drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
   3
   4 #include "i40e.h"
   5
   6 /*********************notification routines***********************/
   7
   8 /**
   9  * i40e_vc_vf_broadcast
  10  * @pf: pointer to the PF structure
  11  * @v_opcode: operation code
  12  * @v_retval: return value
  13  * @msg: pointer to the msg buffer
  14  * @msglen: msg length
  15  *
  16  * send a message to all VFs on a given PF
  17  **/
  18 static void i40e_vc_vf_broadcast(struct i40e_pf *pf,
  19                                  enum virtchnl_ops v_opcode,
  20                                  i40e_status v_retval, u8 *msg,
  21                                  u16 msglen)
  22 {
  23         struct i40e_hw *hw = &pf->hw;
  24         struct i40e_vf *vf = pf->vf;
  25         int i;
  26
  27         for (i = 0; i < pf->num_alloc_vfs; i++, vf++) {
  28                 int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id;
  29                 /* Not all vfs are enabled so skip the ones that are not */
  30                 if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) &&
  31                     !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
  32                         continue;
  33
  34                 /* Ignore return value on purpose - a given VF may fail, but
  35                  * we need to keep going and send to all of them
  36                  */
  37                 i40e_aq_send_msg_to_vf(hw, abs_vf_id, v_opcode, v_retval,
  38                                        msg, msglen, NULL);
  39         }
  40 }
  41
  42 /**
  43  * i40e_vc_link_speed2mbps
  44  * converts i40e_aq_link_speed to integer value of Mbps
  45  * @link_speed: the speed to convert
  46  *
  47  * return the speed as direct value of Mbps.
  48  **/
  49 static u32
  50 i40e_vc_link_speed2mbps(enum i40e_aq_link_speed link_speed)
  51 {
  52         switch (link_speed) {
  53         case I40E_LINK_SPEED_100MB:
  54                 return SPEED_100;
  55         case I40E_LINK_SPEED_1GB:
  56                 return SPEED_1000;
  57         case I40E_LINK_SPEED_2_5GB:
  58                 return SPEED_2500;
  59         case I40E_LINK_SPEED_5GB:
  60                 return SPEED_5000;
  61         case I40E_LINK_SPEED_10GB:
  62                 return SPEED_10000;
  63         case I40E_LINK_SPEED_20GB:
  64                 return SPEED_20000;
  65         case I40E_LINK_SPEED_25GB:
  66                 return SPEED_25000;
  67         case I40E_LINK_SPEED_40GB:
  68                 return SPEED_40000;
  69         case I40E_LINK_SPEED_UNKNOWN:
  70                 return SPEED_UNKNOWN;
  71         }
  72         return SPEED_UNKNOWN;
  73 }
  74
  75 /**
  76  * i40e_set_vf_link_state
  77  * @vf: pointer to the VF structure
  78  * @pfe: pointer to PF event structure
  79  * @ls: pointer to link status structure
  80  *
  81  * set a link state on a single vf
  82  **/
  83 static void i40e_set_vf_link_state(struct i40e_vf *vf,
  84                                    struct virtchnl_pf_event *pfe, struct i40e_link_status *ls)
  85 {
  86         u8 link_status = ls->link_info & I40E_AQ_LINK_UP;
  87
  88         if (vf->link_forced)
  89                 link_status = vf->link_up;
  90
  91         if (vf->driver_caps & VIRTCHNL_VF_CAP_ADV_LINK_SPEED) {
  92                 pfe->event_data.link_event_adv.link_speed = link_status ?
  93                         i40e_vc_link_speed2mbps(ls->link_speed) : 0;
  94                 pfe->event_data.link_event_adv.link_status = link_status;
  95         } else {
  96                 pfe->event_data.link_event.link_speed = link_status ?
  97                         i40e_virtchnl_link_speed(ls->link_speed) : 0;
  98                 pfe->event_data.link_event.link_status = link_status;
  99         }
 100 }
 101
 102 /**
 103  * i40e_vc_notify_vf_link_state
 104  * @vf: pointer to the VF structure
 105  *
 106  * send a link status message to a single VF
 107  **/
 108 static void i40e_vc_notify_vf_link_state(struct i40e_vf *vf)
 109 {
 110         struct virtchnl_pf_event pfe;
 111         struct i40e_pf *pf = vf->pf;
 112         struct i40e_hw *hw = &pf->hw;
 113         struct i40e_link_status *ls = &pf->hw.phy.link_info;
 114         int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id;
 115
 116         pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
 117         pfe.severity = PF_EVENT_SEVERITY_INFO;
 118
 119         i40e_set_vf_link_state(vf, &pfe, ls);
 120
 121         i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT,
 122                                0, (u8 *)&pfe, sizeof(pfe), NULL);
 123 }
 124
 125 /**
 126  * i40e_vc_notify_link_state
 127  * @pf: pointer to the PF structure
 128  *
 129  * send a link status message to all VFs on a given PF
 130  **/
 131 void i40e_vc_notify_link_state(struct i40e_pf *pf)
 132 {
 133         int i;
 134
 135         for (i = 0; i < pf->num_alloc_vfs; i++)
 136                 i40e_vc_notify_vf_link_state(&pf->vf[i]);
 137 }
 138
 139 /**
 140  * i40e_vc_notify_reset
 141  * @pf: pointer to the PF structure
 142  *
 143  * indicate a pending reset to all VFs on a given PF
 144  **/
 145 void i40e_vc_notify_reset(struct i40e_pf *pf)
 146 {
 147         struct virtchnl_pf_event pfe;
 148
 149         pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
 150         pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
 151         i40e_vc_vf_broadcast(pf, VIRTCHNL_OP_EVENT, 0,
 152                              (u8 *)&pfe, sizeof(struct virtchnl_pf_event));
 153 }
 154
 155 /**
 156  * i40e_vc_notify_vf_reset
 157  * @vf: pointer to the VF structure
 158  *
 159  * indicate a pending reset to the given VF
 160  **/
 161 void i40e_vc_notify_vf_reset(struct i40e_vf *vf)
 162 {
 163         struct virtchnl_pf_event pfe;
 164         int abs_vf_id;
 165
 166         /* validate the request */
 167         if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
 168                 return;
 169
 170         /* verify if the VF is in either init or active before proceeding */
 171         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) &&
 172             !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
 173                 return;
 174
 175         abs_vf_id = vf->vf_id + (int)vf->pf->hw.func_caps.vf_base_id;
 176
 177         pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
 178         pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
 179         i40e_aq_send_msg_to_vf(&vf->pf->hw, abs_vf_id, VIRTCHNL_OP_EVENT,
 180                                0, (u8 *)&pfe,
 181                                sizeof(struct virtchnl_pf_event), NULL);
 182 }
 183 /***********************misc routines*****************************/
 184
 185 /**
 186  * i40e_vc_disable_vf
 187  * @vf: pointer to the VF info
 188  *
 189  * Disable the VF through a SW reset.
 190  **/
 191 static inline void i40e_vc_disable_vf(struct i40e_vf *vf)
 192 {
 193         struct i40e_pf *pf = vf->pf;
 194         int i;
 195
 196         i40e_vc_notify_vf_reset(vf);
 197
 198         /* We want to ensure that an actual reset occurs initiated after this
 199          * function was called. However, we do not want to wait forever, so
 200          * we'll give a reasonable time and print a message if we failed to
 201          * ensure a reset.
 202          */
 203         for (i = 0; i < 20; i++) {
 204                 /* If PF is in VFs releasing state reset VF is impossible,
 205                  * so leave it.
 206                  */
 207                 if (test_bit(__I40E_VFS_RELEASING, pf->state))
 208                         return;
 209                 if (i40e_reset_vf(vf, false))
 210                         return;
 211                 usleep_range(10000, 20000);
 212         }
 213
 214         dev_warn(&vf->pf->pdev->dev,
 215                  "Failed to initiate reset for VF %d after 200 milliseconds\n",
 216                  vf->vf_id);
 217 }
 218
 219 /**
 220  * i40e_vc_isvalid_vsi_id
 221  * @vf: pointer to the VF info
 222  * @vsi_id: VF relative VSI id
 223  *
 224  * check for the valid VSI id
 225  **/
 226 static inline bool i40e_vc_isvalid_vsi_id(struct i40e_vf *vf, u16 vsi_id)
 227 {
 228         struct i40e_pf *pf = vf->pf;
 229         struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
 230
 231         return (vsi && (vsi->vf_id == vf->vf_id));
 232 }
 233
 234 /**
 235  * i40e_vc_isvalid_queue_id
 236  * @vf: pointer to the VF info
 237  * @vsi_id: vsi id
 238  * @qid: vsi relative queue id
 239  *
 240  * check for the valid queue id
 241  **/
 242 static inline bool i40e_vc_isvalid_queue_id(struct i40e_vf *vf, u16 vsi_id,
 243                                             u16 qid)
 244 {
 245         struct i40e_pf *pf = vf->pf;
 246         struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
 247
 248         return (vsi && (qid < vsi->alloc_queue_pairs));
 249 }
 250
 251 /**
 252  * i40e_vc_isvalid_vector_id
 253  * @vf: pointer to the VF info
 254  * @vector_id: VF relative vector id
 255  *
 256  * check for the valid vector id
 257  **/
 258 static inline bool i40e_vc_isvalid_vector_id(struct i40e_vf *vf, u32 vector_id)
 259 {
 260         struct i40e_pf *pf = vf->pf;
 261
 262         return vector_id < pf->hw.func_caps.num_msix_vectors_vf;
 263 }
 264
 265 /***********************vf resource mgmt routines*****************/
 266
 267 /**
 268  * i40e_vc_get_pf_queue_id
 269  * @vf: pointer to the VF info
 270  * @vsi_id: id of VSI as provided by the FW
 271  * @vsi_queue_id: vsi relative queue id
 272  *
 273  * return PF relative queue id
 274  **/
 275 static u16 i40e_vc_get_pf_queue_id(struct i40e_vf *vf, u16 vsi_id,
 276                                    u8 vsi_queue_id)
 277 {
 278         struct i40e_pf *pf = vf->pf;
 279         struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
 280         u16 pf_queue_id = I40E_QUEUE_END_OF_LIST;
 281
 282         if (!vsi)
 283                 return pf_queue_id;
 284
 285         if (le16_to_cpu(vsi->info.mapping_flags) &
 286             I40E_AQ_VSI_QUE_MAP_NONCONTIG)
 287                 pf_queue_id =
 288                         le16_to_cpu(vsi->info.queue_mapping[vsi_queue_id]);
 289         else
 290                 pf_queue_id = le16_to_cpu(vsi->info.queue_mapping[0]) +
 291                               vsi_queue_id;
 292
 293         return pf_queue_id;
 294 }
 295
 296 /**
 297  * i40e_get_real_pf_qid
 298  * @vf: pointer to the VF info
 299  * @vsi_id: vsi id
 300  * @queue_id: queue number
 301  *
 302  * wrapper function to get pf_queue_id handling ADq code as well
 303  **/
 304 static u16 i40e_get_real_pf_qid(struct i40e_vf *vf, u16 vsi_id, u16 queue_id)
 305 {
 306         int i;
 307
 308         if (vf->adq_enabled) {
 309                 /* Although VF considers all the queues(can be 1 to 16) as its
 310                  * own but they may actually belong to different VSIs(up to 4).
 311                  * We need to find which queues belongs to which VSI.
 312                  */
 313                 for (i = 0; i < vf->num_tc; i++) {
 314                         if (queue_id < vf->ch[i].num_qps) {
 315                                 vsi_id = vf->ch[i].vsi_id;
 316                                 break;
 317                         }
 318                         /* find right queue id which is relative to a
 319                          * given VSI.
 320                          */
 321                         queue_id -= vf->ch[i].num_qps;
 322                         }
 323                 }
 324
 325         return i40e_vc_get_pf_queue_id(vf, vsi_id, queue_id);
 326 }
 327
 328 /**
 329  * i40e_config_irq_link_list
 330  * @vf: pointer to the VF info
 331  * @vsi_id: id of VSI as given by the FW
 332  * @vecmap: irq map info
 333  *
 334  * configure irq link list from the map
 335  **/
 336 static void i40e_config_irq_link_list(struct i40e_vf *vf, u16 vsi_id,
 337                                       struct virtchnl_vector_map *vecmap)
 338 {
 339         unsigned long linklistmap = 0, tempmap;
 340         struct i40e_pf *pf = vf->pf;
 341         struct i40e_hw *hw = &pf->hw;
 342         u16 vsi_queue_id, pf_queue_id;
 343         enum i40e_queue_type qtype;
 344         u16 next_q, vector_id, size;
 345         u32 reg, reg_idx;
 346         u16 itr_idx = 0;
 347
 348         vector_id = vecmap->vector_id;
 349         /* setup the head */
 350         if (0 == vector_id)
 351                 reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
 352         else
 353                 reg_idx = I40E_VPINT_LNKLSTN(
 354                      ((pf->hw.func_caps.num_msix_vectors_vf - 1) * vf->vf_id) +
 355                      (vector_id - 1));
 356
 357         if (vecmap->rxq_map == 0 && vecmap->txq_map == 0) {
 358                 /* Special case - No queues mapped on this vector */
 359                 wr32(hw, reg_idx, I40E_VPINT_LNKLST0_FIRSTQ_INDX_MASK);
 360                 goto irq_list_done;
 361         }
 362         tempmap = vecmap->rxq_map;
 363         for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
 364                 linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES *
 365                                     vsi_queue_id));
 366         }
 367
 368         tempmap = vecmap->txq_map;
 369         for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
 370                 linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES *
 371                                      vsi_queue_id + 1));
 372         }
 373
 374         size = I40E_MAX_VSI_QP * I40E_VIRTCHNL_SUPPORTED_QTYPES;
 375         next_q = find_first_bit(&linklistmap, size);
 376         if (unlikely(next_q == size))
 377                 goto irq_list_done;
 378
 379         vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES;
 380         qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES;
 381         pf_queue_id = i40e_get_real_pf_qid(vf, vsi_id, vsi_queue_id);
 382         reg = ((qtype << I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT) | pf_queue_id);
 383
 384         wr32(hw, reg_idx, reg);
 385
 386         while (next_q < size) {
 387                 switch (qtype) {
 388                 case I40E_QUEUE_TYPE_RX:
 389                         reg_idx = I40E_QINT_RQCTL(pf_queue_id);
 390                         itr_idx = vecmap->rxitr_idx;
 391                         break;
 392                 case I40E_QUEUE_TYPE_TX:
 393                         reg_idx = I40E_QINT_TQCTL(pf_queue_id);
 394                         itr_idx = vecmap->txitr_idx;
 395                         break;
 396                 default:
 397                         break;
 398                 }
 399
 400                 next_q = find_next_bit(&linklistmap, size, next_q + 1);
 401                 if (next_q < size) {
 402                         vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES;
 403                         qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES;
 404                         pf_queue_id = i40e_get_real_pf_qid(vf,
 405                                                            vsi_id,
 406                                                            vsi_queue_id);
 407                 } else {
 408                         pf_queue_id = I40E_QUEUE_END_OF_LIST;
 409                         qtype = 0;
 410                 }
 411
 412                 /* format for the RQCTL & TQCTL regs is same */
 413                 reg = (vector_id) |
 414                     (qtype << I40E_QINT_RQCTL_NEXTQ_TYPE_SHIFT) |
 415                     (pf_queue_id << I40E_QINT_RQCTL_NEXTQ_INDX_SHIFT) |
 416                     BIT(I40E_QINT_RQCTL_CAUSE_ENA_SHIFT) |
 417                     (itr_idx << I40E_QINT_RQCTL_ITR_INDX_SHIFT);
 418                 wr32(hw, reg_idx, reg);
 419         }
 420
 421         /* if the vf is running in polling mode and using interrupt zero,
 422          * need to disable auto-mask on enabling zero interrupt for VFs.
 423          */
 424         if ((vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) &&
 425             (vector_id == 0)) {
 426                 reg = rd32(hw, I40E_GLINT_CTL);
 427                 if (!(reg & I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK)) {
 428                         reg |= I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK;
 429                         wr32(hw, I40E_GLINT_CTL, reg);
 430                 }
 431         }
 432
 433 irq_list_done:
 434         i40e_flush(hw);
 435 }
 436
 437 /**
 438  * i40e_release_iwarp_qvlist
 439  * @vf: pointer to the VF.
 440  *
 441  **/
 442 static void i40e_release_iwarp_qvlist(struct i40e_vf *vf)
 443 {
 444         struct i40e_pf *pf = vf->pf;
 445         struct virtchnl_iwarp_qvlist_info *qvlist_info = vf->qvlist_info;
 446         u32 msix_vf;
 447         u32 i;
 448
 449         if (!vf->qvlist_info)
 450                 return;
 451
 452         msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
 453         for (i = 0; i < qvlist_info->num_vectors; i++) {
 454                 struct virtchnl_iwarp_qv_info *qv_info;
 455                 u32 next_q_index, next_q_type;
 456                 struct i40e_hw *hw = &pf->hw;
 457                 u32 v_idx, reg_idx, reg;
 458
 459                 qv_info = &qvlist_info->qv_info[i];
 460                 if (!qv_info)
 461                         continue;
 462                 v_idx = qv_info->v_idx;
 463                 if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
 464                         /* Figure out the queue after CEQ and make that the
 465                          * first queue.
 466                          */
 467                         reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
 468                         reg = rd32(hw, I40E_VPINT_CEQCTL(reg_idx));
 469                         next_q_index = (reg & I40E_VPINT_CEQCTL_NEXTQ_INDX_MASK)
 470                                         >> I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT;
 471                         next_q_type = (reg & I40E_VPINT_CEQCTL_NEXTQ_TYPE_MASK)
 472                                         >> I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT;
 473
 474                         reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
 475                         reg = (next_q_index &
 476                                I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
 477                                (next_q_type <<
 478                                I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
 479
 480                         wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
 481                 }
 482         }
 483         kfree(vf->qvlist_info);
 484         vf->qvlist_info = NULL;
 485 }
 486
 487 /**
 488  * i40e_config_iwarp_qvlist
 489  * @vf: pointer to the VF info
 490  * @qvlist_info: queue and vector list
 491  *
 492  * Return 0 on success or < 0 on error
 493  **/
 494 static int i40e_config_iwarp_qvlist(struct i40e_vf *vf,
 495                                     struct virtchnl_iwarp_qvlist_info *qvlist_info)
 496 {
 497         struct i40e_pf *pf = vf->pf;
 498         struct i40e_hw *hw = &pf->hw;
 499         struct virtchnl_iwarp_qv_info *qv_info;
 500         u32 v_idx, i, reg_idx, reg;
 501         u32 next_q_idx, next_q_type;
 502         u32 msix_vf;
 503         int ret = 0;
 504
 505         msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
 506
 507         if (qvlist_info->num_vectors > msix_vf) {
 508                 dev_warn(&pf->pdev->dev,
 509                          "Incorrect number of iwarp vectors %u. Maximum %u allowed.\n",
 510                          qvlist_info->num_vectors,
 511                          msix_vf);
 512                 ret = -EINVAL;
 513                 goto err_out;
 514         }
 515
 516         kfree(vf->qvlist_info);
 517         vf->qvlist_info = kzalloc(struct_size(vf->qvlist_info, qv_info,
 518                                               qvlist_info->num_vectors - 1),
 519                                   GFP_KERNEL);
 520         if (!vf->qvlist_info) {
 521                 ret = -ENOMEM;
 522                 goto err_out;
 523         }
 524         vf->qvlist_info->num_vectors = qvlist_info->num_vectors;
 525
 526         msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
 527         for (i = 0; i < qvlist_info->num_vectors; i++) {
 528                 qv_info = &qvlist_info->qv_info[i];
 529                 if (!qv_info)
 530                         continue;
 531
 532                 /* Validate vector id belongs to this vf */
 533                 if (!i40e_vc_isvalid_vector_id(vf, qv_info->v_idx)) {
 534                         ret = -EINVAL;
 535                         goto err_free;
 536                 }
 537
 538                 v_idx = qv_info->v_idx;
 539
 540                 vf->qvlist_info->qv_info[i] = *qv_info;
 541
 542                 reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
 543                 /* We might be sharing the interrupt, so get the first queue
 544                  * index and type, push it down the list by adding the new
 545                  * queue on top. Also link it with the new queue in CEQCTL.
 546                  */
 547                 reg = rd32(hw, I40E_VPINT_LNKLSTN(reg_idx));
 548                 next_q_idx = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) >>
 549                                 I40E_VPINT_LNKLSTN_FIRSTQ_INDX_SHIFT);
 550                 next_q_type = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK) >>
 551                                 I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
 552
 553                 if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
 554                         reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
 555                         reg = (I40E_VPINT_CEQCTL_CAUSE_ENA_MASK |
 556                         (v_idx << I40E_VPINT_CEQCTL_MSIX_INDX_SHIFT) |
 557                         (qv_info->itr_idx << I40E_VPINT_CEQCTL_ITR_INDX_SHIFT) |
 558                         (next_q_type << I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT) |
 559                         (next_q_idx << I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT));
 560                         wr32(hw, I40E_VPINT_CEQCTL(reg_idx), reg);
 561
 562                         reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
 563                         reg = (qv_info->ceq_idx &
 564                                I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
 565                                (I40E_QUEUE_TYPE_PE_CEQ <<
 566                                I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
 567                         wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
 568                 }
 569
 570                 if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
 571                         reg = (I40E_VPINT_AEQCTL_CAUSE_ENA_MASK |
 572                         (v_idx << I40E_VPINT_AEQCTL_MSIX_INDX_SHIFT) |
 573                         (qv_info->itr_idx << I40E_VPINT_AEQCTL_ITR_INDX_SHIFT));
 574
 575                         wr32(hw, I40E_VPINT_AEQCTL(vf->vf_id), reg);
 576                 }
 577         }
 578
 579         return 0;
 580 err_free:
 581         kfree(vf->qvlist_info);
 582         vf->qvlist_info = NULL;
 583 err_out:
 584         return ret;
 585 }
 586
 587 /**
 588  * i40e_config_vsi_tx_queue
 589  * @vf: pointer to the VF info
 590  * @vsi_id: id of VSI as provided by the FW
 591  * @vsi_queue_id: vsi relative queue index
 592  * @info: config. info
 593  *
 594  * configure tx queue
 595  **/
 596 static int i40e_config_vsi_tx_queue(struct i40e_vf *vf, u16 vsi_id,
 597                                     u16 vsi_queue_id,
 598                                     struct virtchnl_txq_info *info)
 599 {
 600         struct i40e_pf *pf = vf->pf;
 601         struct i40e_hw *hw = &pf->hw;
 602         struct i40e_hmc_obj_txq tx_ctx;
 603         struct i40e_vsi *vsi;
 604         u16 pf_queue_id;
 605         u32 qtx_ctl;
 606         int ret = 0;
 607
 608         if (!i40e_vc_isvalid_vsi_id(vf, info->vsi_id)) {
 609                 ret = -ENOENT;
 610                 goto error_context;
 611         }
 612         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id);
 613         vsi = i40e_find_vsi_from_id(pf, vsi_id);
 614         if (!vsi) {
 615                 ret = -ENOENT;
 616                 goto error_context;
 617         }
 618
 619         /* clear the context structure first */
 620         memset(&tx_ctx, 0, sizeof(struct i40e_hmc_obj_txq));
 621
 622         /* only set the required fields */
 623         tx_ctx.base = info->dma_ring_addr / 128;
 624         tx_ctx.qlen = info->ring_len;
 625         tx_ctx.rdylist = le16_to_cpu(vsi->info.qs_handle[0]);
 626         tx_ctx.rdylist_act = 0;
 627         tx_ctx.head_wb_ena = info->headwb_enabled;
 628         tx_ctx.head_wb_addr = info->dma_headwb_addr;
 629
 630         /* clear the context in the HMC */
 631         ret = i40e_clear_lan_tx_queue_context(hw, pf_queue_id);
 632         if (ret) {
 633                 dev_err(&pf->pdev->dev,
 634                         "Failed to clear VF LAN Tx queue context %d, error: %d\n",
 635                         pf_queue_id, ret);
 636                 ret = -ENOENT;
 637                 goto error_context;
 638         }
 639
 640         /* set the context in the HMC */
 641         ret = i40e_set_lan_tx_queue_context(hw, pf_queue_id, &tx_ctx);
 642         if (ret) {
 643                 dev_err(&pf->pdev->dev,
 644                         "Failed to set VF LAN Tx queue context %d error: %d\n",
 645                         pf_queue_id, ret);
 646                 ret = -ENOENT;
 647                 goto error_context;
 648         }
 649
 650         /* associate this queue with the PCI VF function */
 651         qtx_ctl = I40E_QTX_CTL_VF_QUEUE;
 652         qtx_ctl |= ((hw->pf_id << I40E_QTX_CTL_PF_INDX_SHIFT)
 653                     & I40E_QTX_CTL_PF_INDX_MASK);
 654         qtx_ctl |= (((vf->vf_id + hw->func_caps.vf_base_id)
 655                      << I40E_QTX_CTL_VFVM_INDX_SHIFT)
 656                     & I40E_QTX_CTL_VFVM_INDX_MASK);
 657         wr32(hw, I40E_QTX_CTL(pf_queue_id), qtx_ctl);
 658         i40e_flush(hw);
 659
 660 error_context:
 661         return ret;
 662 }
 663
 664 /**
 665  * i40e_config_vsi_rx_queue
 666  * @vf: pointer to the VF info
 667  * @vsi_id: id of VSI  as provided by the FW
 668  * @vsi_queue_id: vsi relative queue index
 669  * @info: config. info
 670  *
 671  * configure rx queue
 672  **/
 673 static int i40e_config_vsi_rx_queue(struct i40e_vf *vf, u16 vsi_id,
 674                                     u16 vsi_queue_id,
 675                                     struct virtchnl_rxq_info *info)
 676 {
 677         struct i40e_pf *pf = vf->pf;
 678         struct i40e_hw *hw = &pf->hw;
 679         struct i40e_hmc_obj_rxq rx_ctx;
 680         u16 pf_queue_id;
 681         int ret = 0;
 682
 683         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id);
 684
 685         /* clear the context structure first */
 686         memset(&rx_ctx, 0, sizeof(struct i40e_hmc_obj_rxq));
 687
 688         /* only set the required fields */
 689         rx_ctx.base = info->dma_ring_addr / 128;
 690         rx_ctx.qlen = info->ring_len;
 691
 692         if (info->splithdr_enabled) {
 693                 rx_ctx.hsplit_0 = I40E_RX_SPLIT_L2      |
 694                                   I40E_RX_SPLIT_IP      |
 695                                   I40E_RX_SPLIT_TCP_UDP |
 696                                   I40E_RX_SPLIT_SCTP;
 697                 /* header length validation */
 698                 if (info->hdr_size > ((2 * 1024) - 64)) {
 699                         ret = -EINVAL;
 700                         goto error_param;
 701                 }
 702                 rx_ctx.hbuff = info->hdr_size >> I40E_RXQ_CTX_HBUFF_SHIFT;
 703
 704                 /* set split mode 10b */
 705                 rx_ctx.dtype = I40E_RX_DTYPE_HEADER_SPLIT;
 706         }
 707
 708         /* databuffer length validation */
 709         if (info->databuffer_size > ((16 * 1024) - 128)) {
 710                 ret = -EINVAL;
 711                 goto error_param;
 712         }
 713         rx_ctx.dbuff = info->databuffer_size >> I40E_RXQ_CTX_DBUFF_SHIFT;
 714
 715         /* max pkt. length validation */
 716         if (info->max_pkt_size >= (16 * 1024) || info->max_pkt_size < 64) {
 717                 ret = -EINVAL;
 718                 goto error_param;
 719         }
 720         rx_ctx.rxmax = info->max_pkt_size;
 721
 722         /* enable 32bytes desc always */
 723         rx_ctx.dsize = 1;
 724
 725         /* default values */
 726         rx_ctx.lrxqthresh = 1;
 727         rx_ctx.crcstrip = 1;
 728         rx_ctx.prefena = 1;
 729         rx_ctx.l2tsel = 1;
 730
 731         /* clear the context in the HMC */
 732         ret = i40e_clear_lan_rx_queue_context(hw, pf_queue_id);
 733         if (ret) {
 734                 dev_err(&pf->pdev->dev,
 735                         "Failed to clear VF LAN Rx queue context %d, error: %d\n",
 736                         pf_queue_id, ret);
 737                 ret = -ENOENT;
 738                 goto error_param;
 739         }
 740
 741         /* set the context in the HMC */
 742         ret = i40e_set_lan_rx_queue_context(hw, pf_queue_id, &rx_ctx);
 743         if (ret) {
 744                 dev_err(&pf->pdev->dev,
 745                         "Failed to set VF LAN Rx queue context %d error: %d\n",
 746                         pf_queue_id, ret);
 747                 ret = -ENOENT;
 748                 goto error_param;
 749         }
 750
 751 error_param:
 752         return ret;
 753 }
 754
 755 /**
 756  * i40e_alloc_vsi_res
 757  * @vf: pointer to the VF info
 758  * @idx: VSI index, applies only for ADq mode, zero otherwise
 759  *
 760  * alloc VF vsi context & resources
 761  **/
 762 static int i40e_alloc_vsi_res(struct i40e_vf *vf, u8 idx)
 763 {
 764         struct i40e_mac_filter *f = NULL;
 765         struct i40e_pf *pf = vf->pf;
 766         struct i40e_vsi *vsi;
 767         u64 max_tx_rate = 0;
 768         int ret = 0;
 769
 770         vsi = i40e_vsi_setup(pf, I40E_VSI_SRIOV, pf->vsi[pf->lan_vsi]->seid,
 771                              vf->vf_id);
 772
 773         if (!vsi) {
 774                 dev_err(&pf->pdev->dev,
 775                         "add vsi failed for VF %d, aq_err %d\n",
 776                         vf->vf_id, pf->hw.aq.asq_last_status);
 777                 ret = -ENOENT;
 778                 goto error_alloc_vsi_res;
 779         }
 780
 781         if (!idx) {
 782                 u64 hena = i40e_pf_get_default_rss_hena(pf);
 783                 u8 broadcast[ETH_ALEN];
 784
 785                 vf->lan_vsi_idx = vsi->idx;
 786                 vf->lan_vsi_id = vsi->id;
 787                 /* If the port VLAN has been configured and then the
 788                  * VF driver was removed then the VSI port VLAN
 789                  * configuration was destroyed.  Check if there is
 790                  * a port VLAN and restore the VSI configuration if
 791                  * needed.
 792                  */
 793                 if (vf->port_vlan_id)
 794                         i40e_vsi_add_pvid(vsi, vf->port_vlan_id);
 795
 796                 spin_lock_bh(&vsi->mac_filter_hash_lock);
 797                 if (is_valid_ether_addr(vf->default_lan_addr.addr)) {
 798                         f = i40e_add_mac_filter(vsi,
 799                                                 vf->default_lan_addr.addr);
 800                         if (!f)
 801                                 dev_info(&pf->pdev->dev,
 802                                          "Could not add MAC filter %pM for VF %d\n",
 803                                         vf->default_lan_addr.addr, vf->vf_id);
 804                 }
 805                 eth_broadcast_addr(broadcast);
 806                 f = i40e_add_mac_filter(vsi, broadcast);
 807                 if (!f)
 808                         dev_info(&pf->pdev->dev,
 809                                  "Could not allocate VF broadcast filter\n");
 810                 spin_unlock_bh(&vsi->mac_filter_hash_lock);
 811                 wr32(&pf->hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)hena);
 812                 wr32(&pf->hw, I40E_VFQF_HENA1(1, vf->vf_id), (u32)(hena >> 32));
 813                 /* program mac filter only for VF VSI */
 814                 ret = i40e_sync_vsi_filters(vsi);
 815                 if (ret)
 816                         dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
 817         }
 818
 819         /* storing VSI index and id for ADq and don't apply the mac filter */
 820         if (vf->adq_enabled) {
 821                 vf->ch[idx].vsi_idx = vsi->idx;
 822                 vf->ch[idx].vsi_id = vsi->id;
 823         }
 824
 825         /* Set VF bandwidth if specified */
 826         if (vf->tx_rate) {
 827                 max_tx_rate = vf->tx_rate;
 828         } else if (vf->ch[idx].max_tx_rate) {
 829                 max_tx_rate = vf->ch[idx].max_tx_rate;
 830         }
 831
 832         if (max_tx_rate) {
 833                 max_tx_rate = div_u64(max_tx_rate, I40E_BW_CREDIT_DIVISOR);
 834                 ret = i40e_aq_config_vsi_bw_limit(&pf->hw, vsi->seid,
 835                                                   max_tx_rate, 0, NULL);
 836                 if (ret)
 837                         dev_err(&pf->pdev->dev, "Unable to set tx rate, VF %d, error code %d.\n",
 838                                 vf->vf_id, ret);
 839         }
 840
 841 error_alloc_vsi_res:
 842         return ret;
 843 }
 844
 845 /**
 846  * i40e_map_pf_queues_to_vsi
 847  * @vf: pointer to the VF info
 848  *
 849  * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This
 850  * function takes care of first part VSILAN_QTABLE, mapping pf queues to VSI.
 851  **/
 852 static void i40e_map_pf_queues_to_vsi(struct i40e_vf *vf)
 853 {
 854         struct i40e_pf *pf = vf->pf;
 855         struct i40e_hw *hw = &pf->hw;
 856         u32 reg, num_tc = 1; /* VF has at least one traffic class */
 857         u16 vsi_id, qps;
 858         int i, j;
 859
 860         if (vf->adq_enabled)
 861                 num_tc = vf->num_tc;
 862
 863         for (i = 0; i < num_tc; i++) {
 864                 if (vf->adq_enabled) {
 865                         qps = vf->ch[i].num_qps;
 866                         vsi_id =  vf->ch[i].vsi_id;
 867                 } else {
 868                         qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
 869                         vsi_id = vf->lan_vsi_id;
 870                 }
 871
 872                 for (j = 0; j < 7; j++) {
 873                         if (j * 2 >= qps) {
 874                                 /* end of list */
 875                                 reg = 0x07FF07FF;
 876                         } else {
 877                                 u16 qid = i40e_vc_get_pf_queue_id(vf,
 878                                                                   vsi_id,
 879                                                                   j * 2);
 880                                 reg = qid;
 881                                 qid = i40e_vc_get_pf_queue_id(vf, vsi_id,
 882                                                               (j * 2) + 1);
 883                                 reg |= qid << 16;
 884                         }
 885                         i40e_write_rx_ctl(hw,
 886                                           I40E_VSILAN_QTABLE(j, vsi_id),
 887                                           reg);
 888                 }
 889         }
 890 }
 891
 892 /**
 893  * i40e_map_pf_to_vf_queues
 894  * @vf: pointer to the VF info
 895  *
 896  * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This
 897  * function takes care of the second part VPLAN_QTABLE & completes VF mappings.
 898  **/
 899 static void i40e_map_pf_to_vf_queues(struct i40e_vf *vf)
 900 {
 901         struct i40e_pf *pf = vf->pf;
 902         struct i40e_hw *hw = &pf->hw;
 903         u32 reg, total_qps = 0;
 904         u32 qps, num_tc = 1; /* VF has at least one traffic class */
 905         u16 vsi_id, qid;
 906         int i, j;
 907
 908         if (vf->adq_enabled)
 909                 num_tc = vf->num_tc;
 910
 911         for (i = 0; i < num_tc; i++) {
 912                 if (vf->adq_enabled) {
 913                         qps = vf->ch[i].num_qps;
 914                         vsi_id =  vf->ch[i].vsi_id;
 915                 } else {
 916                         qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
 917                         vsi_id = vf->lan_vsi_id;
 918                 }
 919
 920                 for (j = 0; j < qps; j++) {
 921                         qid = i40e_vc_get_pf_queue_id(vf, vsi_id, j);
 922
 923                         reg = (qid & I40E_VPLAN_QTABLE_QINDEX_MASK);
 924                         wr32(hw, I40E_VPLAN_QTABLE(total_qps, vf->vf_id),
 925                              reg);
 926                         total_qps++;
 927                 }
 928         }
 929 }
 930
 931 /**
 932  * i40e_enable_vf_mappings
 933  * @vf: pointer to the VF info
 934  *
 935  * enable VF mappings
 936  **/
 937 static void i40e_enable_vf_mappings(struct i40e_vf *vf)
 938 {
 939         struct i40e_pf *pf = vf->pf;
 940         struct i40e_hw *hw = &pf->hw;
 941         u32 reg;
 942
 943         /* Tell the hardware we're using noncontiguous mapping. HW requires
 944          * that VF queues be mapped using this method, even when they are
 945          * contiguous in real life
 946          */
 947         i40e_write_rx_ctl(hw, I40E_VSILAN_QBASE(vf->lan_vsi_id),
 948                           I40E_VSILAN_QBASE_VSIQTABLE_ENA_MASK);
 949
 950         /* enable VF vplan_qtable mappings */
 951         reg = I40E_VPLAN_MAPENA_TXRX_ENA_MASK;
 952         wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), reg);
 953
 954         i40e_map_pf_to_vf_queues(vf);
 955         i40e_map_pf_queues_to_vsi(vf);
 956
 957         i40e_flush(hw);
 958 }
 959
 960 /**
 961  * i40e_disable_vf_mappings
 962  * @vf: pointer to the VF info
 963  *
 964  * disable VF mappings
 965  **/
 966 static void i40e_disable_vf_mappings(struct i40e_vf *vf)
 967 {
 968         struct i40e_pf *pf = vf->pf;
 969         struct i40e_hw *hw = &pf->hw;
 970         int i;
 971
 972         /* disable qp mappings */
 973         wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), 0);
 974         for (i = 0; i < I40E_MAX_VSI_QP; i++)
 975                 wr32(hw, I40E_VPLAN_QTABLE(i, vf->vf_id),
 976                      I40E_QUEUE_END_OF_LIST);
 977         i40e_flush(hw);
 978 }
 979
 980 /**
 981  * i40e_free_vf_res
 982  * @vf: pointer to the VF info
 983  *
 984  * free VF resources
 985  **/
 986 static void i40e_free_vf_res(struct i40e_vf *vf)
 987 {
 988         struct i40e_pf *pf = vf->pf;
 989         struct i40e_hw *hw = &pf->hw;
 990         u32 reg_idx, reg;
 991         int i, j, msix_vf;
 992
 993         /* Start by disabling VF's configuration API to prevent the OS from
 994          * accessing the VF's VSI after it's freed / invalidated.
 995          */
 996         clear_bit(I40E_VF_STATE_INIT, &vf->vf_states);
 997
 998         /* It's possible the VF had requeuested more queues than the default so
 999          * do the accounting here when we're about to free them.
1000          */
1001         if (vf->num_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF) {
1002                 pf->queues_left += vf->num_queue_pairs -
1003                                    I40E_DEFAULT_QUEUES_PER_VF;
1004         }
1005
1006         /* free vsi & disconnect it from the parent uplink */
1007         if (vf->lan_vsi_idx) {
1008                 i40e_vsi_release(pf->vsi[vf->lan_vsi_idx]);
1009                 vf->lan_vsi_idx = 0;
1010                 vf->lan_vsi_id = 0;
1011         }
1012
1013         /* do the accounting and remove additional ADq VSI's */
1014         if (vf->adq_enabled && vf->ch[0].vsi_idx) {
1015                 for (j = 0; j < vf->num_tc; j++) {
1016                         /* At this point VSI0 is already released so don't
1017                          * release it again and only clear their values in
1018                          * structure variables
1019                          */
1020                         if (j)
1021                                 i40e_vsi_release(pf->vsi[vf->ch[j].vsi_idx]);
1022                         vf->ch[j].vsi_idx = 0;
1023                         vf->ch[j].vsi_id = 0;
1024                 }
1025         }
1026         msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
1027
1028         /* disable interrupts so the VF starts in a known state */
1029         for (i = 0; i < msix_vf; i++) {
1030                 /* format is same for both registers */
1031                 if (0 == i)
1032                         reg_idx = I40E_VFINT_DYN_CTL0(vf->vf_id);
1033                 else
1034                         reg_idx = I40E_VFINT_DYN_CTLN(((msix_vf - 1) *
1035                                                       (vf->vf_id))
1036                                                      + (i - 1));
1037                 wr32(hw, reg_idx, I40E_VFINT_DYN_CTLN_CLEARPBA_MASK);
1038                 i40e_flush(hw);
1039         }
1040
1041         /* clear the irq settings */
1042         for (i = 0; i < msix_vf; i++) {
1043                 /* format is same for both registers */
1044                 if (0 == i)
1045                         reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
1046                 else
1047                         reg_idx = I40E_VPINT_LNKLSTN(((msix_vf - 1) *
1048                                                       (vf->vf_id))
1049                                                      + (i - 1));
1050                 reg = (I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK |
1051                        I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK);
1052                 wr32(hw, reg_idx, reg);
1053                 i40e_flush(hw);
1054         }
1055         /* reset some of the state variables keeping track of the resources */
1056         vf->num_queue_pairs = 0;
1057         clear_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states);
1058         clear_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states);
1059 }
1060
1061 /**
1062  * i40e_alloc_vf_res
1063  * @vf: pointer to the VF info
1064  *
1065  * allocate VF resources
1066  **/
1067 static int i40e_alloc_vf_res(struct i40e_vf *vf)
1068 {
1069         struct i40e_pf *pf = vf->pf;
1070         int total_queue_pairs = 0;
1071         int ret, idx;
1072
1073         if (vf->num_req_queues &&
1074             vf->num_req_queues <= pf->queues_left + I40E_DEFAULT_QUEUES_PER_VF)
1075                 pf->num_vf_qps = vf->num_req_queues;
1076         else
1077                 pf->num_vf_qps = I40E_DEFAULT_QUEUES_PER_VF;
1078
1079         /* allocate hw vsi context & associated resources */
1080         ret = i40e_alloc_vsi_res(vf, 0);
1081         if (ret)
1082                 goto error_alloc;
1083         total_queue_pairs += pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
1084
1085         /* allocate additional VSIs based on tc information for ADq */
1086         if (vf->adq_enabled) {
1087                 if (pf->queues_left >=
1088                     (I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF)) {
1089                         /* TC 0 always belongs to VF VSI */
1090                         for (idx = 1; idx < vf->num_tc; idx++) {
1091                                 ret = i40e_alloc_vsi_res(vf, idx);
1092                                 if (ret)
1093                                         goto error_alloc;
1094                         }
1095                         /* send correct number of queues */
1096                         total_queue_pairs = I40E_MAX_VF_QUEUES;
1097                 } else {
1098                         dev_info(&pf->pdev->dev, "VF %d: Not enough queues to allocate, disabling ADq\n",
1099                                  vf->vf_id);
1100                         vf->adq_enabled = false;
1101                 }
1102         }
1103
1104         /* We account for each VF to get a default number of queue pairs.  If
1105          * the VF has now requested more, we need to account for that to make
1106          * certain we never request more queues than we actually have left in
1107          * HW.
1108          */
1109         if (total_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF)
1110                 pf->queues_left -=
1111                         total_queue_pairs - I40E_DEFAULT_QUEUES_PER_VF;
1112
1113         if (vf->trusted)
1114                 set_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
1115         else
1116                 clear_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
1117
1118         /* store the total qps number for the runtime
1119          * VF req validation
1120          */
1121         vf->num_queue_pairs = total_queue_pairs;
1122
1123         /* VF is now completely initialized */
1124         set_bit(I40E_VF_STATE_INIT, &vf->vf_states);
1125
1126 error_alloc:
1127         if (ret)
1128                 i40e_free_vf_res(vf);
1129
1130         return ret;
1131 }
1132
1133 #define VF_DEVICE_STATUS 0xAA
1134 #define VF_TRANS_PENDING_MASK 0x20
1135 /**
1136  * i40e_quiesce_vf_pci
1137  * @vf: pointer to the VF structure
1138  *
1139  * Wait for VF PCI transactions to be cleared after reset. Returns -EIO
1140  * if the transactions never clear.
1141  **/
1142 static int i40e_quiesce_vf_pci(struct i40e_vf *vf)
1143 {
1144         struct i40e_pf *pf = vf->pf;
1145         struct i40e_hw *hw = &pf->hw;
1146         int vf_abs_id, i;
1147         u32 reg;
1148
1149         vf_abs_id = vf->vf_id + hw->func_caps.vf_base_id;
1150
1151         wr32(hw, I40E_PF_PCI_CIAA,
1152              VF_DEVICE_STATUS | (vf_abs_id << I40E_PF_PCI_CIAA_VF_NUM_SHIFT));
1153         for (i = 0; i < 100; i++) {
1154                 reg = rd32(hw, I40E_PF_PCI_CIAD);
1155                 if ((reg & VF_TRANS_PENDING_MASK) == 0)
1156                         return 0;
1157                 udelay(1);
1158         }
1159         return -EIO;
1160 }
1161
1162 /**
1163  * __i40e_getnum_vf_vsi_vlan_filters
1164  * @vsi: pointer to the vsi
1165  *
1166  * called to get the number of VLANs offloaded on this VF
1167  **/
1168 static int __i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi)
1169 {
1170         struct i40e_mac_filter *f;
1171         u16 num_vlans = 0, bkt;
1172
1173         hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
1174                 if (f->vlan >= 0 && f->vlan <= I40E_MAX_VLANID)
1175                         num_vlans++;
1176         }
1177
1178         return num_vlans;
1179 }
1180
1181 /**
1182  * i40e_getnum_vf_vsi_vlan_filters
1183  * @vsi: pointer to the vsi
1184  *
1185  * wrapper for __i40e_getnum_vf_vsi_vlan_filters() with spinlock held
1186  **/
1187 static int i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi)
1188 {
1189         int num_vlans;
1190
1191         spin_lock_bh(&vsi->mac_filter_hash_lock);
1192         num_vlans = __i40e_getnum_vf_vsi_vlan_filters(vsi);
1193         spin_unlock_bh(&vsi->mac_filter_hash_lock);
1194
1195         return num_vlans;
1196 }
1197
1198 /**
1199  * i40e_get_vlan_list_sync
1200  * @vsi: pointer to the VSI
1201  * @num_vlans: number of VLANs in mac_filter_hash, returned to caller
1202  * @vlan_list: list of VLANs present in mac_filter_hash, returned to caller.
1203  *             This array is allocated here, but has to be freed in caller.
1204  *
1205  * Called to get number of VLANs and VLAN list present in mac_filter_hash.
1206  **/
1207 static void i40e_get_vlan_list_sync(struct i40e_vsi *vsi, u16 *num_vlans,
1208                                     s16 **vlan_list)
1209 {
1210         struct i40e_mac_filter *f;
1211         int i = 0;
1212         int bkt;
1213
1214         spin_lock_bh(&vsi->mac_filter_hash_lock);
1215         *num_vlans = __i40e_getnum_vf_vsi_vlan_filters(vsi);
1216         *vlan_list = kcalloc(*num_vlans, sizeof(**vlan_list), GFP_ATOMIC);
1217         if (!(*vlan_list))
1218                 goto err;
1219
1220         hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
1221                 if (f->vlan < 0 || f->vlan > I40E_MAX_VLANID)
1222                         continue;
1223                 (*vlan_list)[i++] = f->vlan;
1224         }
1225 err:
1226         spin_unlock_bh(&vsi->mac_filter_hash_lock);
1227 }
1228
1229 /**
1230  * i40e_set_vsi_promisc
1231  * @vf: pointer to the VF struct
1232  * @seid: VSI number
1233  * @multi_enable: set MAC L2 layer multicast promiscuous enable/disable
1234  *                for a given VLAN
1235  * @unicast_enable: set MAC L2 layer unicast promiscuous enable/disable
1236  *                  for a given VLAN
1237  * @vl: List of VLANs - apply filter for given VLANs
1238  * @num_vlans: Number of elements in @vl
1239  **/
1240 static i40e_status
1241 i40e_set_vsi_promisc(struct i40e_vf *vf, u16 seid, bool multi_enable,
1242                      bool unicast_enable, s16 *vl, u16 num_vlans)
1243 {
1244         i40e_status aq_ret, aq_tmp = 0;
1245         struct i40e_pf *pf = vf->pf;
1246         struct i40e_hw *hw = &pf->hw;
1247         int i;
1248
1249         /* No VLAN to set promisc on, set on VSI */
1250         if (!num_vlans || !vl) {
1251                 aq_ret = i40e_aq_set_vsi_multicast_promiscuous(hw, seid,
1252                                                                multi_enable,
1253                                                                NULL);
1254                 if (aq_ret) {
1255                         int aq_err = pf->hw.aq.asq_last_status;
1256
1257                         dev_err(&pf->pdev->dev,
1258                                 "VF %d failed to set multicast promiscuous mode err %s aq_err %s\n",
1259                                 vf->vf_id,
1260                                 i40e_stat_str(&pf->hw, aq_ret),
1261                                 i40e_aq_str(&pf->hw, aq_err));
1262
1263                         return aq_ret;
1264                 }
1265
1266                 aq_ret = i40e_aq_set_vsi_unicast_promiscuous(hw, seid,
1267                                                              unicast_enable,
1268                                                              NULL, true);
1269
1270                 if (aq_ret) {
1271                         int aq_err = pf->hw.aq.asq_last_status;
1272
1273                         dev_err(&pf->pdev->dev,
1274                                 "VF %d failed to set unicast promiscuous mode err %s aq_err %s\n",
1275                                 vf->vf_id,
1276                                 i40e_stat_str(&pf->hw, aq_ret),
1277                                 i40e_aq_str(&pf->hw, aq_err));
1278                 }
1279
1280                 return aq_ret;
1281         }
1282
1283         for (i = 0; i < num_vlans; i++) {
1284                 aq_ret = i40e_aq_set_vsi_mc_promisc_on_vlan(hw, seid,
1285                                                             multi_enable,
1286                                                             vl[i], NULL);
1287                 if (aq_ret) {
1288                         int aq_err = pf->hw.aq.asq_last_status;
1289
1290                         dev_err(&pf->pdev->dev,
1291                                 "VF %d failed to set multicast promiscuous mode err %s aq_err %s\n",
1292                                 vf->vf_id,
1293                                 i40e_stat_str(&pf->hw, aq_ret),
1294                                 i40e_aq_str(&pf->hw, aq_err));
1295
1296                         if (!aq_tmp)
1297                                 aq_tmp = aq_ret;
1298                 }
1299
1300                 aq_ret = i40e_aq_set_vsi_uc_promisc_on_vlan(hw, seid,
1301                                                             unicast_enable,
1302                                                             vl[i], NULL);
1303                 if (aq_ret) {
1304                         int aq_err = pf->hw.aq.asq_last_status;
1305
1306                         dev_err(&pf->pdev->dev,
1307                                 "VF %d failed to set unicast promiscuous mode err %s aq_err %s\n",
1308                                 vf->vf_id,
1309                                 i40e_stat_str(&pf->hw, aq_ret),
1310                                 i40e_aq_str(&pf->hw, aq_err));
1311
1312                         if (!aq_tmp)
1313                                 aq_tmp = aq_ret;
1314                 }
1315         }
1316
1317         if (aq_tmp)
1318                 aq_ret = aq_tmp;
1319
1320         return aq_ret;
1321 }
1322
1323 /**
1324  * i40e_config_vf_promiscuous_mode
1325  * @vf: pointer to the VF info
1326  * @vsi_id: VSI id
1327  * @allmulti: set MAC L2 layer multicast promiscuous enable/disable
1328  * @alluni: set MAC L2 layer unicast promiscuous enable/disable
1329  *
1330  * Called from the VF to configure the promiscuous mode of
1331  * VF vsis and from the VF reset path to reset promiscuous mode.
1332  **/
1333 static i40e_status i40e_config_vf_promiscuous_mode(struct i40e_vf *vf,
1334                                                    u16 vsi_id,
1335                                                    bool allmulti,
1336                                                    bool alluni)
1337 {
1338         i40e_status aq_ret = I40E_SUCCESS;
1339         struct i40e_pf *pf = vf->pf;
1340         struct i40e_vsi *vsi;
1341         u16 num_vlans;
1342         s16 *vl;
1343
1344         vsi = i40e_find_vsi_from_id(pf, vsi_id);
1345         if (!i40e_vc_isvalid_vsi_id(vf, vsi_id) || !vsi)
1346                 return I40E_ERR_PARAM;
1347
1348         if (vf->port_vlan_id) {
1349                 aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti,
1350                                               alluni, &vf->port_vlan_id, 1);
1351                 return aq_ret;
1352         } else if (i40e_getnum_vf_vsi_vlan_filters(vsi)) {
1353                 i40e_get_vlan_list_sync(vsi, &num_vlans, &vl);
1354
1355                 if (!vl)
1356                         return I40E_ERR_NO_MEMORY;
1357
1358                 aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti, alluni,
1359                                               vl, num_vlans);
1360                 kfree(vl);
1361                 return aq_ret;
1362         }
1363
1364         /* no VLANs to set on, set on VSI */
1365         aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti, alluni,
1366                                       NULL, 0);
1367         return aq_ret;
1368 }
1369
1370 /**
1371  * i40e_trigger_vf_reset
1372  * @vf: pointer to the VF structure
1373  * @flr: VFLR was issued or not
1374  *
1375  * Trigger hardware to start a reset for a particular VF. Expects the caller
1376  * to wait the proper amount of time to allow hardware to reset the VF before
1377  * it cleans up and restores VF functionality.
1378  **/
1379 static void i40e_trigger_vf_reset(struct i40e_vf *vf, bool flr)
1380 {
1381         struct i40e_pf *pf = vf->pf;
1382         struct i40e_hw *hw = &pf->hw;
1383         u32 reg, reg_idx, bit_idx;
1384
1385         /* warn the VF */
1386         clear_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
1387
1388         /* Disable VF's configuration API during reset. The flag is re-enabled
1389          * in i40e_alloc_vf_res(), when it's safe again to access VF's VSI.
1390          * It's normally disabled in i40e_free_vf_res(), but it's safer
1391          * to do it earlier to give some time to finish to any VF config
1392          * functions that may still be running at this point.
1393          */
1394         clear_bit(I40E_VF_STATE_INIT, &vf->vf_states);
1395
1396         /* In the case of a VFLR, the HW has already reset the VF and we
1397          * just need to clean up, so don't hit the VFRTRIG register.
1398          */
1399         if (!flr) {
1400                 /* reset VF using VPGEN_VFRTRIG reg */
1401                 reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
1402                 reg |= I40E_VPGEN_VFRTRIG_VFSWR_MASK;
1403                 wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
1404                 i40e_flush(hw);
1405         }
1406         /* clear the VFLR bit in GLGEN_VFLRSTAT */
1407         reg_idx = (hw->func_caps.vf_base_id + vf->vf_id) / 32;
1408         bit_idx = (hw->func_caps.vf_base_id + vf->vf_id) % 32;
1409         wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
1410         i40e_flush(hw);
1411
1412         if (i40e_quiesce_vf_pci(vf))
1413                 dev_err(&pf->pdev->dev, "VF %d PCI transactions stuck\n",
1414                         vf->vf_id);
1415 }
1416
1417 /**
1418  * i40e_cleanup_reset_vf
1419  * @vf: pointer to the VF structure
1420  *
1421  * Cleanup a VF after the hardware reset is finished. Expects the caller to
1422  * have verified whether the reset is finished properly, and ensure the
1423  * minimum amount of wait time has passed.
1424  **/
1425 static void i40e_cleanup_reset_vf(struct i40e_vf *vf)
1426 {
1427         struct i40e_pf *pf = vf->pf;
1428         struct i40e_hw *hw = &pf->hw;
1429         u32 reg;
1430
1431         /* disable promisc modes in case they were enabled */
1432         i40e_config_vf_promiscuous_mode(vf, vf->lan_vsi_id, false, false);
1433
1434         /* free VF resources to begin resetting the VSI state */
1435         i40e_free_vf_res(vf);
1436
1437         /* Enable hardware by clearing the reset bit in the VPGEN_VFRTRIG reg.
1438          * By doing this we allow HW to access VF memory at any point. If we
1439          * did it any sooner, HW could access memory while it was being freed
1440          * in i40e_free_vf_res(), causing an IOMMU fault.
1441          *
1442          * On the other hand, this needs to be done ASAP, because the VF driver
1443          * is waiting for this to happen and may report a timeout. It's
1444          * harmless, but it gets logged into Guest OS kernel log, so best avoid
1445          * it.
1446          */
1447         reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
1448         reg &= ~I40E_VPGEN_VFRTRIG_VFSWR_MASK;
1449         wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
1450
1451         /* reallocate VF resources to finish resetting the VSI state */
1452         if (!i40e_alloc_vf_res(vf)) {
1453                 int abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
1454                 i40e_enable_vf_mappings(vf);
1455                 set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
1456                 clear_bit(I40E_VF_STATE_DISABLED, &vf->vf_states);
1457                 /* Do not notify the client during VF init */
1458                 if (!test_and_clear_bit(I40E_VF_STATE_PRE_ENABLE,
1459                                         &vf->vf_states))
1460                         i40e_notify_client_of_vf_reset(pf, abs_vf_id);
1461                 vf->num_vlan = 0;
1462         }
1463
1464         /* Tell the VF driver the reset is done. This needs to be done only
1465          * after VF has been fully initialized, because the VF driver may
1466          * request resources immediately after setting this flag.
1467          */
1468         wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), VIRTCHNL_VFR_VFACTIVE);
1469 }
1470
1471 /**
1472  * i40e_reset_vf
1473  * @vf: pointer to the VF structure
1474  * @flr: VFLR was issued or not
1475  *
1476  * Returns true if the VF is in reset, resets successfully, or resets
1477  * are disabled and false otherwise.
1478  **/
1479 bool i40e_reset_vf(struct i40e_vf *vf, bool flr)
1480 {
1481         struct i40e_pf *pf = vf->pf;
1482         struct i40e_hw *hw = &pf->hw;
1483         bool rsd = false;
1484         u32 reg;
1485         int i;
1486
1487         if (test_bit(__I40E_VF_RESETS_DISABLED, pf->state))
1488                 return true;
1489
1490         /* If the VFs have been disabled, this means something else is
1491          * resetting the VF, so we shouldn't continue.
1492          */
1493         if (test_and_set_bit(__I40E_VF_DISABLE, pf->state))
1494                 return true;
1495
1496         i40e_trigger_vf_reset(vf, flr);
1497
1498         /* poll VPGEN_VFRSTAT reg to make sure
1499          * that reset is complete
1500          */
1501         for (i = 0; i < 10; i++) {
1502                 /* VF reset requires driver to first reset the VF and then
1503                  * poll the status register to make sure that the reset
1504                  * completed successfully. Due to internal HW FIFO flushes,
1505                  * we must wait 10ms before the register will be valid.
1506                  */
1507                 usleep_range(10000, 20000);
1508                 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
1509                 if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) {
1510                         rsd = true;
1511                         break;
1512                 }
1513         }
1514
1515         if (flr)
1516                 usleep_range(10000, 20000);
1517
1518         if (!rsd)
1519                 dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
1520                         vf->vf_id);
1521         usleep_range(10000, 20000);
1522
1523         /* On initial reset, we don't have any queues to disable */
1524         if (vf->lan_vsi_idx != 0)
1525                 i40e_vsi_stop_rings(pf->vsi[vf->lan_vsi_idx]);
1526
1527         i40e_cleanup_reset_vf(vf);
1528
1529         i40e_flush(hw);
1530         clear_bit(__I40E_VF_DISABLE, pf->state);
1531
1532         return true;
1533 }
1534
1535 /**
1536  * i40e_reset_all_vfs
1537  * @pf: pointer to the PF structure
1538  * @flr: VFLR was issued or not
1539  *
1540  * Reset all allocated VFs in one go. First, tell the hardware to reset each
1541  * VF, then do all the waiting in one chunk, and finally finish restoring each
1542  * VF after the wait. This is useful during PF routines which need to reset
1543  * all VFs, as otherwise it must perform these resets in a serialized fashion.
1544  *
1545  * Returns true if any VFs were reset, and false otherwise.
1546  **/
1547 bool i40e_reset_all_vfs(struct i40e_pf *pf, bool flr)
1548 {
1549         struct i40e_hw *hw = &pf->hw;
1550         struct i40e_vf *vf;
1551         int i, v;
1552         u32 reg;
1553
1554         /* If we don't have any VFs, then there is nothing to reset */
1555         if (!pf->num_alloc_vfs)
1556                 return false;
1557
1558         /* If VFs have been disabled, there is no need to reset */
1559         if (test_and_set_bit(__I40E_VF_DISABLE, pf->state))
1560                 return false;
1561
1562         /* Begin reset on all VFs at once */
1563         for (v = 0; v < pf->num_alloc_vfs; v++)
1564                 i40e_trigger_vf_reset(&pf->vf[v], flr);
1565
1566         /* HW requires some time to make sure it can flush the FIFO for a VF
1567          * when it resets it. Poll the VPGEN_VFRSTAT register for each VF in
1568          * sequence to make sure that it has completed. We'll keep track of
1569          * the VFs using a simple iterator that increments once that VF has
1570          * finished resetting.
1571          */
1572         for (i = 0, v = 0; i < 10 && v < pf->num_alloc_vfs; i++) {
1573                 usleep_range(10000, 20000);
1574
1575                 /* Check each VF in sequence, beginning with the VF to fail
1576                  * the previous check.
1577                  */
1578                 while (v < pf->num_alloc_vfs) {
1579                         vf = &pf->vf[v];
1580                         reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
1581                         if (!(reg & I40E_VPGEN_VFRSTAT_VFRD_MASK))
1582                                 break;
1583
1584                         /* If the current VF has finished resetting, move on
1585                          * to the next VF in sequence.
1586                          */
1587                         v++;
1588                 }
1589         }
1590
1591         if (flr)
1592                 usleep_range(10000, 20000);
1593
1594         /* Display a warning if at least one VF didn't manage to reset in
1595          * time, but continue on with the operation.
1596          */
1597         if (v < pf->num_alloc_vfs)
1598                 dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
1599                         pf->vf[v].vf_id);
1600         usleep_range(10000, 20000);
1601
1602         /* Begin disabling all the rings associated with VFs, but do not wait
1603          * between each VF.
1604          */
1605         for (v = 0; v < pf->num_alloc_vfs; v++) {
1606                 /* On initial reset, we don't have any queues to disable */
1607                 if (pf->vf[v].lan_vsi_idx == 0)
1608                         continue;
1609
1610                 i40e_vsi_stop_rings_no_wait(pf->vsi[pf->vf[v].lan_vsi_idx]);
1611         }
1612
1613         /* Now that we've notified HW to disable all of the VF rings, wait
1614          * until they finish.
1615          */
1616         for (v = 0; v < pf->num_alloc_vfs; v++) {
1617                 /* On initial reset, we don't have any queues to disable */
1618                 if (pf->vf[v].lan_vsi_idx == 0)
1619                         continue;
1620
1621                 i40e_vsi_wait_queues_disabled(pf->vsi[pf->vf[v].lan_vsi_idx]);
1622         }
1623
1624         /* Hw may need up to 50ms to finish disabling the RX queues. We
1625          * minimize the wait by delaying only once for all VFs.
1626          */
1627         mdelay(50);
1628
1629         /* Finish the reset on each VF */
1630         for (v = 0; v < pf->num_alloc_vfs; v++)
1631                 i40e_cleanup_reset_vf(&pf->vf[v]);
1632
1633         i40e_flush(hw);
1634         clear_bit(__I40E_VF_DISABLE, pf->state);
1635
1636         return true;
1637 }
1638
1639 /**
1640  * i40e_free_vfs
1641  * @pf: pointer to the PF structure
1642  *
1643  * free VF resources
1644  **/
1645 void i40e_free_vfs(struct i40e_pf *pf)
1646 {
1647         struct i40e_hw *hw = &pf->hw;
1648         u32 reg_idx, bit_idx;
1649         int i, tmp, vf_id;
1650
1651         if (!pf->vf)
1652                 return;
1653
1654         set_bit(__I40E_VFS_RELEASING, pf->state);
1655         while (test_and_set_bit(__I40E_VF_DISABLE, pf->state))
1656                 usleep_range(1000, 2000);
1657
1658         i40e_notify_client_of_vf_enable(pf, 0);
1659
1660         /* Disable IOV before freeing resources. This lets any VF drivers
1661          * running in the host get themselves cleaned up before we yank
1662          * the carpet out from underneath their feet.
1663          */
1664         if (!pci_vfs_assigned(pf->pdev))
1665                 pci_disable_sriov(pf->pdev);
1666         else
1667                 dev_warn(&pf->pdev->dev, "VFs are assigned - not disabling SR-IOV\n");
1668
1669         /* Amortize wait time by stopping all VFs at the same time */
1670         for (i = 0; i < pf->num_alloc_vfs; i++) {
1671                 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1672                         continue;
1673
1674                 i40e_vsi_stop_rings_no_wait(pf->vsi[pf->vf[i].lan_vsi_idx]);
1675         }
1676
1677         for (i = 0; i < pf->num_alloc_vfs; i++) {
1678                 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1679                         continue;
1680
1681                 i40e_vsi_wait_queues_disabled(pf->vsi[pf->vf[i].lan_vsi_idx]);
1682         }
1683
1684         /* free up VF resources */
1685         tmp = pf->num_alloc_vfs;
1686         pf->num_alloc_vfs = 0;
1687         for (i = 0; i < tmp; i++) {
1688                 if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1689                         i40e_free_vf_res(&pf->vf[i]);
1690                 /* disable qp mappings */
1691                 i40e_disable_vf_mappings(&pf->vf[i]);
1692         }
1693
1694         kfree(pf->vf);
1695         pf->vf = NULL;
1696
1697         /* This check is for when the driver is unloaded while VFs are
1698          * assigned. Setting the number of VFs to 0 through sysfs is caught
1699          * before this function ever gets called.
1700          */
1701         if (!pci_vfs_assigned(pf->pdev)) {
1702                 /* Acknowledge VFLR for all VFS. Without this, VFs will fail to
1703                  * work correctly when SR-IOV gets re-enabled.
1704                  */
1705                 for (vf_id = 0; vf_id < tmp; vf_id++) {
1706                         reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
1707                         bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
1708                         wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
1709                 }
1710         }
1711         clear_bit(__I40E_VF_DISABLE, pf->state);
1712         clear_bit(__I40E_VFS_RELEASING, pf->state);
1713 }
1714
1715 #ifdef CONFIG_PCI_IOV
1716 /**
1717  * i40e_alloc_vfs
1718  * @pf: pointer to the PF structure
1719  * @num_alloc_vfs: number of VFs to allocate
1720  *
1721  * allocate VF resources
1722  **/
1723 int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs)
1724 {
1725         struct i40e_vf *vfs;
1726         int i, ret = 0;
1727
1728         /* Disable interrupt 0 so we don't try to handle the VFLR. */
1729         i40e_irq_dynamic_disable_icr0(pf);
1730
1731         /* Check to see if we're just allocating resources for extant VFs */
1732         if (pci_num_vf(pf->pdev) != num_alloc_vfs) {
1733                 ret = pci_enable_sriov(pf->pdev, num_alloc_vfs);
1734                 if (ret) {
1735                         pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
1736                         pf->num_alloc_vfs = 0;
1737                         goto err_iov;
1738                 }
1739         }
1740         /* allocate memory */
1741         vfs = kcalloc(num_alloc_vfs, sizeof(struct i40e_vf), GFP_KERNEL);
1742         if (!vfs) {
1743                 ret = -ENOMEM;
1744                 goto err_alloc;
1745         }
1746         pf->vf = vfs;
1747
1748         /* apply default profile */
1749         for (i = 0; i < num_alloc_vfs; i++) {
1750                 vfs[i].pf = pf;
1751                 vfs[i].parent_type = I40E_SWITCH_ELEMENT_TYPE_VEB;
1752                 vfs[i].vf_id = i;
1753
1754                 /* assign default capabilities */
1755                 set_bit(I40E_VIRTCHNL_VF_CAP_L2, &vfs[i].vf_caps);
1756                 vfs[i].spoofchk = true;
1757
1758                 set_bit(I40E_VF_STATE_PRE_ENABLE, &vfs[i].vf_states);
1759
1760         }
1761         pf->num_alloc_vfs = num_alloc_vfs;
1762
1763         /* VF resources get allocated during reset */
1764         i40e_reset_all_vfs(pf, false);
1765
1766         i40e_notify_client_of_vf_enable(pf, num_alloc_vfs);
1767
1768 err_alloc:
1769         if (ret)
1770                 i40e_free_vfs(pf);
1771 err_iov:
1772         /* Re-enable interrupt 0. */
1773         i40e_irq_dynamic_enable_icr0(pf);
1774         return ret;
1775 }
1776
1777 #endif
1778 /**
1779  * i40e_pci_sriov_enable
1780  * @pdev: pointer to a pci_dev structure
1781  * @num_vfs: number of VFs to allocate
1782  *
1783  * Enable or change the number of VFs
1784  **/
1785 static int i40e_pci_sriov_enable(struct pci_dev *pdev, int num_vfs)
1786 {
1787 #ifdef CONFIG_PCI_IOV
1788         struct i40e_pf *pf = pci_get_drvdata(pdev);
1789         int pre_existing_vfs = pci_num_vf(pdev);
1790         int err = 0;
1791
1792         if (test_bit(__I40E_TESTING, pf->state)) {
1793                 dev_warn(&pdev->dev,
1794                          "Cannot enable SR-IOV virtual functions while the device is undergoing diagnostic testing\n");
1795                 err = -EPERM;
1796                 goto err_out;
1797         }
1798
1799         if (pre_existing_vfs && pre_existing_vfs != num_vfs)
1800                 i40e_free_vfs(pf);
1801         else if (pre_existing_vfs && pre_existing_vfs == num_vfs)
1802                 goto out;
1803
1804         if (num_vfs > pf->num_req_vfs) {
1805                 dev_warn(&pdev->dev, "Unable to enable %d VFs. Limited to %d VFs due to device resource constraints.\n",
1806                          num_vfs, pf->num_req_vfs);
1807                 err = -EPERM;
1808                 goto err_out;
1809         }
1810
1811         dev_info(&pdev->dev, "Allocating %d VFs.\n", num_vfs);
1812         err = i40e_alloc_vfs(pf, num_vfs);
1813         if (err) {
1814                 dev_warn(&pdev->dev, "Failed to enable SR-IOV: %d\n", err);
1815                 goto err_out;
1816         }
1817
1818 out:
1819         return num_vfs;
1820
1821 err_out:
1822         return err;
1823 #endif
1824         return 0;
1825 }
1826
1827 /**
1828  * i40e_pci_sriov_configure
1829  * @pdev: pointer to a pci_dev structure
1830  * @num_vfs: number of VFs to allocate
1831  *
1832  * Enable or change the number of VFs. Called when the user updates the number
1833  * of VFs in sysfs.
1834  **/
1835 int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
1836 {
1837         struct i40e_pf *pf = pci_get_drvdata(pdev);
1838         int ret = 0;
1839
1840         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
1841                 dev_warn(&pdev->dev, "Unable to configure VFs, other operation is pending.\n");
1842                 return -EAGAIN;
1843         }
1844
1845         if (num_vfs) {
1846                 if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) {
1847                         pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
1848                         i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
1849                 }
1850                 ret = i40e_pci_sriov_enable(pdev, num_vfs);
1851                 goto sriov_configure_out;
1852         }
1853
1854         if (!pci_vfs_assigned(pf->pdev)) {
1855                 i40e_free_vfs(pf);
1856                 pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
1857                 i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
1858         } else {
1859                 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n");
1860                 ret = -EINVAL;
1861                 goto sriov_configure_out;
1862         }
1863 sriov_configure_out:
1864         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
1865         return ret;
1866 }
1867
1868 /***********************virtual channel routines******************/
1869
1870 /**
1871  * i40e_vc_send_msg_to_vf
1872  * @vf: pointer to the VF info
1873  * @v_opcode: virtual channel opcode
1874  * @v_retval: virtual channel return value
1875  * @msg: pointer to the msg buffer
1876  * @msglen: msg length
1877  *
1878  * send msg to VF
1879  **/
1880 static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode,
1881                                   u32 v_retval, u8 *msg, u16 msglen)
1882 {
1883         struct i40e_pf *pf;
1884         struct i40e_hw *hw;
1885         int abs_vf_id;
1886         i40e_status aq_ret;
1887
1888         /* validate the request */
1889         if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
1890                 return -EINVAL;
1891
1892         pf = vf->pf;
1893         hw = &pf->hw;
1894         abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
1895
1896         /* single place to detect unsuccessful return values */
1897         if (v_retval) {
1898                 vf->num_invalid_msgs++;
1899                 dev_info(&pf->pdev->dev, "VF %d failed opcode %d, retval: %d\n",
1900                          vf->vf_id, v_opcode, v_retval);
1901                 if (vf->num_invalid_msgs >
1902                     I40E_DEFAULT_NUM_INVALID_MSGS_ALLOWED) {
1903                         dev_err(&pf->pdev->dev,
1904                                 "Number of invalid messages exceeded for VF %d\n",
1905                                 vf->vf_id);
1906                         dev_err(&pf->pdev->dev, "Use PF Control I/F to enable the VF\n");
1907                         set_bit(I40E_VF_STATE_DISABLED, &vf->vf_states);
1908                 }
1909         } else {
1910                 vf->num_valid_msgs++;
1911                 /* reset the invalid counter, if a valid message is received. */
1912                 vf->num_invalid_msgs = 0;
1913         }
1914
1915         aq_ret = i40e_aq_send_msg_to_vf(hw, abs_vf_id,  v_opcode, v_retval,
1916                                         msg, msglen, NULL);
1917         if (aq_ret) {
1918                 dev_info(&pf->pdev->dev,
1919                          "Unable to send the message to VF %d aq_err %d\n",
1920                          vf->vf_id, pf->hw.aq.asq_last_status);
1921                 return -EIO;
1922         }
1923
1924         return 0;
1925 }
1926
1927 /**
1928  * i40e_vc_send_resp_to_vf
1929  * @vf: pointer to the VF info
1930  * @opcode: operation code
1931  * @retval: return value
1932  *
1933  * send resp msg to VF
1934  **/
1935 static int i40e_vc_send_resp_to_vf(struct i40e_vf *vf,
1936                                    enum virtchnl_ops opcode,
1937                                    i40e_status retval)
1938 {
1939         return i40e_vc_send_msg_to_vf(vf, opcode, retval, NULL, 0);
1940 }
1941
1942 /**
1943  * i40e_vc_get_version_msg
1944  * @vf: pointer to the VF info
1945  * @msg: pointer to the msg buffer
1946  *
1947  * called from the VF to request the API version used by the PF
1948  **/
1949 static int i40e_vc_get_version_msg(struct i40e_vf *vf, u8 *msg)
1950 {
1951         struct virtchnl_version_info info = {
1952                 VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR
1953         };
1954
1955         vf->vf_ver = *(struct virtchnl_version_info *)msg;
1956         /* VFs running the 1.0 API expect to get 1.0 back or they will cry. */
1957         if (VF_IS_V10(&vf->vf_ver))
1958                 info.minor = VIRTCHNL_VERSION_MINOR_NO_VF_CAPS;
1959         return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_VERSION,
1960                                       I40E_SUCCESS, (u8 *)&info,
1961                                       sizeof(struct virtchnl_version_info));
1962 }
1963
1964 /**
1965  * i40e_del_qch - delete all the additional VSIs created as a part of ADq
1966  * @vf: pointer to VF structure
1967  **/
1968 static void i40e_del_qch(struct i40e_vf *vf)
1969 {
1970         struct i40e_pf *pf = vf->pf;
1971         int i;
1972
1973         /* first element in the array belongs to primary VF VSI and we shouldn't
1974          * delete it. We should however delete the rest of the VSIs created
1975          */
1976         for (i = 1; i < vf->num_tc; i++) {
1977                 if (vf->ch[i].vsi_idx) {
1978                         i40e_vsi_release(pf->vsi[vf->ch[i].vsi_idx]);
1979                         vf->ch[i].vsi_idx = 0;
1980                         vf->ch[i].vsi_id = 0;
1981                 }
1982         }
1983 }
1984
1985 /**
1986  * i40e_vc_get_vf_resources_msg
1987  * @vf: pointer to the VF info
1988  * @msg: pointer to the msg buffer
1989  *
1990  * called from the VF to request its resources
1991  **/
1992 static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
1993 {
1994         struct virtchnl_vf_resource *vfres = NULL;
1995         struct i40e_pf *pf = vf->pf;
1996         i40e_status aq_ret = 0;
1997         struct i40e_vsi *vsi;
1998         int num_vsis = 1;
1999         size_t len = 0;
2000         int ret;
2001
2002         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
2003                 aq_ret = I40E_ERR_PARAM;
2004                 goto err;
2005         }
2006
2007         len = struct_size(vfres, vsi_res, num_vsis);
2008         vfres = kzalloc(len, GFP_KERNEL);
2009         if (!vfres) {
2010                 aq_ret = I40E_ERR_NO_MEMORY;
2011                 len = 0;
2012                 goto err;
2013         }
2014         if (VF_IS_V11(&vf->vf_ver))
2015                 vf->driver_caps = *(u32 *)msg;
2016         else
2017                 vf->driver_caps = VIRTCHNL_VF_OFFLOAD_L2 |
2018                                   VIRTCHNL_VF_OFFLOAD_RSS_REG |
2019                                   VIRTCHNL_VF_OFFLOAD_VLAN;
2020
2021         vfres->vf_cap_flags = VIRTCHNL_VF_OFFLOAD_L2;
2022         vfres->vf_cap_flags |= VIRTCHNL_VF_CAP_ADV_LINK_SPEED;
2023         vsi = pf->vsi[vf->lan_vsi_idx];
2024         if (!vsi->info.pvid)
2025                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_VLAN;
2026
2027         if (i40e_vf_client_capable(pf, vf->vf_id) &&
2028             (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_IWARP)) {
2029                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_IWARP;
2030                 set_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states);
2031         } else {
2032                 clear_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states);
2033         }
2034
2035         if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PF) {
2036                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_PF;
2037         } else {
2038                 if ((pf->hw_features & I40E_HW_RSS_AQ_CAPABLE) &&
2039                     (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_AQ))
2040                         vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_AQ;
2041                 else
2042                         vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_REG;
2043         }
2044
2045         if (pf->hw_features & I40E_HW_MULTIPLE_TCP_UDP_RSS_PCTYPE) {
2046                 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2)
2047                         vfres->vf_cap_flags |=
2048                                 VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2;
2049         }
2050
2051         if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP)
2052                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP;
2053
2054         if ((pf->hw_features & I40E_HW_OUTER_UDP_CSUM_CAPABLE) &&
2055             (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM))
2056                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM;
2057
2058         if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) {
2059                 if (pf->flags & I40E_FLAG_MFP_ENABLED) {
2060                         dev_err(&pf->pdev->dev,
2061                                 "VF %d requested polling mode: this feature is supported only when the device is running in single function per port (SFP) mode\n",
2062                                  vf->vf_id);
2063                         aq_ret = I40E_ERR_PARAM;
2064                         goto err;
2065                 }
2066                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RX_POLLING;
2067         }
2068
2069         if (pf->hw_features & I40E_HW_WB_ON_ITR_CAPABLE) {
2070                 if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
2071                         vfres->vf_cap_flags |=
2072                                         VIRTCHNL_VF_OFFLOAD_WB_ON_ITR;
2073         }
2074
2075         if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_REQ_QUEUES)
2076                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_REQ_QUEUES;
2077
2078         if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ)
2079                 vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ADQ;
2080
2081         vfres->num_vsis = num_vsis;
2082         vfres->num_queue_pairs = vf->num_queue_pairs;
2083         vfres->max_vectors = pf->hw.func_caps.num_msix_vectors_vf;
2084         vfres->rss_key_size = I40E_HKEY_ARRAY_SIZE;
2085         vfres->rss_lut_size = I40E_VF_HLUT_ARRAY_SIZE;
2086
2087         if (vf->lan_vsi_idx) {
2088                 vfres->vsi_res[0].vsi_id = vf->lan_vsi_id;
2089                 vfres->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV;
2090                 vfres->vsi_res[0].num_queue_pairs = vsi->alloc_queue_pairs;
2091                 /* VFs only use TC 0 */
2092                 vfres->vsi_res[0].qset_handle
2093                                           = le16_to_cpu(vsi->info.qs_handle[0]);
2094                 ether_addr_copy(vfres->vsi_res[0].default_mac_addr,
2095                                 vf->default_lan_addr.addr);
2096         }
2097         set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
2098
2099 err:
2100         /* send the response back to the VF */
2101         ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_VF_RESOURCES,
2102                                      aq_ret, (u8 *)vfres, len);
2103
2104         kfree(vfres);
2105         return ret;
2106 }
2107
2108 /**
2109  * i40e_vc_reset_vf_msg
2110  * @vf: pointer to the VF info
2111  *
2112  * called from the VF to reset itself,
2113  * unlike other virtchnl messages, PF driver
2114  * doesn't send the response back to the VF
2115  **/
2116 static void i40e_vc_reset_vf_msg(struct i40e_vf *vf)
2117 {
2118         if (test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
2119                 i40e_reset_vf(vf, false);
2120 }
2121
2122 /**
2123  * i40e_vc_config_promiscuous_mode_msg
2124  * @vf: pointer to the VF info
2125  * @msg: pointer to the msg buffer
2126  *
2127  * called from the VF to configure the promiscuous mode of
2128  * VF vsis
2129  **/
2130 static int i40e_vc_config_promiscuous_mode_msg(struct i40e_vf *vf, u8 *msg)
2131 {
2132         struct virtchnl_promisc_info *info =
2133             (struct virtchnl_promisc_info *)msg;
2134         struct i40e_pf *pf = vf->pf;
2135         i40e_status aq_ret = 0;
2136         bool allmulti = false;
2137         bool alluni = false;
2138
2139         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2140                 aq_ret = I40E_ERR_PARAM;
2141                 goto err_out;
2142         }
2143         if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
2144                 dev_err(&pf->pdev->dev,
2145                         "Unprivileged VF %d is attempting to configure promiscuous mode\n",
2146                         vf->vf_id);
2147
2148                 /* Lie to the VF on purpose, because this is an error we can
2149                  * ignore. Unprivileged VF is not a virtual channel error.
2150                  */
2151                 aq_ret = 0;
2152                 goto err_out;
2153         }
2154
2155         if (info->flags > I40E_MAX_VF_PROMISC_FLAGS) {
2156                 aq_ret = I40E_ERR_PARAM;
2157                 goto err_out;
2158         }
2159
2160         if (!i40e_vc_isvalid_vsi_id(vf, info->vsi_id)) {
2161                 aq_ret = I40E_ERR_PARAM;
2162                 goto err_out;
2163         }
2164
2165         /* Multicast promiscuous handling*/
2166         if (info->flags & FLAG_VF_MULTICAST_PROMISC)
2167                 allmulti = true;
2168
2169         if (info->flags & FLAG_VF_UNICAST_PROMISC)
2170                 alluni = true;
2171         aq_ret = i40e_config_vf_promiscuous_mode(vf, info->vsi_id, allmulti,
2172                                                  alluni);
2173         if (aq_ret)
2174                 goto err_out;
2175
2176         if (allmulti) {
2177                 if (!test_and_set_bit(I40E_VF_STATE_MC_PROMISC,
2178                                       &vf->vf_states))
2179                         dev_info(&pf->pdev->dev,
2180                                  "VF %d successfully set multicast promiscuous mode\n",
2181                                  vf->vf_id);
2182         } else if (test_and_clear_bit(I40E_VF_STATE_MC_PROMISC,
2183                                       &vf->vf_states))
2184                 dev_info(&pf->pdev->dev,
2185                          "VF %d successfully unset multicast promiscuous mode\n",
2186                          vf->vf_id);
2187
2188         if (alluni) {
2189                 if (!test_and_set_bit(I40E_VF_STATE_UC_PROMISC,
2190                                       &vf->vf_states))
2191                         dev_info(&pf->pdev->dev,
2192                                  "VF %d successfully set unicast promiscuous mode\n",
2193                                  vf->vf_id);
2194         } else if (test_and_clear_bit(I40E_VF_STATE_UC_PROMISC,
2195                                       &vf->vf_states))
2196                 dev_info(&pf->pdev->dev,
2197                          "VF %d successfully unset unicast promiscuous mode\n",
2198                          vf->vf_id);
2199
2200 err_out:
2201         /* send the response to the VF */
2202         return i40e_vc_send_resp_to_vf(vf,
2203                                        VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
2204                                        aq_ret);
2205 }
2206
2207 /**
2208  * i40e_vc_config_queues_msg
2209  * @vf: pointer to the VF info
2210  * @msg: pointer to the msg buffer
2211  *
2212  * called from the VF to configure the rx/tx
2213  * queues
2214  **/
2215 static int i40e_vc_config_queues_msg(struct i40e_vf *vf, u8 *msg)
2216 {
2217         struct virtchnl_vsi_queue_config_info *qci =
2218             (struct virtchnl_vsi_queue_config_info *)msg;
2219         struct virtchnl_queue_pair_info *qpi;
2220         struct i40e_pf *pf = vf->pf;
2221         u16 vsi_id, vsi_queue_id = 0;
2222         u16 num_qps_all = 0;
2223         i40e_status aq_ret = 0;
2224         int i, j = 0, idx = 0;
2225
2226         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2227                 aq_ret = I40E_ERR_PARAM;
2228                 goto error_param;
2229         }
2230
2231         if (!i40e_vc_isvalid_vsi_id(vf, qci->vsi_id)) {
2232                 aq_ret = I40E_ERR_PARAM;
2233                 goto error_param;
2234         }
2235
2236         if (qci->num_queue_pairs > I40E_MAX_VF_QUEUES) {
2237                 aq_ret = I40E_ERR_PARAM;
2238                 goto error_param;
2239         }
2240
2241         if (vf->adq_enabled) {
2242                 for (i = 0; i < I40E_MAX_VF_VSI; i++)
2243                         num_qps_all += vf->ch[i].num_qps;
2244                 if (num_qps_all != qci->num_queue_pairs) {
2245                         aq_ret = I40E_ERR_PARAM;
2246                         goto error_param;
2247                 }
2248         }
2249
2250         vsi_id = qci->vsi_id;
2251
2252         for (i = 0; i < qci->num_queue_pairs; i++) {
2253                 qpi = &qci->qpair[i];
2254
2255                 if (!vf->adq_enabled) {
2256                         if (!i40e_vc_isvalid_queue_id(vf, vsi_id,
2257                                                       qpi->txq.queue_id)) {
2258                                 aq_ret = I40E_ERR_PARAM;
2259                                 goto error_param;
2260                         }
2261
2262                         vsi_queue_id = qpi->txq.queue_id;
2263
2264                         if (qpi->txq.vsi_id != qci->vsi_id ||
2265                             qpi->rxq.vsi_id != qci->vsi_id ||
2266                             qpi->rxq.queue_id != vsi_queue_id) {
2267                                 aq_ret = I40E_ERR_PARAM;
2268                                 goto error_param;
2269                         }
2270                 }
2271
2272                 if (vf->adq_enabled) {
2273                         if (idx >= ARRAY_SIZE(vf->ch)) {
2274                                 aq_ret = I40E_ERR_NO_AVAILABLE_VSI;
2275                                 goto error_param;
2276                         }
2277                         vsi_id = vf->ch[idx].vsi_id;
2278                 }
2279
2280                 if (i40e_config_vsi_rx_queue(vf, vsi_id, vsi_queue_id,
2281                                              &qpi->rxq) ||
2282                     i40e_config_vsi_tx_queue(vf, vsi_id, vsi_queue_id,
2283                                              &qpi->txq)) {
2284                         aq_ret = I40E_ERR_PARAM;
2285                         goto error_param;
2286                 }
2287
2288                 /* For ADq there can be up to 4 VSIs with max 4 queues each.
2289                  * VF does not know about these additional VSIs and all
2290                  * it cares is about its own queues. PF configures these queues
2291                  * to its appropriate VSIs based on TC mapping
2292                  */
2293                 if (vf->adq_enabled) {
2294                         if (idx >= ARRAY_SIZE(vf->ch)) {
2295                                 aq_ret = I40E_ERR_NO_AVAILABLE_VSI;
2296                                 goto error_param;
2297                         }
2298                         if (j == (vf->ch[idx].num_qps - 1)) {
2299                                 idx++;
2300                                 j = 0; /* resetting the queue count */
2301                                 vsi_queue_id = 0;
2302                         } else {
2303                                 j++;
2304                                 vsi_queue_id++;
2305                         }
2306                 }
2307         }
2308         /* set vsi num_queue_pairs in use to num configured by VF */
2309         if (!vf->adq_enabled) {
2310                 pf->vsi[vf->lan_vsi_idx]->num_queue_pairs =
2311                         qci->num_queue_pairs;
2312         } else {
2313                 for (i = 0; i < vf->num_tc; i++)
2314                         pf->vsi[vf->ch[i].vsi_idx]->num_queue_pairs =
2315                                vf->ch[i].num_qps;
2316         }
2317
2318 error_param:
2319         /* send the response to the VF */
2320         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
2321                                        aq_ret);
2322 }
2323
2324 /**
2325  * i40e_validate_queue_map - check queue map is valid
2326  * @vf: the VF structure pointer
2327  * @vsi_id: vsi id
2328  * @queuemap: Tx or Rx queue map
2329  *
2330  * check if Tx or Rx queue map is valid
2331  **/
2332 static int i40e_validate_queue_map(struct i40e_vf *vf, u16 vsi_id,
2333                                    unsigned long queuemap)
2334 {
2335         u16 vsi_queue_id, queue_id;
2336
2337         for_each_set_bit(vsi_queue_id, &queuemap, I40E_MAX_VSI_QP) {
2338                 if (vf->adq_enabled) {
2339                         vsi_id = vf->ch[vsi_queue_id / I40E_MAX_VF_VSI].vsi_id;
2340                         queue_id = (vsi_queue_id % I40E_DEFAULT_QUEUES_PER_VF);
2341                 } else {
2342                         queue_id = vsi_queue_id;
2343                 }
2344
2345                 if (!i40e_vc_isvalid_queue_id(vf, vsi_id, queue_id))
2346                         return -EINVAL;
2347         }
2348
2349         return 0;
2350 }
2351
2352 /**
2353  * i40e_vc_config_irq_map_msg
2354  * @vf: pointer to the VF info
2355  * @msg: pointer to the msg buffer
2356  *
2357  * called from the VF to configure the irq to
2358  * queue map
2359  **/
2360 static int i40e_vc_config_irq_map_msg(struct i40e_vf *vf, u8 *msg)
2361 {
2362         struct virtchnl_irq_map_info *irqmap_info =
2363             (struct virtchnl_irq_map_info *)msg;
2364         struct virtchnl_vector_map *map;
2365         u16 vsi_id;
2366         i40e_status aq_ret = 0;
2367         int i;
2368
2369         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2370                 aq_ret = I40E_ERR_PARAM;
2371                 goto error_param;
2372         }
2373
2374         if (irqmap_info->num_vectors >
2375             vf->pf->hw.func_caps.num_msix_vectors_vf) {
2376                 aq_ret = I40E_ERR_PARAM;
2377                 goto error_param;
2378         }
2379
2380         for (i = 0; i < irqmap_info->num_vectors; i++) {
2381                 map = &irqmap_info->vecmap[i];
2382                 /* validate msg params */
2383                 if (!i40e_vc_isvalid_vector_id(vf, map->vector_id) ||
2384                     !i40e_vc_isvalid_vsi_id(vf, map->vsi_id)) {
2385                         aq_ret = I40E_ERR_PARAM;
2386                         goto error_param;
2387                 }
2388                 vsi_id = map->vsi_id;
2389
2390                 if (i40e_validate_queue_map(vf, vsi_id, map->rxq_map)) {
2391                         aq_ret = I40E_ERR_PARAM;
2392                         goto error_param;
2393                 }
2394
2395                 if (i40e_validate_queue_map(vf, vsi_id, map->txq_map)) {
2396                         aq_ret = I40E_ERR_PARAM;
2397                         goto error_param;
2398                 }
2399
2400                 i40e_config_irq_link_list(vf, vsi_id, map);
2401         }
2402 error_param:
2403         /* send the response to the VF */
2404         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_IRQ_MAP,
2405                                        aq_ret);
2406 }
2407
2408 /**
2409  * i40e_ctrl_vf_tx_rings
2410  * @vsi: the SRIOV VSI being configured
2411  * @q_map: bit map of the queues to be enabled
2412  * @enable: start or stop the queue
2413  **/
2414 static int i40e_ctrl_vf_tx_rings(struct i40e_vsi *vsi, unsigned long q_map,
2415                                  bool enable)
2416 {
2417         struct i40e_pf *pf = vsi->back;
2418         int ret = 0;
2419         u16 q_id;
2420
2421         for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) {
2422                 ret = i40e_control_wait_tx_q(vsi->seid, pf,
2423                                              vsi->base_queue + q_id,
2424                                              false /*is xdp*/, enable);
2425                 if (ret)
2426                         break;
2427         }
2428         return ret;
2429 }
2430
2431 /**
2432  * i40e_ctrl_vf_rx_rings
2433  * @vsi: the SRIOV VSI being configured
2434  * @q_map: bit map of the queues to be enabled
2435  * @enable: start or stop the queue
2436  **/
2437 static int i40e_ctrl_vf_rx_rings(struct i40e_vsi *vsi, unsigned long q_map,
2438                                  bool enable)
2439 {
2440         struct i40e_pf *pf = vsi->back;
2441         int ret = 0;
2442         u16 q_id;
2443
2444         for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) {
2445                 ret = i40e_control_wait_rx_q(pf, vsi->base_queue + q_id,
2446                                              enable);
2447                 if (ret)
2448                         break;
2449         }
2450         return ret;
2451 }
2452
2453 /**
2454  * i40e_vc_validate_vqs_bitmaps - validate Rx/Tx queue bitmaps from VIRTHCHNL
2455  * @vqs: virtchnl_queue_select structure containing bitmaps to validate
2456  *
2457  * Returns true if validation was successful, else false.
2458  */
2459 static bool i40e_vc_validate_vqs_bitmaps(struct virtchnl_queue_select *vqs)
2460 {
2461         if ((!vqs->rx_queues && !vqs->tx_queues) ||
2462             vqs->rx_queues >= BIT(I40E_MAX_VF_QUEUES) ||
2463             vqs->tx_queues >= BIT(I40E_MAX_VF_QUEUES))
2464                 return false;
2465
2466         return true;
2467 }
2468
2469 /**
2470  * i40e_vc_enable_queues_msg
2471  * @vf: pointer to the VF info
2472  * @msg: pointer to the msg buffer
2473  *
2474  * called from the VF to enable all or specific queue(s)
2475  **/
2476 static int i40e_vc_enable_queues_msg(struct i40e_vf *vf, u8 *msg)
2477 {
2478         struct virtchnl_queue_select *vqs =
2479             (struct virtchnl_queue_select *)msg;
2480         struct i40e_pf *pf = vf->pf;
2481         i40e_status aq_ret = 0;
2482         int i;
2483
2484         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2485                 aq_ret = I40E_ERR_PARAM;
2486                 goto error_param;
2487         }
2488
2489         if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2490                 aq_ret = I40E_ERR_PARAM;
2491                 goto error_param;
2492         }
2493
2494         if (!i40e_vc_validate_vqs_bitmaps(vqs)) {
2495                 aq_ret = I40E_ERR_PARAM;
2496                 goto error_param;
2497         }
2498
2499         /* Use the queue bit map sent by the VF */
2500         if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues,
2501                                   true)) {
2502                 aq_ret = I40E_ERR_TIMEOUT;
2503                 goto error_param;
2504         }
2505         if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues,
2506                                   true)) {
2507                 aq_ret = I40E_ERR_TIMEOUT;
2508                 goto error_param;
2509         }
2510
2511         /* need to start the rings for additional ADq VSI's as well */
2512         if (vf->adq_enabled) {
2513                 /* zero belongs to LAN VSI */
2514                 for (i = 1; i < vf->num_tc; i++) {
2515                         if (i40e_vsi_start_rings(pf->vsi[vf->ch[i].vsi_idx]))
2516                                 aq_ret = I40E_ERR_TIMEOUT;
2517                 }
2518         }
2519
2520 error_param:
2521         /* send the response to the VF */
2522         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_QUEUES,
2523                                        aq_ret);
2524 }
2525
2526 /**
2527  * i40e_vc_disable_queues_msg
2528  * @vf: pointer to the VF info
2529  * @msg: pointer to the msg buffer
2530  *
2531  * called from the VF to disable all or specific
2532  * queue(s)
2533  **/
2534 static int i40e_vc_disable_queues_msg(struct i40e_vf *vf, u8 *msg)
2535 {
2536         struct virtchnl_queue_select *vqs =
2537             (struct virtchnl_queue_select *)msg;
2538         struct i40e_pf *pf = vf->pf;
2539         i40e_status aq_ret = 0;
2540
2541         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2542                 aq_ret = I40E_ERR_PARAM;
2543                 goto error_param;
2544         }
2545
2546         if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2547                 aq_ret = I40E_ERR_PARAM;
2548                 goto error_param;
2549         }
2550
2551         if (!i40e_vc_validate_vqs_bitmaps(vqs)) {
2552                 aq_ret = I40E_ERR_PARAM;
2553                 goto error_param;
2554         }
2555
2556         /* Use the queue bit map sent by the VF */
2557         if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues,
2558                                   false)) {
2559                 aq_ret = I40E_ERR_TIMEOUT;
2560                 goto error_param;
2561         }
2562         if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues,
2563                                   false)) {
2564                 aq_ret = I40E_ERR_TIMEOUT;
2565                 goto error_param;
2566         }
2567 error_param:
2568         /* send the response to the VF */
2569         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_QUEUES,
2570                                        aq_ret);
2571 }
2572
2573 /**
2574  * i40e_vc_request_queues_msg
2575  * @vf: pointer to the VF info
2576  * @msg: pointer to the msg buffer
2577  *
2578  * VFs get a default number of queues but can use this message to request a
2579  * different number.  If the request is successful, PF will reset the VF and
2580  * return 0.  If unsuccessful, PF will send message informing VF of number of
2581  * available queues and return result of sending VF a message.
2582  **/
2583 static int i40e_vc_request_queues_msg(struct i40e_vf *vf, u8 *msg)
2584 {
2585         struct virtchnl_vf_res_request *vfres =
2586                 (struct virtchnl_vf_res_request *)msg;
2587         u16 req_pairs = vfres->num_queue_pairs;
2588         u8 cur_pairs = vf->num_queue_pairs;
2589         struct i40e_pf *pf = vf->pf;
2590
2591         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
2592                 return -EINVAL;
2593
2594         if (req_pairs > I40E_MAX_VF_QUEUES) {
2595                 dev_err(&pf->pdev->dev,
2596                         "VF %d tried to request more than %d queues.\n",
2597                         vf->vf_id,
2598                         I40E_MAX_VF_QUEUES);
2599                 vfres->num_queue_pairs = I40E_MAX_VF_QUEUES;
2600         } else if (req_pairs - cur_pairs > pf->queues_left) {
2601                 dev_warn(&pf->pdev->dev,
2602                          "VF %d requested %d more queues, but only %d left.\n",
2603                          vf->vf_id,
2604                          req_pairs - cur_pairs,
2605                          pf->queues_left);
2606                 vfres->num_queue_pairs = pf->queues_left + cur_pairs;
2607         } else {
2608                 /* successful request */
2609                 vf->num_req_queues = req_pairs;
2610                 i40e_vc_notify_vf_reset(vf);
2611                 i40e_reset_vf(vf, false);
2612                 return 0;
2613         }
2614
2615         return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_REQUEST_QUEUES, 0,
2616                                       (u8 *)vfres, sizeof(*vfres));
2617 }
2618
2619 /**
2620  * i40e_vc_get_stats_msg
2621  * @vf: pointer to the VF info
2622  * @msg: pointer to the msg buffer
2623  *
2624  * called from the VF to get vsi stats
2625  **/
2626 static int i40e_vc_get_stats_msg(struct i40e_vf *vf, u8 *msg)
2627 {
2628         struct virtchnl_queue_select *vqs =
2629             (struct virtchnl_queue_select *)msg;
2630         struct i40e_pf *pf = vf->pf;
2631         struct i40e_eth_stats stats;
2632         i40e_status aq_ret = 0;
2633         struct i40e_vsi *vsi;
2634
2635         memset(&stats, 0, sizeof(struct i40e_eth_stats));
2636
2637         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2638                 aq_ret = I40E_ERR_PARAM;
2639                 goto error_param;
2640         }
2641
2642         if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2643                 aq_ret = I40E_ERR_PARAM;
2644                 goto error_param;
2645         }
2646
2647         vsi = pf->vsi[vf->lan_vsi_idx];
2648         if (!vsi) {
2649                 aq_ret = I40E_ERR_PARAM;
2650                 goto error_param;
2651         }
2652         i40e_update_eth_stats(vsi);
2653         stats = vsi->eth_stats;
2654
2655 error_param:
2656         /* send the response back to the VF */
2657         return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_STATS, aq_ret,
2658                                       (u8 *)&stats, sizeof(stats));
2659 }
2660
2661 /* If the VF is not trusted restrict the number of MAC/VLAN it can program
2662  * MAC filters: 16 for multicast, 1 for MAC, 1 for broadcast
2663  */
2664 #define I40E_VC_MAX_MAC_ADDR_PER_VF (16 + 1 + 1)
2665 #define I40E_VC_MAX_VLAN_PER_VF 16
2666
2667 /**
2668  * i40e_check_vf_permission
2669  * @vf: pointer to the VF info
2670  * @al: MAC address list from virtchnl
2671  *
2672  * Check that the given list of MAC addresses is allowed. Will return -EPERM
2673  * if any address in the list is not valid. Checks the following conditions:
2674  *
2675  * 1) broadcast and zero addresses are never valid
2676  * 2) unicast addresses are not allowed if the VMM has administratively set
2677  *    the VF MAC address, unless the VF is marked as privileged.
2678  * 3) There is enough space to add all the addresses.
2679  *
2680  * Note that to guarantee consistency, it is expected this function be called
2681  * while holding the mac_filter_hash_lock, as otherwise the current number of
2682  * addresses might not be accurate.
2683  **/
2684 static inline int i40e_check_vf_permission(struct i40e_vf *vf,
2685                                            struct virtchnl_ether_addr_list *al)
2686 {
2687         struct i40e_pf *pf = vf->pf;
2688         struct i40e_vsi *vsi = pf->vsi[vf->lan_vsi_idx];
2689         int mac2add_cnt = 0;
2690         int i;
2691
2692         for (i = 0; i < al->num_elements; i++) {
2693                 struct i40e_mac_filter *f;
2694                 u8 *addr = al->list[i].addr;
2695
2696                 if (is_broadcast_ether_addr(addr) ||
2697                     is_zero_ether_addr(addr)) {
2698                         dev_err(&pf->pdev->dev, "invalid VF MAC addr %pM\n",
2699                                 addr);
2700                         return I40E_ERR_INVALID_MAC_ADDR;
2701                 }
2702
2703                 /* If the host VMM administrator has set the VF MAC address
2704                  * administratively via the ndo_set_vf_mac command then deny
2705                  * permission to the VF to add or delete unicast MAC addresses.
2706                  * Unless the VF is privileged and then it can do whatever.
2707                  * The VF may request to set the MAC address filter already
2708                  * assigned to it so do not return an error in that case.
2709                  */
2710                 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) &&
2711                     !is_multicast_ether_addr(addr) && vf->pf_set_mac &&
2712                     !ether_addr_equal(addr, vf->default_lan_addr.addr)) {
2713                         dev_err(&pf->pdev->dev,
2714                                 "VF attempting to override administratively set MAC address, bring down and up the VF interface to resume normal operation\n");
2715                         return -EPERM;
2716                 }
2717
2718                 /*count filters that really will be added*/
2719                 f = i40e_find_mac(vsi, addr);
2720                 if (!f)
2721                         ++mac2add_cnt;
2722         }
2723
2724         /* If this VF is not privileged, then we can't add more than a limited
2725          * number of addresses. Check to make sure that the additions do not
2726          * push us over the limit.
2727          */
2728         if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) &&
2729             (i40e_count_filters(vsi) + mac2add_cnt) >
2730                     I40E_VC_MAX_MAC_ADDR_PER_VF) {
2731                 dev_err(&pf->pdev->dev,
2732                         "Cannot add more MAC addresses, VF is not trusted, switch the VF to trusted to add more functionality\n");
2733                 return -EPERM;
2734         }
2735         return 0;
2736 }
2737
2738 /**
2739  * i40e_vc_add_mac_addr_msg
2740  * @vf: pointer to the VF info
2741  * @msg: pointer to the msg buffer
2742  *
2743  * add guest mac address filter
2744  **/
2745 static int i40e_vc_add_mac_addr_msg(struct i40e_vf *vf, u8 *msg)
2746 {
2747         struct virtchnl_ether_addr_list *al =
2748             (struct virtchnl_ether_addr_list *)msg;
2749         struct i40e_pf *pf = vf->pf;
2750         struct i40e_vsi *vsi = NULL;
2751         i40e_status ret = 0;
2752         int i;
2753
2754         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
2755             !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
2756                 ret = I40E_ERR_PARAM;
2757                 goto error_param;
2758         }
2759
2760         vsi = pf->vsi[vf->lan_vsi_idx];
2761
2762         /* Lock once, because all function inside for loop accesses VSI's
2763          * MAC filter list which needs to be protected using same lock.
2764          */
2765         spin_lock_bh(&vsi->mac_filter_hash_lock);
2766
2767         ret = i40e_check_vf_permission(vf, al);
2768         if (ret) {
2769                 spin_unlock_bh(&vsi->mac_filter_hash_lock);
2770                 goto error_param;
2771         }
2772
2773         /* add new addresses to the list */
2774         for (i = 0; i < al->num_elements; i++) {
2775                 struct i40e_mac_filter *f;
2776
2777                 f = i40e_find_mac(vsi, al->list[i].addr);
2778                 if (!f) {
2779                         f = i40e_add_mac_filter(vsi, al->list[i].addr);
2780
2781                         if (!f) {
2782                                 dev_err(&pf->pdev->dev,
2783                                         "Unable to add MAC filter %pM for VF %d\n",
2784                                         al->list[i].addr, vf->vf_id);
2785                                 ret = I40E_ERR_PARAM;
2786                                 spin_unlock_bh(&vsi->mac_filter_hash_lock);
2787                                 goto error_param;
2788                         }
2789                         if (is_valid_ether_addr(al->list[i].addr) &&
2790                             is_zero_ether_addr(vf->default_lan_addr.addr))
2791                                 ether_addr_copy(vf->default_lan_addr.addr,
2792                                                 al->list[i].addr);
2793                 }
2794         }
2795         spin_unlock_bh(&vsi->mac_filter_hash_lock);
2796
2797         /* program the updated filter list */
2798         ret = i40e_sync_vsi_filters(vsi);
2799         if (ret)
2800                 dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n",
2801                         vf->vf_id, ret);
2802
2803 error_param:
2804         /* send the response to the VF */
2805         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_ETH_ADDR,
2806                                        ret);
2807 }
2808
2809 /**
2810  * i40e_vc_del_mac_addr_msg
2811  * @vf: pointer to the VF info
2812  * @msg: pointer to the msg buffer
2813  *
2814  * remove guest mac address filter
2815  **/
2816 static int i40e_vc_del_mac_addr_msg(struct i40e_vf *vf, u8 *msg)
2817 {
2818         struct virtchnl_ether_addr_list *al =
2819             (struct virtchnl_ether_addr_list *)msg;
2820         bool was_unimac_deleted = false;
2821         struct i40e_pf *pf = vf->pf;
2822         struct i40e_vsi *vsi = NULL;
2823         i40e_status ret = 0;
2824         int i;
2825
2826         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
2827             !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
2828                 ret = I40E_ERR_PARAM;
2829                 goto error_param;
2830         }
2831
2832         for (i = 0; i < al->num_elements; i++) {
2833                 if (is_broadcast_ether_addr(al->list[i].addr) ||
2834                     is_zero_ether_addr(al->list[i].addr)) {
2835                         dev_err(&pf->pdev->dev, "Invalid MAC addr %pM for VF %d\n",
2836                                 al->list[i].addr, vf->vf_id);
2837                         ret = I40E_ERR_INVALID_MAC_ADDR;
2838                         goto error_param;
2839                 }
2840                 if (ether_addr_equal(al->list[i].addr, vf->default_lan_addr.addr))
2841                         was_unimac_deleted = true;
2842         }
2843         vsi = pf->vsi[vf->lan_vsi_idx];
2844
2845         spin_lock_bh(&vsi->mac_filter_hash_lock);
2846         /* delete addresses from the list */
2847         for (i = 0; i < al->num_elements; i++)
2848                 if (i40e_del_mac_filter(vsi, al->list[i].addr)) {
2849                         ret = I40E_ERR_INVALID_MAC_ADDR;
2850                         spin_unlock_bh(&vsi->mac_filter_hash_lock);
2851                         goto error_param;
2852                 }
2853
2854         spin_unlock_bh(&vsi->mac_filter_hash_lock);
2855
2856         /* program the updated filter list */
2857         ret = i40e_sync_vsi_filters(vsi);
2858         if (ret)
2859                 dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n",
2860                         vf->vf_id, ret);
2861
2862         if (vf->trusted && was_unimac_deleted) {
2863                 struct i40e_mac_filter *f;
2864                 struct hlist_node *h;
2865                 u8 *macaddr = NULL;
2866                 int bkt;
2867
2868                 /* set last unicast mac address as default */
2869                 spin_lock_bh(&vsi->mac_filter_hash_lock);
2870                 hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
2871                         if (is_valid_ether_addr(f->macaddr))
2872                                 macaddr = f->macaddr;
2873                 }
2874                 if (macaddr)
2875                         ether_addr_copy(vf->default_lan_addr.addr, macaddr);
2876                 spin_unlock_bh(&vsi->mac_filter_hash_lock);
2877         }
2878 error_param:
2879         /* send the response to the VF */
2880         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_ETH_ADDR, ret);
2881 }
2882
2883 /**
2884  * i40e_vc_add_vlan_msg
2885  * @vf: pointer to the VF info
2886  * @msg: pointer to the msg buffer
2887  *
2888  * program guest vlan id
2889  **/
2890 static int i40e_vc_add_vlan_msg(struct i40e_vf *vf, u8 *msg)
2891 {
2892         struct virtchnl_vlan_filter_list *vfl =
2893             (struct virtchnl_vlan_filter_list *)msg;
2894         struct i40e_pf *pf = vf->pf;
2895         struct i40e_vsi *vsi = NULL;
2896         i40e_status aq_ret = 0;
2897         int i;
2898
2899         if ((vf->num_vlan >= I40E_VC_MAX_VLAN_PER_VF) &&
2900             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
2901                 dev_err(&pf->pdev->dev,
2902                         "VF is not trusted, switch the VF to trusted to add more VLAN addresses\n");
2903                 goto error_param;
2904         }
2905         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
2906             !i40e_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
2907                 aq_ret = I40E_ERR_PARAM;
2908                 goto error_param;
2909         }
2910
2911         for (i = 0; i < vfl->num_elements; i++) {
2912                 if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
2913                         aq_ret = I40E_ERR_PARAM;
2914                         dev_err(&pf->pdev->dev,
2915                                 "invalid VF VLAN id %d\n", vfl->vlan_id[i]);
2916                         goto error_param;
2917                 }
2918         }
2919         vsi = pf->vsi[vf->lan_vsi_idx];
2920         if (vsi->info.pvid) {
2921                 aq_ret = I40E_ERR_PARAM;
2922                 goto error_param;
2923         }
2924
2925         i40e_vlan_stripping_enable(vsi);
2926         for (i = 0; i < vfl->num_elements; i++) {
2927                 /* add new VLAN filter */
2928                 int ret = i40e_vsi_add_vlan(vsi, vfl->vlan_id[i]);
2929                 if (!ret)
2930                         vf->num_vlan++;
2931
2932                 if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
2933                         i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid,
2934                                                            true,
2935                                                            vfl->vlan_id[i],
2936                                                            NULL);
2937                 if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
2938                         i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid,
2939                                                            true,
2940                                                            vfl->vlan_id[i],
2941                                                            NULL);
2942
2943                 if (ret)
2944                         dev_err(&pf->pdev->dev,
2945                                 "Unable to add VLAN filter %d for VF %d, error %d\n",
2946                                 vfl->vlan_id[i], vf->vf_id, ret);
2947         }
2948
2949 error_param:
2950         /* send the response to the VF */
2951         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_VLAN, aq_ret);
2952 }
2953
2954 /**
2955  * i40e_vc_remove_vlan_msg
2956  * @vf: pointer to the VF info
2957  * @msg: pointer to the msg buffer
2958  *
2959  * remove programmed guest vlan id
2960  **/
2961 static int i40e_vc_remove_vlan_msg(struct i40e_vf *vf, u8 *msg)
2962 {
2963         struct virtchnl_vlan_filter_list *vfl =
2964             (struct virtchnl_vlan_filter_list *)msg;
2965         struct i40e_pf *pf = vf->pf;
2966         struct i40e_vsi *vsi = NULL;
2967         i40e_status aq_ret = 0;
2968         int i;
2969
2970         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
2971             !i40e_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
2972                 aq_ret = I40E_ERR_PARAM;
2973                 goto error_param;
2974         }
2975
2976         for (i = 0; i < vfl->num_elements; i++) {
2977                 if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
2978                         aq_ret = I40E_ERR_PARAM;
2979                         goto error_param;
2980                 }
2981         }
2982
2983         vsi = pf->vsi[vf->lan_vsi_idx];
2984         if (vsi->info.pvid) {
2985                 if (vfl->num_elements > 1 || vfl->vlan_id[0])
2986                         aq_ret = I40E_ERR_PARAM;
2987                 goto error_param;
2988         }
2989
2990         for (i = 0; i < vfl->num_elements; i++) {
2991                 i40e_vsi_kill_vlan(vsi, vfl->vlan_id[i]);
2992                 vf->num_vlan--;
2993
2994                 if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
2995                         i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid,
2996                                                            false,
2997                                                            vfl->vlan_id[i],
2998                                                            NULL);
2999                 if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
3000                         i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid,
3001                                                            false,
3002                                                            vfl->vlan_id[i],
3003                                                            NULL);
3004         }
3005
3006 error_param:
3007         /* send the response to the VF */
3008         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_VLAN, aq_ret);
3009 }
3010
3011 /**
3012  * i40e_vc_iwarp_msg
3013  * @vf: pointer to the VF info
3014  * @msg: pointer to the msg buffer
3015  * @msglen: msg length
3016  *
3017  * called from the VF for the iwarp msgs
3018  **/
3019 static int i40e_vc_iwarp_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
3020 {
3021         struct i40e_pf *pf = vf->pf;
3022         int abs_vf_id = vf->vf_id + pf->hw.func_caps.vf_base_id;
3023         i40e_status aq_ret = 0;
3024
3025         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3026             !test_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states)) {
3027                 aq_ret = I40E_ERR_PARAM;
3028                 goto error_param;
3029         }
3030
3031         i40e_notify_client_of_vf_msg(pf->vsi[pf->lan_vsi], abs_vf_id,
3032                                      msg, msglen);
3033
3034 error_param:
3035         /* send the response to the VF */
3036         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_IWARP,
3037                                        aq_ret);
3038 }
3039
3040 /**
3041  * i40e_vc_iwarp_qvmap_msg
3042  * @vf: pointer to the VF info
3043  * @msg: pointer to the msg buffer
3044  * @config: config qvmap or release it
3045  *
3046  * called from the VF for the iwarp msgs
3047  **/
3048 static int i40e_vc_iwarp_qvmap_msg(struct i40e_vf *vf, u8 *msg, bool config)
3049 {
3050         struct virtchnl_iwarp_qvlist_info *qvlist_info =
3051                                 (struct virtchnl_iwarp_qvlist_info *)msg;
3052         i40e_status aq_ret = 0;
3053
3054         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3055             !test_bit(I40E_VF_STATE_IWARPENA, &vf->vf_states)) {
3056                 aq_ret = I40E_ERR_PARAM;
3057                 goto error_param;
3058         }
3059
3060         if (config) {
3061                 if (i40e_config_iwarp_qvlist(vf, qvlist_info))
3062                         aq_ret = I40E_ERR_PARAM;
3063         } else {
3064                 i40e_release_iwarp_qvlist(vf);
3065         }
3066
3067 error_param:
3068         /* send the response to the VF */
3069         return i40e_vc_send_resp_to_vf(vf,
3070                                config ? VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP :
3071                                VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP,
3072                                aq_ret);
3073 }
3074
3075 /**
3076  * i40e_vc_config_rss_key
3077  * @vf: pointer to the VF info
3078  * @msg: pointer to the msg buffer
3079  *
3080  * Configure the VF's RSS key
3081  **/
3082 static int i40e_vc_config_rss_key(struct i40e_vf *vf, u8 *msg)
3083 {
3084         struct virtchnl_rss_key *vrk =
3085                 (struct virtchnl_rss_key *)msg;
3086         struct i40e_pf *pf = vf->pf;
3087         struct i40e_vsi *vsi = NULL;
3088         i40e_status aq_ret = 0;
3089
3090         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3091             !i40e_vc_isvalid_vsi_id(vf, vrk->vsi_id) ||
3092             (vrk->key_len != I40E_HKEY_ARRAY_SIZE)) {
3093                 aq_ret = I40E_ERR_PARAM;
3094                 goto err;
3095         }
3096
3097         vsi = pf->vsi[vf->lan_vsi_idx];
3098         aq_ret = i40e_config_rss(vsi, vrk->key, NULL, 0);
3099 err:
3100         /* send the response to the VF */
3101         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_KEY,
3102                                        aq_ret);
3103 }
3104
3105 /**
3106  * i40e_vc_config_rss_lut
3107  * @vf: pointer to the VF info
3108  * @msg: pointer to the msg buffer
3109  *
3110  * Configure the VF's RSS LUT
3111  **/
3112 static int i40e_vc_config_rss_lut(struct i40e_vf *vf, u8 *msg)
3113 {
3114         struct virtchnl_rss_lut *vrl =
3115                 (struct virtchnl_rss_lut *)msg;
3116         struct i40e_pf *pf = vf->pf;
3117         struct i40e_vsi *vsi = NULL;
3118         i40e_status aq_ret = 0;
3119         u16 i;
3120
3121         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3122             !i40e_vc_isvalid_vsi_id(vf, vrl->vsi_id) ||
3123             (vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE)) {
3124                 aq_ret = I40E_ERR_PARAM;
3125                 goto err;
3126         }
3127
3128         for (i = 0; i < vrl->lut_entries; i++)
3129                 if (vrl->lut[i] >= vf->num_queue_pairs) {
3130                         aq_ret = I40E_ERR_PARAM;
3131                         goto err;
3132                 }
3133
3134         vsi = pf->vsi[vf->lan_vsi_idx];
3135         aq_ret = i40e_config_rss(vsi, NULL, vrl->lut, I40E_VF_HLUT_ARRAY_SIZE);
3136         /* send the response to the VF */
3137 err:
3138         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_LUT,
3139                                        aq_ret);
3140 }
3141
3142 /**
3143  * i40e_vc_get_rss_hena
3144  * @vf: pointer to the VF info
3145  * @msg: pointer to the msg buffer
3146  *
3147  * Return the RSS HENA bits allowed by the hardware
3148  **/
3149 static int i40e_vc_get_rss_hena(struct i40e_vf *vf, u8 *msg)
3150 {
3151         struct virtchnl_rss_hena *vrh = NULL;
3152         struct i40e_pf *pf = vf->pf;
3153         i40e_status aq_ret = 0;
3154         int len = 0;
3155
3156         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3157                 aq_ret = I40E_ERR_PARAM;
3158                 goto err;
3159         }
3160         len = sizeof(struct virtchnl_rss_hena);
3161
3162         vrh = kzalloc(len, GFP_KERNEL);
3163         if (!vrh) {
3164                 aq_ret = I40E_ERR_NO_MEMORY;
3165                 len = 0;
3166                 goto err;
3167         }
3168         vrh->hena = i40e_pf_get_default_rss_hena(pf);
3169 err:
3170         /* send the response back to the VF */
3171         aq_ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_RSS_HENA_CAPS,
3172                                         aq_ret, (u8 *)vrh, len);
3173         kfree(vrh);
3174         return aq_ret;
3175 }
3176
3177 /**
3178  * i40e_vc_set_rss_hena
3179  * @vf: pointer to the VF info
3180  * @msg: pointer to the msg buffer
3181  *
3182  * Set the RSS HENA bits for the VF
3183  **/
3184 static int i40e_vc_set_rss_hena(struct i40e_vf *vf, u8 *msg)
3185 {
3186         struct virtchnl_rss_hena *vrh =
3187                 (struct virtchnl_rss_hena *)msg;
3188         struct i40e_pf *pf = vf->pf;
3189         struct i40e_hw *hw = &pf->hw;
3190         i40e_status aq_ret = 0;
3191
3192         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3193                 aq_ret = I40E_ERR_PARAM;
3194                 goto err;
3195         }
3196         i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)vrh->hena);
3197         i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(1, vf->vf_id),
3198                           (u32)(vrh->hena >> 32));
3199
3200         /* send the response to the VF */
3201 err:
3202         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_SET_RSS_HENA, aq_ret);
3203 }
3204
3205 /**
3206  * i40e_vc_enable_vlan_stripping
3207  * @vf: pointer to the VF info
3208  * @msg: pointer to the msg buffer
3209  *
3210  * Enable vlan header stripping for the VF
3211  **/
3212 static int i40e_vc_enable_vlan_stripping(struct i40e_vf *vf, u8 *msg)
3213 {
3214         i40e_status aq_ret = 0;
3215         struct i40e_vsi *vsi;
3216
3217         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3218                 aq_ret = I40E_ERR_PARAM;
3219                 goto err;
3220         }
3221
3222         vsi = vf->pf->vsi[vf->lan_vsi_idx];
3223         i40e_vlan_stripping_enable(vsi);
3224
3225         /* send the response to the VF */
3226 err:
3227         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING,
3228                                        aq_ret);
3229 }
3230
3231 /**
3232  * i40e_vc_disable_vlan_stripping
3233  * @vf: pointer to the VF info
3234  * @msg: pointer to the msg buffer
3235  *
3236  * Disable vlan header stripping for the VF
3237  **/
3238 static int i40e_vc_disable_vlan_stripping(struct i40e_vf *vf, u8 *msg)
3239 {
3240         i40e_status aq_ret = 0;
3241         struct i40e_vsi *vsi;
3242
3243         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3244                 aq_ret = I40E_ERR_PARAM;
3245                 goto err;
3246         }
3247
3248         vsi = vf->pf->vsi[vf->lan_vsi_idx];
3249         i40e_vlan_stripping_disable(vsi);
3250
3251         /* send the response to the VF */
3252 err:
3253         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING,
3254                                        aq_ret);
3255 }
3256
3257 /**
3258  * i40e_validate_cloud_filter
3259  * @vf: pointer to VF structure
3260  * @tc_filter: pointer to filter requested
3261  *
3262  * This function validates cloud filter programmed as TC filter for ADq
3263  **/
3264 static int i40e_validate_cloud_filter(struct i40e_vf *vf,
3265                                       struct virtchnl_filter *tc_filter)
3266 {
3267         struct virtchnl_l4_spec mask = tc_filter->mask.tcp_spec;
3268         struct virtchnl_l4_spec data = tc_filter->data.tcp_spec;
3269         struct i40e_pf *pf = vf->pf;
3270         struct i40e_vsi *vsi = NULL;
3271         struct i40e_mac_filter *f;
3272         struct hlist_node *h;
3273         bool found = false;
3274         int bkt;
3275
3276         if (!tc_filter->action) {
3277                 dev_info(&pf->pdev->dev,
3278                          "VF %d: Currently ADq doesn't support Drop Action\n",
3279                          vf->vf_id);
3280                 goto err;
3281         }
3282
3283         /* action_meta is TC number here to which the filter is applied */
3284         if (!tc_filter->action_meta ||
3285             tc_filter->action_meta > I40E_MAX_VF_VSI) {
3286                 dev_info(&pf->pdev->dev, "VF %d: Invalid TC number %u\n",
3287                          vf->vf_id, tc_filter->action_meta);
3288                 goto err;
3289         }
3290
3291         /* Check filter if it's programmed for advanced mode or basic mode.
3292          * There are two ADq modes (for VF only),
3293          * 1. Basic mode: intended to allow as many filter options as possible
3294          *                to be added to a VF in Non-trusted mode. Main goal is
3295          *                to add filters to its own MAC and VLAN id.
3296          * 2. Advanced mode: is for allowing filters to be applied other than
3297          *                its own MAC or VLAN. This mode requires the VF to be
3298          *                Trusted.
3299          */
3300         if (mask.dst_mac[0] && !mask.dst_ip[0]) {
3301                 vsi = pf->vsi[vf->lan_vsi_idx];
3302                 f = i40e_find_mac(vsi, data.dst_mac);
3303
3304                 if (!f) {
3305                         dev_info(&pf->pdev->dev,
3306                                  "Destination MAC %pM doesn't belong to VF %d\n",
3307                                  data.dst_mac, vf->vf_id);
3308                         goto err;
3309                 }
3310
3311                 if (mask.vlan_id) {
3312                         hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f,
3313                                            hlist) {
3314                                 if (f->vlan == ntohs(data.vlan_id)) {
3315                                         found = true;
3316                                         break;
3317                                 }
3318                         }
3319                         if (!found) {
3320                                 dev_info(&pf->pdev->dev,
3321                                          "VF %d doesn't have any VLAN id %u\n",
3322                                          vf->vf_id, ntohs(data.vlan_id));
3323                                 goto err;
3324                         }
3325                 }
3326         } else {
3327                 /* Check if VF is trusted */
3328                 if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
3329                         dev_err(&pf->pdev->dev,
3330                                 "VF %d not trusted, make VF trusted to add advanced mode ADq cloud filters\n",
3331                                 vf->vf_id);
3332                         return I40E_ERR_CONFIG;
3333                 }
3334         }
3335
3336         if (mask.dst_mac[0] & data.dst_mac[0]) {
3337                 if (is_broadcast_ether_addr(data.dst_mac) ||
3338                     is_zero_ether_addr(data.dst_mac)) {
3339                         dev_info(&pf->pdev->dev, "VF %d: Invalid Dest MAC addr %pM\n",
3340                                  vf->vf_id, data.dst_mac);
3341                         goto err;
3342                 }
3343         }
3344
3345         if (mask.src_mac[0] & data.src_mac[0]) {
3346                 if (is_broadcast_ether_addr(data.src_mac) ||
3347                     is_zero_ether_addr(data.src_mac)) {
3348                         dev_info(&pf->pdev->dev, "VF %d: Invalid Source MAC addr %pM\n",
3349                                  vf->vf_id, data.src_mac);
3350                         goto err;
3351                 }
3352         }
3353
3354         if (mask.dst_port & data.dst_port) {
3355                 if (!data.dst_port) {
3356                         dev_info(&pf->pdev->dev, "VF %d: Invalid Dest port\n",
3357                                  vf->vf_id);
3358                         goto err;
3359                 }
3360         }
3361
3362         if (mask.src_port & data.src_port) {
3363                 if (!data.src_port) {
3364                         dev_info(&pf->pdev->dev, "VF %d: Invalid Source port\n",
3365                                  vf->vf_id);
3366                         goto err;
3367                 }
3368         }
3369
3370         if (tc_filter->flow_type != VIRTCHNL_TCP_V6_FLOW &&
3371             tc_filter->flow_type != VIRTCHNL_TCP_V4_FLOW) {
3372                 dev_info(&pf->pdev->dev, "VF %d: Invalid Flow type\n",
3373                          vf->vf_id);
3374                 goto err;
3375         }
3376
3377         if (mask.vlan_id & data.vlan_id) {
3378                 if (ntohs(data.vlan_id) > I40E_MAX_VLANID) {
3379                         dev_info(&pf->pdev->dev, "VF %d: invalid VLAN ID\n",
3380                                  vf->vf_id);
3381                         goto err;
3382                 }
3383         }
3384
3385         return I40E_SUCCESS;
3386 err:
3387         return I40E_ERR_CONFIG;
3388 }
3389
3390 /**
3391  * i40e_find_vsi_from_seid - searches for the vsi with the given seid
3392  * @vf: pointer to the VF info
3393  * @seid: seid of the vsi it is searching for
3394  **/
3395 static struct i40e_vsi *i40e_find_vsi_from_seid(struct i40e_vf *vf, u16 seid)
3396 {
3397         struct i40e_pf *pf = vf->pf;
3398         struct i40e_vsi *vsi = NULL;
3399         int i;
3400
3401         for (i = 0; i < vf->num_tc ; i++) {
3402                 vsi = i40e_find_vsi_from_id(pf, vf->ch[i].vsi_id);
3403                 if (vsi && vsi->seid == seid)
3404                         return vsi;
3405         }
3406         return NULL;
3407 }
3408
3409 /**
3410  * i40e_del_all_cloud_filters
3411  * @vf: pointer to the VF info
3412  *
3413  * This function deletes all cloud filters
3414  **/
3415 static void i40e_del_all_cloud_filters(struct i40e_vf *vf)
3416 {
3417         struct i40e_cloud_filter *cfilter = NULL;
3418         struct i40e_pf *pf = vf->pf;
3419         struct i40e_vsi *vsi = NULL;
3420         struct hlist_node *node;
3421         int ret;
3422
3423         hlist_for_each_entry_safe(cfilter, node,
3424                                   &vf->cloud_filter_list, cloud_node) {
3425                 vsi = i40e_find_vsi_from_seid(vf, cfilter->seid);
3426
3427                 if (!vsi) {
3428                         dev_err(&pf->pdev->dev, "VF %d: no VSI found for matching %u seid, can't delete cloud filter\n",
3429                                 vf->vf_id, cfilter->seid);
3430                         continue;
3431                 }
3432
3433                 if (cfilter->dst_port)
3434                         ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter,
3435                                                                 false);
3436                 else
3437                         ret = i40e_add_del_cloud_filter(vsi, cfilter, false);
3438                 if (ret)
3439                         dev_err(&pf->pdev->dev,
3440                                 "VF %d: Failed to delete cloud filter, err %s aq_err %s\n",
3441                                 vf->vf_id, i40e_stat_str(&pf->hw, ret),
3442                                 i40e_aq_str(&pf->hw,
3443                                             pf->hw.aq.asq_last_status));
3444
3445                 hlist_del(&cfilter->cloud_node);
3446                 kfree(cfilter);
3447                 vf->num_cloud_filters--;
3448         }
3449 }
3450
3451 /**
3452  * i40e_vc_del_cloud_filter
3453  * @vf: pointer to the VF info
3454  * @msg: pointer to the msg buffer
3455  *
3456  * This function deletes a cloud filter programmed as TC filter for ADq
3457  **/
3458 static int i40e_vc_del_cloud_filter(struct i40e_vf *vf, u8 *msg)
3459 {
3460         struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg;
3461         struct virtchnl_l4_spec mask = vcf->mask.tcp_spec;
3462         struct virtchnl_l4_spec tcf = vcf->data.tcp_spec;
3463         struct i40e_cloud_filter cfilter, *cf = NULL;
3464         struct i40e_pf *pf = vf->pf;
3465         struct i40e_vsi *vsi = NULL;
3466         struct hlist_node *node;
3467         i40e_status aq_ret = 0;
3468         int i, ret;
3469
3470         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3471                 aq_ret = I40E_ERR_PARAM;
3472                 goto err;
3473         }
3474
3475         if (!vf->adq_enabled) {
3476                 dev_info(&pf->pdev->dev,
3477                          "VF %d: ADq not enabled, can't apply cloud filter\n",
3478                          vf->vf_id);
3479                 aq_ret = I40E_ERR_PARAM;
3480                 goto err;
3481         }
3482
3483         if (i40e_validate_cloud_filter(vf, vcf)) {
3484                 dev_info(&pf->pdev->dev,
3485                          "VF %d: Invalid input, can't apply cloud filter\n",
3486                          vf->vf_id);
3487                 aq_ret = I40E_ERR_PARAM;
3488                 goto err;
3489         }
3490
3491         memset(&cfilter, 0, sizeof(cfilter));
3492         /* parse destination mac address */
3493         for (i = 0; i < ETH_ALEN; i++)
3494                 cfilter.dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i];
3495
3496         /* parse source mac address */
3497         for (i = 0; i < ETH_ALEN; i++)
3498                 cfilter.src_mac[i] = mask.src_mac[i] & tcf.src_mac[i];
3499
3500         cfilter.vlan_id = mask.vlan_id & tcf.vlan_id;
3501         cfilter.dst_port = mask.dst_port & tcf.dst_port;
3502         cfilter.src_port = mask.src_port & tcf.src_port;
3503
3504         switch (vcf->flow_type) {
3505         case VIRTCHNL_TCP_V4_FLOW:
3506                 cfilter.n_proto = ETH_P_IP;
3507                 if (mask.dst_ip[0] & tcf.dst_ip[0])
3508                         memcpy(&cfilter.ip.v4.dst_ip, tcf.dst_ip,
3509                                ARRAY_SIZE(tcf.dst_ip));
3510                 else if (mask.src_ip[0] & tcf.dst_ip[0])
3511                         memcpy(&cfilter.ip.v4.src_ip, tcf.src_ip,
3512                                ARRAY_SIZE(tcf.dst_ip));
3513                 break;
3514         case VIRTCHNL_TCP_V6_FLOW:
3515                 cfilter.n_proto = ETH_P_IPV6;
3516                 if (mask.dst_ip[3] & tcf.dst_ip[3])
3517                         memcpy(&cfilter.ip.v6.dst_ip6, tcf.dst_ip,
3518                                sizeof(cfilter.ip.v6.dst_ip6));
3519                 if (mask.src_ip[3] & tcf.src_ip[3])
3520                         memcpy(&cfilter.ip.v6.src_ip6, tcf.src_ip,
3521                                sizeof(cfilter.ip.v6.src_ip6));
3522                 break;
3523         default:
3524                 /* TC filter can be configured based on different combinations
3525                  * and in this case IP is not a part of filter config
3526                  */
3527                 dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n",
3528                          vf->vf_id);
3529         }
3530
3531         /* get the vsi to which the tc belongs to */
3532         vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx];
3533         cfilter.seid = vsi->seid;
3534         cfilter.flags = vcf->field_flags;
3535
3536         /* Deleting TC filter */
3537         if (tcf.dst_port)
3538                 ret = i40e_add_del_cloud_filter_big_buf(vsi, &cfilter, false);
3539         else
3540                 ret = i40e_add_del_cloud_filter(vsi, &cfilter, false);
3541         if (ret) {
3542                 dev_err(&pf->pdev->dev,
3543                         "VF %d: Failed to delete cloud filter, err %s aq_err %s\n",
3544                         vf->vf_id, i40e_stat_str(&pf->hw, ret),
3545                         i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status));
3546                 goto err;
3547         }
3548
3549         hlist_for_each_entry_safe(cf, node,
3550                                   &vf->cloud_filter_list, cloud_node) {
3551                 if (cf->seid != cfilter.seid)
3552                         continue;
3553                 if (mask.dst_port)
3554                         if (cfilter.dst_port != cf->dst_port)
3555                                 continue;
3556                 if (mask.dst_mac[0])
3557                         if (!ether_addr_equal(cf->src_mac, cfilter.src_mac))
3558                                 continue;
3559                 /* for ipv4 data to be valid, only first byte of mask is set */
3560                 if (cfilter.n_proto == ETH_P_IP && mask.dst_ip[0])
3561                         if (memcmp(&cfilter.ip.v4.dst_ip, &cf->ip.v4.dst_ip,
3562                                    ARRAY_SIZE(tcf.dst_ip)))
3563                                 continue;
3564                 /* for ipv6, mask is set for all sixteen bytes (4 words) */
3565                 if (cfilter.n_proto == ETH_P_IPV6 && mask.dst_ip[3])
3566                         if (memcmp(&cfilter.ip.v6.dst_ip6, &cf->ip.v6.dst_ip6,
3567                                    sizeof(cfilter.ip.v6.src_ip6)))
3568                                 continue;
3569                 if (mask.vlan_id)
3570                         if (cfilter.vlan_id != cf->vlan_id)
3571                                 continue;
3572
3573                 hlist_del(&cf->cloud_node);
3574                 kfree(cf);
3575                 vf->num_cloud_filters--;
3576         }
3577
3578 err:
3579         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_CLOUD_FILTER,
3580                                        aq_ret);
3581 }
3582
3583 /**
3584  * i40e_vc_add_cloud_filter
3585  * @vf: pointer to the VF info
3586  * @msg: pointer to the msg buffer
3587  *
3588  * This function adds a cloud filter programmed as TC filter for ADq
3589  **/
3590 static int i40e_vc_add_cloud_filter(struct i40e_vf *vf, u8 *msg)
3591 {
3592         struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg;
3593         struct virtchnl_l4_spec mask = vcf->mask.tcp_spec;
3594         struct virtchnl_l4_spec tcf = vcf->data.tcp_spec;
3595         struct i40e_cloud_filter *cfilter = NULL;
3596         struct i40e_pf *pf = vf->pf;
3597         struct i40e_vsi *vsi = NULL;
3598         i40e_status aq_ret = 0;
3599         int i, ret;
3600
3601         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3602                 aq_ret = I40E_ERR_PARAM;
3603                 goto err_out;
3604         }
3605
3606         if (!vf->adq_enabled) {
3607                 dev_info(&pf->pdev->dev,
3608                          "VF %d: ADq is not enabled, can't apply cloud filter\n",
3609                          vf->vf_id);
3610                 aq_ret = I40E_ERR_PARAM;
3611                 goto err_out;
3612         }
3613
3614         if (i40e_validate_cloud_filter(vf, vcf)) {
3615                 dev_info(&pf->pdev->dev,
3616                          "VF %d: Invalid input/s, can't apply cloud filter\n",
3617                          vf->vf_id);
3618                 aq_ret = I40E_ERR_PARAM;
3619                 goto err_out;
3620         }
3621
3622         cfilter = kzalloc(sizeof(*cfilter), GFP_KERNEL);
3623         if (!cfilter)
3624                 return -ENOMEM;
3625
3626         /* parse destination mac address */
3627         for (i = 0; i < ETH_ALEN; i++)
3628                 cfilter->dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i];
3629
3630         /* parse source mac address */
3631         for (i = 0; i < ETH_ALEN; i++)
3632                 cfilter->src_mac[i] = mask.src_mac[i] & tcf.src_mac[i];
3633
3634         cfilter->vlan_id = mask.vlan_id & tcf.vlan_id;
3635         cfilter->dst_port = mask.dst_port & tcf.dst_port;
3636         cfilter->src_port = mask.src_port & tcf.src_port;
3637
3638         switch (vcf->flow_type) {
3639         case VIRTCHNL_TCP_V4_FLOW:
3640                 cfilter->n_proto = ETH_P_IP;
3641                 if (mask.dst_ip[0] & tcf.dst_ip[0])
3642                         memcpy(&cfilter->ip.v4.dst_ip, tcf.dst_ip,
3643                                ARRAY_SIZE(tcf.dst_ip));
3644                 else if (mask.src_ip[0] & tcf.dst_ip[0])
3645                         memcpy(&cfilter->ip.v4.src_ip, tcf.src_ip,
3646                                ARRAY_SIZE(tcf.dst_ip));
3647                 break;
3648         case VIRTCHNL_TCP_V6_FLOW:
3649                 cfilter->n_proto = ETH_P_IPV6;
3650                 if (mask.dst_ip[3] & tcf.dst_ip[3])
3651                         memcpy(&cfilter->ip.v6.dst_ip6, tcf.dst_ip,
3652                                sizeof(cfilter->ip.v6.dst_ip6));
3653                 if (mask.src_ip[3] & tcf.src_ip[3])
3654                         memcpy(&cfilter->ip.v6.src_ip6, tcf.src_ip,
3655                                sizeof(cfilter->ip.v6.src_ip6));
3656                 break;
3657         default:
3658                 /* TC filter can be configured based on different combinations
3659                  * and in this case IP is not a part of filter config
3660                  */
3661                 dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n",
3662                          vf->vf_id);
3663         }
3664
3665         /* get the VSI to which the TC belongs to */
3666         vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx];
3667         cfilter->seid = vsi->seid;
3668         cfilter->flags = vcf->field_flags;
3669
3670         /* Adding cloud filter programmed as TC filter */
3671         if (tcf.dst_port)
3672                 ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter, true);
3673         else
3674                 ret = i40e_add_del_cloud_filter(vsi, cfilter, true);
3675         if (ret) {
3676                 dev_err(&pf->pdev->dev,
3677                         "VF %d: Failed to add cloud filter, err %s aq_err %s\n",
3678                         vf->vf_id, i40e_stat_str(&pf->hw, ret),
3679                         i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status));
3680                 goto err_free;
3681         }
3682
3683         INIT_HLIST_NODE(&cfilter->cloud_node);
3684         hlist_add_head(&cfilter->cloud_node, &vf->cloud_filter_list);
3685         /* release the pointer passing it to the collection */
3686         cfilter = NULL;
3687         vf->num_cloud_filters++;
3688 err_free:
3689         kfree(cfilter);
3690 err_out:
3691         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_CLOUD_FILTER,
3692                                        aq_ret);
3693 }
3694
3695 /**
3696  * i40e_vc_add_qch_msg: Add queue channel and enable ADq
3697  * @vf: pointer to the VF info
3698  * @msg: pointer to the msg buffer
3699  **/
3700 static int i40e_vc_add_qch_msg(struct i40e_vf *vf, u8 *msg)
3701 {
3702         struct virtchnl_tc_info *tci =
3703                 (struct virtchnl_tc_info *)msg;
3704         struct i40e_pf *pf = vf->pf;
3705         struct i40e_link_status *ls = &pf->hw.phy.link_info;
3706         int i, adq_request_qps = 0;
3707         i40e_status aq_ret = 0;
3708         u64 speed = 0;
3709
3710         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3711                 aq_ret = I40E_ERR_PARAM;
3712                 goto err;
3713         }
3714
3715         /* ADq cannot be applied if spoof check is ON */
3716         if (vf->spoofchk) {
3717                 dev_err(&pf->pdev->dev,
3718                         "Spoof check is ON, turn it OFF to enable ADq\n");
3719                 aq_ret = I40E_ERR_PARAM;
3720                 goto err;
3721         }
3722
3723         if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ)) {
3724                 dev_err(&pf->pdev->dev,
3725                         "VF %d attempting to enable ADq, but hasn't properly negotiated that capability\n",
3726                         vf->vf_id);
3727                 aq_ret = I40E_ERR_PARAM;
3728                 goto err;
3729         }
3730
3731         /* max number of traffic classes for VF currently capped at 4 */
3732         if (!tci->num_tc || tci->num_tc > I40E_MAX_VF_VSI) {
3733                 dev_err(&pf->pdev->dev,
3734                         "VF %d trying to set %u TCs, valid range 1-%u TCs per VF\n",
3735                         vf->vf_id, tci->num_tc, I40E_MAX_VF_VSI);
3736                 aq_ret = I40E_ERR_PARAM;
3737                 goto err;
3738         }
3739
3740         /* validate queues for each TC */
3741         for (i = 0; i < tci->num_tc; i++)
3742                 if (!tci->list[i].count ||
3743                     tci->list[i].count > I40E_DEFAULT_QUEUES_PER_VF) {
3744                         dev_err(&pf->pdev->dev,
3745                                 "VF %d: TC %d trying to set %u queues, valid range 1-%u queues per TC\n",
3746                                 vf->vf_id, i, tci->list[i].count,
3747                                 I40E_DEFAULT_QUEUES_PER_VF);
3748                         aq_ret = I40E_ERR_PARAM;
3749                         goto err;
3750                 }
3751
3752         /* need Max VF queues but already have default number of queues */
3753         adq_request_qps = I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF;
3754
3755         if (pf->queues_left < adq_request_qps) {
3756                 dev_err(&pf->pdev->dev,
3757                         "No queues left to allocate to VF %d\n",
3758                         vf->vf_id);
3759                 aq_ret = I40E_ERR_PARAM;
3760                 goto err;
3761         } else {
3762                 /* we need to allocate max VF queues to enable ADq so as to
3763                  * make sure ADq enabled VF always gets back queues when it
3764                  * goes through a reset.
3765                  */
3766                 vf->num_queue_pairs = I40E_MAX_VF_QUEUES;
3767         }
3768
3769         /* get link speed in MB to validate rate limit */
3770         speed = i40e_vc_link_speed2mbps(ls->link_speed);
3771         if (speed == SPEED_UNKNOWN) {
3772                 dev_err(&pf->pdev->dev,
3773                         "Cannot detect link speed\n");
3774                 aq_ret = I40E_ERR_PARAM;
3775                 goto err;
3776         }
3777
3778         /* parse data from the queue channel info */
3779         vf->num_tc = tci->num_tc;
3780         for (i = 0; i < vf->num_tc; i++) {
3781                 if (tci->list[i].max_tx_rate) {
3782                         if (tci->list[i].max_tx_rate > speed) {
3783                                 dev_err(&pf->pdev->dev,
3784                                         "Invalid max tx rate %llu specified for VF %d.",
3785                                         tci->list[i].max_tx_rate,
3786                                         vf->vf_id);
3787                                 aq_ret = I40E_ERR_PARAM;
3788                                 goto err;
3789                         } else {
3790                                 vf->ch[i].max_tx_rate =
3791                                         tci->list[i].max_tx_rate;
3792                         }
3793                 }
3794                 vf->ch[i].num_qps = tci->list[i].count;
3795         }
3796
3797         /* set this flag only after making sure all inputs are sane */
3798         vf->adq_enabled = true;
3799         /* num_req_queues is set when user changes number of queues via ethtool
3800          * and this causes issue for default VSI(which depends on this variable)
3801          * when ADq is enabled, hence reset it.
3802          */
3803         vf->num_req_queues = 0;
3804
3805         /* reset the VF in order to allocate resources */
3806         i40e_vc_notify_vf_reset(vf);
3807         i40e_reset_vf(vf, false);
3808
3809         return I40E_SUCCESS;
3810
3811         /* send the response to the VF */
3812 err:
3813         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_CHANNELS,
3814                                        aq_ret);
3815 }
3816
3817 /**
3818  * i40e_vc_del_qch_msg
3819  * @vf: pointer to the VF info
3820  * @msg: pointer to the msg buffer
3821  **/
3822 static int i40e_vc_del_qch_msg(struct i40e_vf *vf, u8 *msg)
3823 {
3824         struct i40e_pf *pf = vf->pf;
3825         i40e_status aq_ret = 0;
3826
3827         if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
3828                 aq_ret = I40E_ERR_PARAM;
3829                 goto err;
3830         }
3831
3832         if (vf->adq_enabled) {
3833                 i40e_del_all_cloud_filters(vf);
3834                 i40e_del_qch(vf);
3835                 vf->adq_enabled = false;
3836                 vf->num_tc = 0;
3837                 dev_info(&pf->pdev->dev,
3838                          "Deleting Queue Channels and cloud filters for ADq on VF %d\n",
3839                          vf->vf_id);
3840         } else {
3841                 dev_info(&pf->pdev->dev, "VF %d trying to delete queue channels but ADq isn't enabled\n",
3842                          vf->vf_id);
3843                 aq_ret = I40E_ERR_PARAM;
3844         }
3845
3846         /* reset the VF in order to allocate resources */
3847         i40e_vc_notify_vf_reset(vf);
3848         i40e_reset_vf(vf, false);
3849
3850         return I40E_SUCCESS;
3851
3852 err:
3853         return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_CHANNELS,
3854                                        aq_ret);
3855 }
3856
3857 /**
3858  * i40e_vc_process_vf_msg
3859  * @pf: pointer to the PF structure
3860  * @vf_id: source VF id
3861  * @v_opcode: operation code
3862  * @v_retval: unused return value code
3863  * @msg: pointer to the msg buffer
3864  * @msglen: msg length
3865  *
3866  * called from the common aeq/arq handler to
3867  * process request from VF
3868  **/
3869 int i40e_vc_process_vf_msg(struct i40e_pf *pf, s16 vf_id, u32 v_opcode,
3870                            u32 __always_unused v_retval, u8 *msg, u16 msglen)
3871 {
3872         struct i40e_hw *hw = &pf->hw;
3873         int local_vf_id = vf_id - (s16)hw->func_caps.vf_base_id;
3874         struct i40e_vf *vf;
3875         int ret;
3876
3877         pf->vf_aq_requests++;
3878         if (local_vf_id < 0 || local_vf_id >= pf->num_alloc_vfs)
3879                 return -EINVAL;
3880         vf = &(pf->vf[local_vf_id]);
3881
3882         /* Check if VF is disabled. */
3883         if (test_bit(I40E_VF_STATE_DISABLED, &vf->vf_states))
3884                 return I40E_ERR_PARAM;
3885
3886         /* perform basic checks on the msg */
3887         ret = virtchnl_vc_validate_vf_msg(&vf->vf_ver, v_opcode, msg, msglen);
3888
3889         if (ret) {
3890                 i40e_vc_send_resp_to_vf(vf, v_opcode, I40E_ERR_PARAM);
3891                 dev_err(&pf->pdev->dev, "Invalid message from VF %d, opcode %d, len %d\n",
3892                         local_vf_id, v_opcode, msglen);
3893                 switch (ret) {
3894                 case VIRTCHNL_STATUS_ERR_PARAM:
3895                         return -EPERM;
3896                 default:
3897                         return -EINVAL;
3898                 }
3899         }
3900
3901         switch (v_opcode) {
3902         case VIRTCHNL_OP_VERSION:
3903                 ret = i40e_vc_get_version_msg(vf, msg);
3904                 break;
3905         case VIRTCHNL_OP_GET_VF_RESOURCES:
3906                 ret = i40e_vc_get_vf_resources_msg(vf, msg);
3907                 i40e_vc_notify_vf_link_state(vf);
3908                 break;
3909         case VIRTCHNL_OP_RESET_VF:
3910                 i40e_vc_reset_vf_msg(vf);
3911                 ret = 0;
3912                 break;
3913         case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
3914                 ret = i40e_vc_config_promiscuous_mode_msg(vf, msg);
3915                 break;
3916         case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
3917                 ret = i40e_vc_config_queues_msg(vf, msg);
3918                 break;
3919         case VIRTCHNL_OP_CONFIG_IRQ_MAP:
3920                 ret = i40e_vc_config_irq_map_msg(vf, msg);
3921                 break;
3922         case VIRTCHNL_OP_ENABLE_QUEUES:
3923                 ret = i40e_vc_enable_queues_msg(vf, msg);
3924                 i40e_vc_notify_vf_link_state(vf);
3925                 break;
3926         case VIRTCHNL_OP_DISABLE_QUEUES:
3927                 ret = i40e_vc_disable_queues_msg(vf, msg);
3928                 break;
3929         case VIRTCHNL_OP_ADD_ETH_ADDR:
3930                 ret = i40e_vc_add_mac_addr_msg(vf, msg);
3931                 break;
3932         case VIRTCHNL_OP_DEL_ETH_ADDR:
3933                 ret = i40e_vc_del_mac_addr_msg(vf, msg);
3934                 break;
3935         case VIRTCHNL_OP_ADD_VLAN:
3936                 ret = i40e_vc_add_vlan_msg(vf, msg);
3937                 break;
3938         case VIRTCHNL_OP_DEL_VLAN:
3939                 ret = i40e_vc_remove_vlan_msg(vf, msg);
3940                 break;
3941         case VIRTCHNL_OP_GET_STATS:
3942                 ret = i40e_vc_get_stats_msg(vf, msg);
3943                 break;
3944         case VIRTCHNL_OP_IWARP:
3945                 ret = i40e_vc_iwarp_msg(vf, msg, msglen);
3946                 break;
3947         case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
3948                 ret = i40e_vc_iwarp_qvmap_msg(vf, msg, true);
3949                 break;
3950         case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP:
3951                 ret = i40e_vc_iwarp_qvmap_msg(vf, msg, false);
3952                 break;
3953         case VIRTCHNL_OP_CONFIG_RSS_KEY:
3954                 ret = i40e_vc_config_rss_key(vf, msg);
3955                 break;
3956         case VIRTCHNL_OP_CONFIG_RSS_LUT:
3957                 ret = i40e_vc_config_rss_lut(vf, msg);
3958                 break;
3959         case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
3960                 ret = i40e_vc_get_rss_hena(vf, msg);
3961                 break;
3962         case VIRTCHNL_OP_SET_RSS_HENA:
3963                 ret = i40e_vc_set_rss_hena(vf, msg);
3964                 break;
3965         case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
3966                 ret = i40e_vc_enable_vlan_stripping(vf, msg);
3967                 break;
3968         case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
3969                 ret = i40e_vc_disable_vlan_stripping(vf, msg);
3970                 break;
3971         case VIRTCHNL_OP_REQUEST_QUEUES:
3972                 ret = i40e_vc_request_queues_msg(vf, msg);
3973                 break;
3974         case VIRTCHNL_OP_ENABLE_CHANNELS:
3975                 ret = i40e_vc_add_qch_msg(vf, msg);
3976                 break;
3977         case VIRTCHNL_OP_DISABLE_CHANNELS:
3978                 ret = i40e_vc_del_qch_msg(vf, msg);
3979                 break;
3980         case VIRTCHNL_OP_ADD_CLOUD_FILTER:
3981                 ret = i40e_vc_add_cloud_filter(vf, msg);
3982                 break;
3983         case VIRTCHNL_OP_DEL_CLOUD_FILTER:
3984                 ret = i40e_vc_del_cloud_filter(vf, msg);
3985                 break;
3986         case VIRTCHNL_OP_UNKNOWN:
3987         default:
3988                 dev_err(&pf->pdev->dev, "Unsupported opcode %d from VF %d\n",
3989                         v_opcode, local_vf_id);
3990                 ret = i40e_vc_send_resp_to_vf(vf, v_opcode,
3991                                               I40E_ERR_NOT_IMPLEMENTED);
3992                 break;
3993         }
3994
3995         return ret;
3996 }
3997
3998 /**
3999  * i40e_vc_process_vflr_event
4000  * @pf: pointer to the PF structure
4001  *
4002  * called from the vlfr irq handler to
4003  * free up VF resources and state variables
4004  **/
4005 int i40e_vc_process_vflr_event(struct i40e_pf *pf)
4006 {
4007         struct i40e_hw *hw = &pf->hw;
4008         u32 reg, reg_idx, bit_idx;
4009         struct i40e_vf *vf;
4010         int vf_id;
4011
4012         if (!test_bit(__I40E_VFLR_EVENT_PENDING, pf->state))
4013                 return 0;
4014
4015         /* Re-enable the VFLR interrupt cause here, before looking for which
4016          * VF got reset. Otherwise, if another VF gets a reset while the
4017          * first one is being processed, that interrupt will be lost, and
4018          * that VF will be stuck in reset forever.
4019          */
4020         reg = rd32(hw, I40E_PFINT_ICR0_ENA);
4021         reg |= I40E_PFINT_ICR0_ENA_VFLR_MASK;
4022         wr32(hw, I40E_PFINT_ICR0_ENA, reg);
4023         i40e_flush(hw);
4024
4025         clear_bit(__I40E_VFLR_EVENT_PENDING, pf->state);
4026         for (vf_id = 0; vf_id < pf->num_alloc_vfs; vf_id++) {
4027                 reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
4028                 bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
4029                 /* read GLGEN_VFLRSTAT register to find out the flr VFs */
4030                 vf = &pf->vf[vf_id];
4031                 reg = rd32(hw, I40E_GLGEN_VFLRSTAT(reg_idx));
4032                 if (reg & BIT(bit_idx))
4033                         /* i40e_reset_vf will clear the bit in GLGEN_VFLRSTAT */
4034                         i40e_reset_vf(vf, true);
4035         }
4036
4037         return 0;
4038 }
4039
4040 /**
4041  * i40e_validate_vf
4042  * @pf: the physical function
4043  * @vf_id: VF identifier
4044  *
4045  * Check that the VF is enabled and the VSI exists.
4046  *
4047  * Returns 0 on success, negative on failure
4048  **/
4049 static int i40e_validate_vf(struct i40e_pf *pf, int vf_id)
4050 {
4051         struct i40e_vsi *vsi;
4052         struct i40e_vf *vf;
4053         int ret = 0;
4054
4055         if (vf_id >= pf->num_alloc_vfs) {
4056                 dev_err(&pf->pdev->dev,
4057                         "Invalid VF Identifier %d\n", vf_id);
4058                 ret = -EINVAL;
4059                 goto err_out;
4060         }
4061         vf = &pf->vf[vf_id];
4062         vsi = i40e_find_vsi_from_id(pf, vf->lan_vsi_id);
4063         if (!vsi)
4064                 ret = -EINVAL;
4065 err_out:
4066         return ret;
4067 }
4068
4069 /**
4070  * i40e_ndo_set_vf_mac
4071  * @netdev: network interface device structure
4072  * @vf_id: VF identifier
4073  * @mac: mac address
4074  *
4075  * program VF mac address
4076  **/
4077 int i40e_ndo_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac)
4078 {
4079         struct i40e_netdev_priv *np = netdev_priv(netdev);
4080         struct i40e_vsi *vsi = np->vsi;
4081         struct i40e_pf *pf = vsi->back;
4082         struct i40e_mac_filter *f;
4083         struct i40e_vf *vf;
4084         int ret = 0;
4085         struct hlist_node *h;
4086         int bkt;
4087         u8 i;
4088
4089         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4090                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4091                 return -EAGAIN;
4092         }
4093
4094         /* validate the request */
4095         ret = i40e_validate_vf(pf, vf_id);
4096         if (ret)
4097                 goto error_param;
4098
4099         vf = &pf->vf[vf_id];
4100
4101         /* When the VF is resetting wait until it is done.
4102          * It can take up to 200 milliseconds,
4103          * but wait for up to 300 milliseconds to be safe.
4104          * Acquire the VSI pointer only after the VF has been
4105          * properly initialized.
4106          */
4107         for (i = 0; i < 15; i++) {
4108                 if (test_bit(I40E_VF_STATE_INIT, &vf->vf_states))
4109                         break;
4110                 msleep(20);
4111         }
4112         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4113                 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n",
4114                         vf_id);
4115                 ret = -EAGAIN;
4116                 goto error_param;
4117         }
4118         vsi = pf->vsi[vf->lan_vsi_idx];
4119
4120         if (is_multicast_ether_addr(mac)) {
4121                 dev_err(&pf->pdev->dev,
4122                         "Invalid Ethernet address %pM for VF %d\n", mac, vf_id);
4123                 ret = -EINVAL;
4124                 goto error_param;
4125         }
4126
4127         /* Lock once because below invoked function add/del_filter requires
4128          * mac_filter_hash_lock to be held
4129          */
4130         spin_lock_bh(&vsi->mac_filter_hash_lock);
4131
4132         /* delete the temporary mac address */
4133         if (!is_zero_ether_addr(vf->default_lan_addr.addr))
4134                 i40e_del_mac_filter(vsi, vf->default_lan_addr.addr);
4135
4136         /* Delete all the filters for this VSI - we're going to kill it
4137          * anyway.
4138          */
4139         hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist)
4140                 __i40e_del_filter(vsi, f);
4141
4142         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4143
4144         /* program mac filter */
4145         if (i40e_sync_vsi_filters(vsi)) {
4146                 dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
4147                 ret = -EIO;
4148                 goto error_param;
4149         }
4150         ether_addr_copy(vf->default_lan_addr.addr, mac);
4151
4152         if (is_zero_ether_addr(mac)) {
4153                 vf->pf_set_mac = false;
4154                 dev_info(&pf->pdev->dev, "Removing MAC on VF %d\n", vf_id);
4155         } else {
4156                 vf->pf_set_mac = true;
4157                 dev_info(&pf->pdev->dev, "Setting MAC %pM on VF %d\n",
4158                          mac, vf_id);
4159         }
4160
4161         /* Force the VF interface down so it has to bring up with new MAC
4162          * address
4163          */
4164         i40e_vc_disable_vf(vf);
4165         dev_info(&pf->pdev->dev, "Bring down and up the VF interface to make this change effective.\n");
4166
4167 error_param:
4168         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4169         return ret;
4170 }
4171
4172 /**
4173  * i40e_vsi_has_vlans - True if VSI has configured VLANs
4174  * @vsi: pointer to the vsi
4175  *
4176  * Check if a VSI has configured any VLANs. False if we have a port VLAN or if
4177  * we have no configured VLANs. Do not call while holding the
4178  * mac_filter_hash_lock.
4179  */
4180 static bool i40e_vsi_has_vlans(struct i40e_vsi *vsi)
4181 {
4182         bool have_vlans;
4183
4184         /* If we have a port VLAN, then the VSI cannot have any VLANs
4185          * configured, as all MAC/VLAN filters will be assigned to the PVID.
4186          */
4187         if (vsi->info.pvid)
4188                 return false;
4189
4190         /* Since we don't have a PVID, we know that if the device is in VLAN
4191          * mode it must be because of a VLAN filter configured on this VSI.
4192          */
4193         spin_lock_bh(&vsi->mac_filter_hash_lock);
4194         have_vlans = i40e_is_vsi_in_vlan(vsi);
4195         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4196
4197         return have_vlans;
4198 }
4199
4200 /**
4201  * i40e_ndo_set_vf_port_vlan
4202  * @netdev: network interface device structure
4203  * @vf_id: VF identifier
4204  * @vlan_id: mac address
4205  * @qos: priority setting
4206  * @vlan_proto: vlan protocol
4207  *
4208  * program VF vlan id and/or qos
4209  **/
4210 int i40e_ndo_set_vf_port_vlan(struct net_device *netdev, int vf_id,
4211                               u16 vlan_id, u8 qos, __be16 vlan_proto)
4212 {
4213         u16 vlanprio = vlan_id | (qos << I40E_VLAN_PRIORITY_SHIFT);
4214         struct i40e_netdev_priv *np = netdev_priv(netdev);
4215         bool allmulti = false, alluni = false;
4216         struct i40e_pf *pf = np->vsi->back;
4217         struct i40e_vsi *vsi;
4218         struct i40e_vf *vf;
4219         int ret = 0;
4220
4221         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4222                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4223                 return -EAGAIN;
4224         }
4225
4226         /* validate the request */
4227         ret = i40e_validate_vf(pf, vf_id);
4228         if (ret)
4229                 goto error_pvid;
4230
4231         if ((vlan_id > I40E_MAX_VLANID) || (qos > 7)) {
4232                 dev_err(&pf->pdev->dev, "Invalid VF Parameters\n");
4233                 ret = -EINVAL;
4234                 goto error_pvid;
4235         }
4236
4237         if (vlan_proto != htons(ETH_P_8021Q)) {
4238                 dev_err(&pf->pdev->dev, "VF VLAN protocol is not supported\n");
4239                 ret = -EPROTONOSUPPORT;
4240                 goto error_pvid;
4241         }
4242
4243         vf = &pf->vf[vf_id];
4244         vsi = pf->vsi[vf->lan_vsi_idx];
4245         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4246                 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n",
4247                         vf_id);
4248                 ret = -EAGAIN;
4249                 goto error_pvid;
4250         }
4251
4252         if (le16_to_cpu(vsi->info.pvid) == vlanprio)
4253                 /* duplicate request, so just return success */
4254                 goto error_pvid;
4255
4256         if (i40e_vsi_has_vlans(vsi)) {
4257                 dev_err(&pf->pdev->dev,
4258                         "VF %d has already configured VLAN filters and the administrator is requesting a port VLAN override.\nPlease unload and reload the VF driver for this change to take effect.\n",
4259                         vf_id);
4260                 /* Administrator Error - knock the VF offline until he does
4261                  * the right thing by reconfiguring his network correctly
4262                  * and then reloading the VF driver.
4263                  */
4264                 i40e_vc_disable_vf(vf);
4265                 /* During reset the VF got a new VSI, so refresh the pointer. */
4266                 vsi = pf->vsi[vf->lan_vsi_idx];
4267         }
4268
4269         /* Locked once because multiple functions below iterate list */
4270         spin_lock_bh(&vsi->mac_filter_hash_lock);
4271
4272         /* Check for condition where there was already a port VLAN ID
4273          * filter set and now it is being deleted by setting it to zero.
4274          * Additionally check for the condition where there was a port
4275          * VLAN but now there is a new and different port VLAN being set.
4276          * Before deleting all the old VLAN filters we must add new ones
4277          * with -1 (I40E_VLAN_ANY) or otherwise we're left with all our
4278          * MAC addresses deleted.
4279          */
4280         if ((!(vlan_id || qos) ||
4281             vlanprio != le16_to_cpu(vsi->info.pvid)) &&
4282             vsi->info.pvid) {
4283                 ret = i40e_add_vlan_all_mac(vsi, I40E_VLAN_ANY);
4284                 if (ret) {
4285                         dev_info(&vsi->back->pdev->dev,
4286                                  "add VF VLAN failed, ret=%d aq_err=%d\n", ret,
4287                                  vsi->back->hw.aq.asq_last_status);
4288                         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4289                         goto error_pvid;
4290                 }
4291         }
4292
4293         if (vsi->info.pvid) {
4294                 /* remove all filters on the old VLAN */
4295                 i40e_rm_vlan_all_mac(vsi, (le16_to_cpu(vsi->info.pvid) &
4296                                            VLAN_VID_MASK));
4297         }
4298
4299         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4300
4301         /* disable promisc modes in case they were enabled */
4302         ret = i40e_config_vf_promiscuous_mode(vf, vf->lan_vsi_id,
4303                                               allmulti, alluni);
4304         if (ret) {
4305                 dev_err(&pf->pdev->dev, "Unable to config VF promiscuous mode\n");
4306                 goto error_pvid;
4307         }
4308
4309         if (vlan_id || qos)
4310                 ret = i40e_vsi_add_pvid(vsi, vlanprio);
4311         else
4312                 i40e_vsi_remove_pvid(vsi);
4313         spin_lock_bh(&vsi->mac_filter_hash_lock);
4314
4315         if (vlan_id) {
4316                 dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",
4317                          vlan_id, qos, vf_id);
4318
4319                 /* add new VLAN filter for each MAC */
4320                 ret = i40e_add_vlan_all_mac(vsi, vlan_id);
4321                 if (ret) {
4322                         dev_info(&vsi->back->pdev->dev,
4323                                  "add VF VLAN failed, ret=%d aq_err=%d\n", ret,
4324                                  vsi->back->hw.aq.asq_last_status);
4325                         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4326                         goto error_pvid;
4327                 }
4328
4329                 /* remove the previously added non-VLAN MAC filters */
4330                 i40e_rm_vlan_all_mac(vsi, I40E_VLAN_ANY);
4331         }
4332
4333         spin_unlock_bh(&vsi->mac_filter_hash_lock);
4334
4335         if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
4336                 alluni = true;
4337
4338         if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
4339                 allmulti = true;
4340
4341         /* Schedule the worker thread to take care of applying changes */
4342         i40e_service_event_schedule(vsi->back);
4343
4344         if (ret) {
4345                 dev_err(&pf->pdev->dev, "Unable to update VF vsi context\n");
4346                 goto error_pvid;
4347         }
4348
4349         /* The Port VLAN needs to be saved across resets the same as the
4350          * default LAN MAC address.
4351          */
4352         vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);
4353
4354         ret = i40e_config_vf_promiscuous_mode(vf, vsi->id, allmulti, alluni);
4355         if (ret) {
4356                 dev_err(&pf->pdev->dev, "Unable to config vf promiscuous mode\n");
4357                 goto error_pvid;
4358         }
4359
4360         ret = 0;
4361
4362 error_pvid:
4363         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4364         return ret;
4365 }
4366
4367 /**
4368  * i40e_ndo_set_vf_bw
4369  * @netdev: network interface device structure
4370  * @vf_id: VF identifier
4371  * @min_tx_rate: Minimum Tx rate
4372  * @max_tx_rate: Maximum Tx rate
4373  *
4374  * configure VF Tx rate
4375  **/
4376 int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
4377                        int max_tx_rate)
4378 {
4379         struct i40e_netdev_priv *np = netdev_priv(netdev);
4380         struct i40e_pf *pf = np->vsi->back;
4381         struct i40e_vsi *vsi;
4382         struct i40e_vf *vf;
4383         int ret = 0;
4384
4385         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4386                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4387                 return -EAGAIN;
4388         }
4389
4390         /* validate the request */
4391         ret = i40e_validate_vf(pf, vf_id);
4392         if (ret)
4393                 goto error;
4394
4395         if (min_tx_rate) {
4396                 dev_err(&pf->pdev->dev, "Invalid min tx rate (%d) (greater than 0) specified for VF %d.\n",
4397                         min_tx_rate, vf_id);
4398                 ret = -EINVAL;
4399                 goto error;
4400         }
4401
4402         vf = &pf->vf[vf_id];
4403         vsi = pf->vsi[vf->lan_vsi_idx];
4404         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4405                 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n",
4406                         vf_id);
4407                 ret = -EAGAIN;
4408                 goto error;
4409         }
4410
4411         ret = i40e_set_bw_limit(vsi, vsi->seid, max_tx_rate);
4412         if (ret)
4413                 goto error;
4414
4415         vf->tx_rate = max_tx_rate;
4416 error:
4417         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4418         return ret;
4419 }
4420
4421 /**
4422  * i40e_ndo_get_vf_config
4423  * @netdev: network interface device structure
4424  * @vf_id: VF identifier
4425  * @ivi: VF configuration structure
4426  *
4427  * return VF configuration
4428  **/
4429 int i40e_ndo_get_vf_config(struct net_device *netdev,
4430                            int vf_id, struct ifla_vf_info *ivi)
4431 {
4432         struct i40e_netdev_priv *np = netdev_priv(netdev);
4433         struct i40e_vsi *vsi = np->vsi;
4434         struct i40e_pf *pf = vsi->back;
4435         struct i40e_vf *vf;
4436         int ret = 0;
4437
4438         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4439                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4440                 return -EAGAIN;
4441         }
4442
4443         /* validate the request */
4444         ret = i40e_validate_vf(pf, vf_id);
4445         if (ret)
4446                 goto error_param;
4447
4448         vf = &pf->vf[vf_id];
4449         /* first vsi is always the LAN vsi */
4450         vsi = pf->vsi[vf->lan_vsi_idx];
4451         if (!vsi) {
4452                 ret = -ENOENT;
4453                 goto error_param;
4454         }
4455
4456         ivi->vf = vf_id;
4457
4458         ether_addr_copy(ivi->mac, vf->default_lan_addr.addr);
4459
4460         ivi->max_tx_rate = vf->tx_rate;
4461         ivi->min_tx_rate = 0;
4462         ivi->vlan = le16_to_cpu(vsi->info.pvid) & I40E_VLAN_MASK;
4463         ivi->qos = (le16_to_cpu(vsi->info.pvid) & I40E_PRIORITY_MASK) >>
4464                    I40E_VLAN_PRIORITY_SHIFT;
4465         if (vf->link_forced == false)
4466                 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO;
4467         else if (vf->link_up == true)
4468                 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE;
4469         else
4470                 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE;
4471         ivi->spoofchk = vf->spoofchk;
4472         ivi->trusted = vf->trusted;
4473         ret = 0;
4474
4475 error_param:
4476         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4477         return ret;
4478 }
4479
4480 /**
4481  * i40e_ndo_set_vf_link_state
4482  * @netdev: network interface device structure
4483  * @vf_id: VF identifier
4484  * @link: required link state
4485  *
4486  * Set the link state of a specified VF, regardless of physical link state
4487  **/
4488 int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link)
4489 {
4490         struct i40e_netdev_priv *np = netdev_priv(netdev);
4491         struct i40e_pf *pf = np->vsi->back;
4492         struct i40e_link_status *ls = &pf->hw.phy.link_info;
4493         struct virtchnl_pf_event pfe;
4494         struct i40e_hw *hw = &pf->hw;
4495         struct i40e_vf *vf;
4496         int abs_vf_id;
4497         int ret = 0;
4498
4499         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4500                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4501                 return -EAGAIN;
4502         }
4503
4504         /* validate the request */
4505         if (vf_id >= pf->num_alloc_vfs) {
4506                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4507                 ret = -EINVAL;
4508                 goto error_out;
4509         }
4510
4511         vf = &pf->vf[vf_id];
4512         abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
4513
4514         pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
4515         pfe.severity = PF_EVENT_SEVERITY_INFO;
4516
4517         switch (link) {
4518         case IFLA_VF_LINK_STATE_AUTO:
4519                 vf->link_forced = false;
4520                 i40e_set_vf_link_state(vf, &pfe, ls);
4521                 break;
4522         case IFLA_VF_LINK_STATE_ENABLE:
4523                 vf->link_forced = true;
4524                 vf->link_up = true;
4525                 i40e_set_vf_link_state(vf, &pfe, ls);
4526                 break;
4527         case IFLA_VF_LINK_STATE_DISABLE:
4528                 vf->link_forced = true;
4529                 vf->link_up = false;
4530                 i40e_set_vf_link_state(vf, &pfe, ls);
4531                 break;
4532         default:
4533                 ret = -EINVAL;
4534                 goto error_out;
4535         }
4536         /* Notify the VF of its new link state */
4537         i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT,
4538                                0, (u8 *)&pfe, sizeof(pfe), NULL);
4539
4540 error_out:
4541         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4542         return ret;
4543 }
4544
4545 /**
4546  * i40e_ndo_set_vf_spoofchk
4547  * @netdev: network interface device structure
4548  * @vf_id: VF identifier
4549  * @enable: flag to enable or disable feature
4550  *
4551  * Enable or disable VF spoof checking
4552  **/
4553 int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable)
4554 {
4555         struct i40e_netdev_priv *np = netdev_priv(netdev);
4556         struct i40e_vsi *vsi = np->vsi;
4557         struct i40e_pf *pf = vsi->back;
4558         struct i40e_vsi_context ctxt;
4559         struct i40e_hw *hw = &pf->hw;
4560         struct i40e_vf *vf;
4561         int ret = 0;
4562
4563         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4564                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4565                 return -EAGAIN;
4566         }
4567
4568         /* validate the request */
4569         if (vf_id >= pf->num_alloc_vfs) {
4570                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4571                 ret = -EINVAL;
4572                 goto out;
4573         }
4574
4575         vf = &(pf->vf[vf_id]);
4576         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4577                 dev_err(&pf->pdev->dev, "VF %d still in reset. Try again.\n",
4578                         vf_id);
4579                 ret = -EAGAIN;
4580                 goto out;
4581         }
4582
4583         if (enable == vf->spoofchk)
4584                 goto out;
4585
4586         vf->spoofchk = enable;
4587         memset(&ctxt, 0, sizeof(ctxt));
4588         ctxt.seid = pf->vsi[vf->lan_vsi_idx]->seid;
4589         ctxt.pf_num = pf->hw.pf_id;
4590         ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SECURITY_VALID);
4591         if (enable)
4592                 ctxt.info.sec_flags |= (I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK |
4593                                         I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK);
4594         ret = i40e_aq_update_vsi_params(hw, &ctxt, NULL);
4595         if (ret) {
4596                 dev_err(&pf->pdev->dev, "Error %d updating VSI parameters\n",
4597                         ret);
4598                 ret = -EIO;
4599         }
4600 out:
4601         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4602         return ret;
4603 }
4604
4605 /**
4606  * i40e_ndo_set_vf_trust
4607  * @netdev: network interface device structure of the pf
4608  * @vf_id: VF identifier
4609  * @setting: trust setting
4610  *
4611  * Enable or disable VF trust setting
4612  **/
4613 int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting)
4614 {
4615         struct i40e_netdev_priv *np = netdev_priv(netdev);
4616         struct i40e_pf *pf = np->vsi->back;
4617         struct i40e_vf *vf;
4618         int ret = 0;
4619
4620         if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4621                 dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4622                 return -EAGAIN;
4623         }
4624
4625         /* validate the request */
4626         if (vf_id >= pf->num_alloc_vfs) {
4627                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4628                 ret = -EINVAL;
4629                 goto out;
4630         }
4631
4632         if (pf->flags & I40E_FLAG_MFP_ENABLED) {
4633                 dev_err(&pf->pdev->dev, "Trusted VF not supported in MFP mode.\n");
4634                 ret = -EINVAL;
4635                 goto out;
4636         }
4637
4638         vf = &pf->vf[vf_id];
4639
4640         if (setting == vf->trusted)
4641                 goto out;
4642
4643         vf->trusted = setting;
4644         i40e_vc_disable_vf(vf);
4645         dev_info(&pf->pdev->dev, "VF %u is now %strusted\n",
4646                  vf_id, setting ? "" : "un");
4647
4648         if (vf->adq_enabled) {
4649                 if (!vf->trusted) {
4650                         dev_info(&pf->pdev->dev,
4651                                  "VF %u no longer Trusted, deleting all cloud filters\n",
4652                                  vf_id);
4653                         i40e_del_all_cloud_filters(vf);
4654                 }
4655         }
4656
4657 out:
4658         clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4659         return ret;
4660 }
4661
4662 /**
4663  * i40e_get_vf_stats - populate some stats for the VF
4664  * @netdev: the netdev of the PF
4665  * @vf_id: the host OS identifier (0-127)
4666  * @vf_stats: pointer to the OS memory to be initialized
4667  */
4668 int i40e_get_vf_stats(struct net_device *netdev, int vf_id,
4669                       struct ifla_vf_stats *vf_stats)
4670 {
4671         struct i40e_netdev_priv *np = netdev_priv(netdev);
4672         struct i40e_pf *pf = np->vsi->back;
4673         struct i40e_eth_stats *stats;
4674         struct i40e_vsi *vsi;
4675         struct i40e_vf *vf;
4676
4677         /* validate the request */
4678         if (i40e_validate_vf(pf, vf_id))
4679                 return -EINVAL;
4680
4681         vf = &pf->vf[vf_id];
4682         if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4683                 dev_err(&pf->pdev->dev, "VF %d in reset. Try again.\n", vf_id);
4684                 return -EBUSY;
4685         }
4686
4687         vsi = pf->vsi[vf->lan_vsi_idx];
4688         if (!vsi)
4689                 return -EINVAL;
4690
4691         i40e_update_eth_stats(vsi);
4692         stats = &vsi->eth_stats;
4693
4694         memset(vf_stats, 0, sizeof(*vf_stats));
4695
4696         vf_stats->rx_packets = stats->rx_unicast + stats->rx_broadcast +
4697                 stats->rx_multicast;
4698         vf_stats->tx_packets = stats->tx_unicast + stats->tx_broadcast +
4699                 stats->tx_multicast;
4700         vf_stats->rx_bytes   = stats->rx_bytes;
4701         vf_stats->tx_bytes   = stats->tx_bytes;
4702         vf_stats->broadcast  = stats->rx_broadcast;
4703         vf_stats->multicast  = stats->rx_multicast;
4704         vf_stats->rx_dropped = stats->rx_discards;
4705         vf_stats->tx_dropped = stats->tx_discards;
4706
4707         return 0;
4708 }