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

   1 /*******************************************************************************
   2  *
   3  * Intel Ethernet Controller XL710 Family Linux Driver
   4  * Copyright(c) 2013 - 2014 Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * The full GNU General Public License is included in this distribution in
  19  * the file called "COPYING".
  20  *
  21  * Contact Information:
  22  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  24  *
  25  ******************************************************************************/
  26
  27 #include "i40e.h"
  28
  29 /***********************misc routines*****************************/
  30
  31 /**
  32  * i40e_vc_disable_vf
  33  * @pf: pointer to the pf info
  34  * @vf: pointer to the vf info
  35  *
  36  * Disable the VF through a SW reset
  37  **/
  38 static inline void i40e_vc_disable_vf(struct i40e_pf *pf, struct i40e_vf *vf)
  39 {
  40         struct i40e_hw *hw = &pf->hw;
  41         u32 reg;
  42
  43         reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
  44         reg |= I40E_VPGEN_VFRTRIG_VFSWR_MASK;
  45         wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
  46         i40e_flush(hw);
  47 }
  48
  49 /**
  50  * i40e_vc_isvalid_vsi_id
  51  * @vf: pointer to the vf info
  52  * @vsi_id: vf relative vsi id
  53  *
  54  * check for the valid vsi id
  55  **/
  56 static inline bool i40e_vc_isvalid_vsi_id(struct i40e_vf *vf, u8 vsi_id)
  57 {
  58         struct i40e_pf *pf = vf->pf;
  59
  60         return pf->vsi[vsi_id]->vf_id == vf->vf_id;
  61 }
  62
  63 /**
  64  * i40e_vc_isvalid_queue_id
  65  * @vf: pointer to the vf info
  66  * @vsi_id: vsi id
  67  * @qid: vsi relative queue id
  68  *
  69  * check for the valid queue id
  70  **/
  71 static inline bool i40e_vc_isvalid_queue_id(struct i40e_vf *vf, u8 vsi_id,
  72                                             u8 qid)
  73 {
  74         struct i40e_pf *pf = vf->pf;
  75
  76         return qid < pf->vsi[vsi_id]->num_queue_pairs;
  77 }
  78
  79 /**
  80  * i40e_vc_isvalid_vector_id
  81  * @vf: pointer to the vf info
  82  * @vector_id: vf relative vector id
  83  *
  84  * check for the valid vector id
  85  **/
  86 static inline bool i40e_vc_isvalid_vector_id(struct i40e_vf *vf, u8 vector_id)
  87 {
  88         struct i40e_pf *pf = vf->pf;
  89
  90         return vector_id < pf->hw.func_caps.num_msix_vectors_vf;
  91 }
  92
  93 /***********************vf resource mgmt routines*****************/
  94
  95 /**
  96  * i40e_vc_get_pf_queue_id
  97  * @vf: pointer to the vf info
  98  * @vsi_idx: index of VSI in PF struct
  99  * @vsi_queue_id: vsi relative queue id
 100  *
 101  * return pf relative queue id
 102  **/
 103 static u16 i40e_vc_get_pf_queue_id(struct i40e_vf *vf, u8 vsi_idx,
 104                                    u8 vsi_queue_id)
 105 {
 106         struct i40e_pf *pf = vf->pf;
 107         struct i40e_vsi *vsi = pf->vsi[vsi_idx];
 108         u16 pf_queue_id = I40E_QUEUE_END_OF_LIST;
 109
 110         if (le16_to_cpu(vsi->info.mapping_flags) &
 111             I40E_AQ_VSI_QUE_MAP_NONCONTIG)
 112                 pf_queue_id =
 113                         le16_to_cpu(vsi->info.queue_mapping[vsi_queue_id]);
 114         else
 115                 pf_queue_id = le16_to_cpu(vsi->info.queue_mapping[0]) +
 116                               vsi_queue_id;
 117
 118         return pf_queue_id;
 119 }
 120
 121 /**
 122  * i40e_config_irq_link_list
 123  * @vf: pointer to the vf info
 124  * @vsi_idx: index of VSI in PF struct
 125  * @vecmap: irq map info
 126  *
 127  * configure irq link list from the map
 128  **/
 129 static void i40e_config_irq_link_list(struct i40e_vf *vf, u16 vsi_idx,
 130                                       struct i40e_virtchnl_vector_map *vecmap)
 131 {
 132         unsigned long linklistmap = 0, tempmap;
 133         struct i40e_pf *pf = vf->pf;
 134         struct i40e_hw *hw = &pf->hw;
 135         u16 vsi_queue_id, pf_queue_id;
 136         enum i40e_queue_type qtype;
 137         u16 next_q, vector_id;
 138         u32 reg, reg_idx;
 139         u16 itr_idx = 0;
 140
 141         vector_id = vecmap->vector_id;
 142         /* setup the head */
 143         if (0 == vector_id)
 144                 reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
 145         else
 146                 reg_idx = I40E_VPINT_LNKLSTN(
 147                      ((pf->hw.func_caps.num_msix_vectors_vf - 1) * vf->vf_id) +
 148                      (vector_id - 1));
 149
 150         if (vecmap->rxq_map == 0 && vecmap->txq_map == 0) {
 151                 /* Special case - No queues mapped on this vector */
 152                 wr32(hw, reg_idx, I40E_VPINT_LNKLST0_FIRSTQ_INDX_MASK);
 153                 goto irq_list_done;
 154         }
 155         tempmap = vecmap->rxq_map;
 156         for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
 157                 linklistmap |= (1 <<
 158                                 (I40E_VIRTCHNL_SUPPORTED_QTYPES *
 159                                  vsi_queue_id));
 160         }
 161
 162         tempmap = vecmap->txq_map;
 163         for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
 164                 linklistmap |= (1 <<
 165                                 (I40E_VIRTCHNL_SUPPORTED_QTYPES * vsi_queue_id
 166                                  + 1));
 167         }
 168
 169         next_q = find_first_bit(&linklistmap,
 170                                 (I40E_MAX_VSI_QP *
 171                                  I40E_VIRTCHNL_SUPPORTED_QTYPES));
 172         vsi_queue_id = next_q/I40E_VIRTCHNL_SUPPORTED_QTYPES;
 173         qtype = next_q%I40E_VIRTCHNL_SUPPORTED_QTYPES;
 174         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_idx, vsi_queue_id);
 175         reg = ((qtype << I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT) | pf_queue_id);
 176
 177         wr32(hw, reg_idx, reg);
 178
 179         while (next_q < (I40E_MAX_VSI_QP * I40E_VIRTCHNL_SUPPORTED_QTYPES)) {
 180                 switch (qtype) {
 181                 case I40E_QUEUE_TYPE_RX:
 182                         reg_idx = I40E_QINT_RQCTL(pf_queue_id);
 183                         itr_idx = vecmap->rxitr_idx;
 184                         break;
 185                 case I40E_QUEUE_TYPE_TX:
 186                         reg_idx = I40E_QINT_TQCTL(pf_queue_id);
 187                         itr_idx = vecmap->txitr_idx;
 188                         break;
 189                 default:
 190                         break;
 191                 }
 192
 193                 next_q = find_next_bit(&linklistmap,
 194                                        (I40E_MAX_VSI_QP *
 195                                         I40E_VIRTCHNL_SUPPORTED_QTYPES),
 196                                        next_q + 1);
 197                 if (next_q <
 198                     (I40E_MAX_VSI_QP * I40E_VIRTCHNL_SUPPORTED_QTYPES)) {
 199                         vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES;
 200                         qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES;
 201                         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_idx,
 202                                                               vsi_queue_id);
 203                 } else {
 204                         pf_queue_id = I40E_QUEUE_END_OF_LIST;
 205                         qtype = 0;
 206                 }
 207
 208                 /* format for the RQCTL & TQCTL regs is same */
 209                 reg = (vector_id) |
 210                     (qtype << I40E_QINT_RQCTL_NEXTQ_TYPE_SHIFT) |
 211                     (pf_queue_id << I40E_QINT_RQCTL_NEXTQ_INDX_SHIFT) |
 212                     (1 << I40E_QINT_RQCTL_CAUSE_ENA_SHIFT) |
 213                     (itr_idx << I40E_QINT_RQCTL_ITR_INDX_SHIFT);
 214                 wr32(hw, reg_idx, reg);
 215         }
 216
 217 irq_list_done:
 218         i40e_flush(hw);
 219 }
 220
 221 /**
 222  * i40e_config_vsi_tx_queue
 223  * @vf: pointer to the vf info
 224  * @vsi_idx: index of VSI in PF struct
 225  * @vsi_queue_id: vsi relative queue index
 226  * @info: config. info
 227  *
 228  * configure tx queue
 229  **/
 230 static int i40e_config_vsi_tx_queue(struct i40e_vf *vf, u16 vsi_idx,
 231                                     u16 vsi_queue_id,
 232                                     struct i40e_virtchnl_txq_info *info)
 233 {
 234         struct i40e_pf *pf = vf->pf;
 235         struct i40e_hw *hw = &pf->hw;
 236         struct i40e_hmc_obj_txq tx_ctx;
 237         u16 pf_queue_id;
 238         u32 qtx_ctl;
 239         int ret = 0;
 240
 241         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_idx, vsi_queue_id);
 242
 243         /* clear the context structure first */
 244         memset(&tx_ctx, 0, sizeof(struct i40e_hmc_obj_txq));
 245
 246         /* only set the required fields */
 247         tx_ctx.base = info->dma_ring_addr / 128;
 248         tx_ctx.qlen = info->ring_len;
 249         tx_ctx.rdylist = le16_to_cpu(pf->vsi[vsi_idx]->info.qs_handle[0]);
 250         tx_ctx.rdylist_act = 0;
 251         tx_ctx.head_wb_ena = 1;
 252         tx_ctx.head_wb_addr = info->dma_ring_addr +
 253                               (info->ring_len * sizeof(struct i40e_tx_desc));
 254
 255         /* clear the context in the HMC */
 256         ret = i40e_clear_lan_tx_queue_context(hw, pf_queue_id);
 257         if (ret) {
 258                 dev_err(&pf->pdev->dev,
 259                         "Failed to clear VF LAN Tx queue context %d, error: %d\n",
 260                         pf_queue_id, ret);
 261                 ret = -ENOENT;
 262                 goto error_context;
 263         }
 264
 265         /* set the context in the HMC */
 266         ret = i40e_set_lan_tx_queue_context(hw, pf_queue_id, &tx_ctx);
 267         if (ret) {
 268                 dev_err(&pf->pdev->dev,
 269                         "Failed to set VF LAN Tx queue context %d error: %d\n",
 270                         pf_queue_id, ret);
 271                 ret = -ENOENT;
 272                 goto error_context;
 273         }
 274
 275         /* associate this queue with the PCI VF function */
 276         qtx_ctl = I40E_QTX_CTL_VF_QUEUE;
 277         qtx_ctl |= ((hw->pf_id << I40E_QTX_CTL_PF_INDX_SHIFT)
 278                     & I40E_QTX_CTL_PF_INDX_MASK);
 279         qtx_ctl |= (((vf->vf_id + hw->func_caps.vf_base_id)
 280                      << I40E_QTX_CTL_VFVM_INDX_SHIFT)
 281                     & I40E_QTX_CTL_VFVM_INDX_MASK);
 282         wr32(hw, I40E_QTX_CTL(pf_queue_id), qtx_ctl);
 283         i40e_flush(hw);
 284
 285 error_context:
 286         return ret;
 287 }
 288
 289 /**
 290  * i40e_config_vsi_rx_queue
 291  * @vf: pointer to the vf info
 292  * @vsi_idx: index of VSI in PF struct
 293  * @vsi_queue_id: vsi relative queue index
 294  * @info: config. info
 295  *
 296  * configure rx queue
 297  **/
 298 static int i40e_config_vsi_rx_queue(struct i40e_vf *vf, u16 vsi_idx,
 299                                     u16 vsi_queue_id,
 300                                     struct i40e_virtchnl_rxq_info *info)
 301 {
 302         struct i40e_pf *pf = vf->pf;
 303         struct i40e_hw *hw = &pf->hw;
 304         struct i40e_hmc_obj_rxq rx_ctx;
 305         u16 pf_queue_id;
 306         int ret = 0;
 307
 308         pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_idx, vsi_queue_id);
 309
 310         /* clear the context structure first */
 311         memset(&rx_ctx, 0, sizeof(struct i40e_hmc_obj_rxq));
 312
 313         /* only set the required fields */
 314         rx_ctx.base = info->dma_ring_addr / 128;
 315         rx_ctx.qlen = info->ring_len;
 316
 317         if (info->splithdr_enabled) {
 318                 rx_ctx.hsplit_0 = I40E_RX_SPLIT_L2      |
 319                                   I40E_RX_SPLIT_IP      |
 320                                   I40E_RX_SPLIT_TCP_UDP |
 321                                   I40E_RX_SPLIT_SCTP;
 322                 /* header length validation */
 323                 if (info->hdr_size > ((2 * 1024) - 64)) {
 324                         ret = -EINVAL;
 325                         goto error_param;
 326                 }
 327                 rx_ctx.hbuff = info->hdr_size >> I40E_RXQ_CTX_HBUFF_SHIFT;
 328
 329                 /* set splitalways mode 10b */
 330                 rx_ctx.dtype = 0x2;
 331         }
 332
 333         /* databuffer length validation */
 334         if (info->databuffer_size > ((16 * 1024) - 128)) {
 335                 ret = -EINVAL;
 336                 goto error_param;
 337         }
 338         rx_ctx.dbuff = info->databuffer_size >> I40E_RXQ_CTX_DBUFF_SHIFT;
 339
 340         /* max pkt. length validation */
 341         if (info->max_pkt_size >= (16 * 1024) || info->max_pkt_size < 64) {
 342                 ret = -EINVAL;
 343                 goto error_param;
 344         }
 345         rx_ctx.rxmax = info->max_pkt_size;
 346
 347         /* enable 32bytes desc always */
 348         rx_ctx.dsize = 1;
 349
 350         /* default values */
 351         rx_ctx.tphrdesc_ena = 1;
 352         rx_ctx.tphwdesc_ena = 1;
 353         rx_ctx.tphdata_ena = 1;
 354         rx_ctx.tphhead_ena = 1;
 355         rx_ctx.lrxqthresh = 2;
 356         rx_ctx.crcstrip = 1;
 357         rx_ctx.prefena = 1;
 358
 359         /* clear the context in the HMC */
 360         ret = i40e_clear_lan_rx_queue_context(hw, pf_queue_id);
 361         if (ret) {
 362                 dev_err(&pf->pdev->dev,
 363                         "Failed to clear VF LAN Rx queue context %d, error: %d\n",
 364                         pf_queue_id, ret);
 365                 ret = -ENOENT;
 366                 goto error_param;
 367         }
 368
 369         /* set the context in the HMC */
 370         ret = i40e_set_lan_rx_queue_context(hw, pf_queue_id, &rx_ctx);
 371         if (ret) {
 372                 dev_err(&pf->pdev->dev,
 373                         "Failed to set VF LAN Rx queue context %d error: %d\n",
 374                         pf_queue_id, ret);
 375                 ret = -ENOENT;
 376                 goto error_param;
 377         }
 378
 379 error_param:
 380         return ret;
 381 }
 382
 383 /**
 384  * i40e_alloc_vsi_res
 385  * @vf: pointer to the vf info
 386  * @type: type of VSI to allocate
 387  *
 388  * alloc vf vsi context & resources
 389  **/
 390 static int i40e_alloc_vsi_res(struct i40e_vf *vf, enum i40e_vsi_type type)
 391 {
 392         struct i40e_mac_filter *f = NULL;
 393         struct i40e_pf *pf = vf->pf;
 394         struct i40e_vsi *vsi;
 395         int ret = 0;
 396
 397         vsi = i40e_vsi_setup(pf, type, pf->vsi[pf->lan_vsi]->seid, vf->vf_id);
 398
 399         if (!vsi) {
 400                 dev_err(&pf->pdev->dev,
 401                         "add vsi failed for vf %d, aq_err %d\n",
 402                         vf->vf_id, pf->hw.aq.asq_last_status);
 403                 ret = -ENOENT;
 404                 goto error_alloc_vsi_res;
 405         }
 406         if (type == I40E_VSI_SRIOV) {
 407                 u8 brdcast[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 408                 vf->lan_vsi_index = vsi->idx;
 409                 vf->lan_vsi_id = vsi->id;
 410                 dev_info(&pf->pdev->dev,
 411                          "VF %d assigned LAN VSI index %d, VSI id %d\n",
 412                          vf->vf_id, vsi->idx, vsi->id);
 413                 /* If the port VLAN has been configured and then the
 414                  * VF driver was removed then the VSI port VLAN
 415                  * configuration was destroyed.  Check if there is
 416                  * a port VLAN and restore the VSI configuration if
 417                  * needed.
 418                  */
 419                 if (vf->port_vlan_id)
 420                         i40e_vsi_add_pvid(vsi, vf->port_vlan_id);
 421                 f = i40e_add_filter(vsi, vf->default_lan_addr.addr,
 422                                     vf->port_vlan_id, true, false);
 423                 if (!f)
 424                         dev_info(&pf->pdev->dev,
 425                                  "Could not allocate VF MAC addr\n");
 426                 f = i40e_add_filter(vsi, brdcast, vf->port_vlan_id,
 427                                     true, false);
 428                 if (!f)
 429                         dev_info(&pf->pdev->dev,
 430                                  "Could not allocate VF broadcast filter\n");
 431         }
 432
 433         /* program mac filter */
 434         ret = i40e_sync_vsi_filters(vsi);
 435         if (ret)
 436                 dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
 437
 438         /* Set VF bandwidth if specified */
 439         if (vf->tx_rate) {
 440                 ret = i40e_aq_config_vsi_bw_limit(&pf->hw, vsi->seid,
 441                                                   vf->tx_rate / 50, 0, NULL);
 442                 if (ret)
 443                         dev_err(&pf->pdev->dev, "Unable to set tx rate, VF %d, error code %d.\n",
 444                                 vf->vf_id, ret);
 445         }
 446
 447 error_alloc_vsi_res:
 448         return ret;
 449 }
 450
 451 /**
 452  * i40e_enable_vf_mappings
 453  * @vf: pointer to the vf info
 454  *
 455  * enable vf mappings
 456  **/
 457 static void i40e_enable_vf_mappings(struct i40e_vf *vf)
 458 {
 459         struct i40e_pf *pf = vf->pf;
 460         struct i40e_hw *hw = &pf->hw;
 461         u32 reg, total_queue_pairs = 0;
 462         int j;
 463
 464         /* Tell the hardware we're using noncontiguous mapping. HW requires
 465          * that VF queues be mapped using this method, even when they are
 466          * contiguous in real life
 467          */
 468         wr32(hw, I40E_VSILAN_QBASE(vf->lan_vsi_id),
 469              I40E_VSILAN_QBASE_VSIQTABLE_ENA_MASK);
 470
 471         /* enable VF vplan_qtable mappings */
 472         reg = I40E_VPLAN_MAPENA_TXRX_ENA_MASK;
 473         wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), reg);
 474
 475         /* map PF queues to VF queues */
 476         for (j = 0; j < pf->vsi[vf->lan_vsi_index]->num_queue_pairs; j++) {
 477                 u16 qid = i40e_vc_get_pf_queue_id(vf, vf->lan_vsi_index, j);
 478                 reg = (qid & I40E_VPLAN_QTABLE_QINDEX_MASK);
 479                 wr32(hw, I40E_VPLAN_QTABLE(total_queue_pairs, vf->vf_id), reg);
 480                 total_queue_pairs++;
 481         }
 482
 483         /* map PF queues to VSI */
 484         for (j = 0; j < 7; j++) {
 485                 if (j * 2 >= pf->vsi[vf->lan_vsi_index]->num_queue_pairs) {
 486                         reg = 0x07FF07FF;       /* unused */
 487                 } else {
 488                         u16 qid = i40e_vc_get_pf_queue_id(vf, vf->lan_vsi_index,
 489                                                           j * 2);
 490                         reg = qid;
 491                         qid = i40e_vc_get_pf_queue_id(vf, vf->lan_vsi_index,
 492                                                       (j * 2) + 1);
 493                         reg |= qid << 16;
 494                 }
 495                 wr32(hw, I40E_VSILAN_QTABLE(j, vf->lan_vsi_id), reg);
 496         }
 497
 498         i40e_flush(hw);
 499 }
 500
 501 /**
 502  * i40e_disable_vf_mappings
 503  * @vf: pointer to the vf info
 504  *
 505  * disable vf mappings
 506  **/
 507 static void i40e_disable_vf_mappings(struct i40e_vf *vf)
 508 {
 509         struct i40e_pf *pf = vf->pf;
 510         struct i40e_hw *hw = &pf->hw;
 511         int i;
 512
 513         /* disable qp mappings */
 514         wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), 0);
 515         for (i = 0; i < I40E_MAX_VSI_QP; i++)
 516                 wr32(hw, I40E_VPLAN_QTABLE(i, vf->vf_id),
 517                      I40E_QUEUE_END_OF_LIST);
 518         i40e_flush(hw);
 519 }
 520
 521 /**
 522  * i40e_free_vf_res
 523  * @vf: pointer to the vf info
 524  *
 525  * free vf resources
 526  **/
 527 static void i40e_free_vf_res(struct i40e_vf *vf)
 528 {
 529         struct i40e_pf *pf = vf->pf;
 530         struct i40e_hw *hw = &pf->hw;
 531         u32 reg_idx, reg;
 532         int i, msix_vf;
 533
 534         /* free vsi & disconnect it from the parent uplink */
 535         if (vf->lan_vsi_index) {
 536                 i40e_vsi_release(pf->vsi[vf->lan_vsi_index]);
 537                 vf->lan_vsi_index = 0;
 538                 vf->lan_vsi_id = 0;
 539         }
 540         msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
 541
 542         /* disable interrupts so the VF starts in a known state */
 543         for (i = 0; i < msix_vf; i++) {
 544                 /* format is same for both registers */
 545                 if (0 == i)
 546                         reg_idx = I40E_VFINT_DYN_CTL0(vf->vf_id);
 547                 else
 548                         reg_idx = I40E_VFINT_DYN_CTLN(((msix_vf - 1) *
 549                                                       (vf->vf_id))
 550                                                      + (i - 1));
 551                 wr32(hw, reg_idx, I40E_VFINT_DYN_CTLN_CLEARPBA_MASK);
 552                 i40e_flush(hw);
 553         }
 554
 555         /* clear the irq settings */
 556         for (i = 0; i < msix_vf; i++) {
 557                 /* format is same for both registers */
 558                 if (0 == i)
 559                         reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
 560                 else
 561                         reg_idx = I40E_VPINT_LNKLSTN(((msix_vf - 1) *
 562                                                       (vf->vf_id))
 563                                                      + (i - 1));
 564                 reg = (I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK |
 565                        I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK);
 566                 wr32(hw, reg_idx, reg);
 567                 i40e_flush(hw);
 568         }
 569         /* reset some of the state varibles keeping
 570          * track of the resources
 571          */
 572         vf->num_queue_pairs = 0;
 573         vf->vf_states = 0;
 574 }
 575
 576 /**
 577  * i40e_alloc_vf_res
 578  * @vf: pointer to the vf info
 579  *
 580  * allocate vf resources
 581  **/
 582 static int i40e_alloc_vf_res(struct i40e_vf *vf)
 583 {
 584         struct i40e_pf *pf = vf->pf;
 585         int total_queue_pairs = 0;
 586         int ret;
 587
 588         /* allocate hw vsi context & associated resources */
 589         ret = i40e_alloc_vsi_res(vf, I40E_VSI_SRIOV);
 590         if (ret)
 591                 goto error_alloc;
 592         total_queue_pairs += pf->vsi[vf->lan_vsi_index]->num_queue_pairs;
 593         set_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 594
 595         /* store the total qps number for the runtime
 596          * vf req validation
 597          */
 598         vf->num_queue_pairs = total_queue_pairs;
 599
 600         /* vf is now completely initialized */
 601         set_bit(I40E_VF_STAT_INIT, &vf->vf_states);
 602
 603 error_alloc:
 604         if (ret)
 605                 i40e_free_vf_res(vf);
 606
 607         return ret;
 608 }
 609
 610 #define VF_DEVICE_STATUS 0xAA
 611 #define VF_TRANS_PENDING_MASK 0x20
 612 /**
 613  * i40e_quiesce_vf_pci
 614  * @vf: pointer to the vf structure
 615  *
 616  * Wait for VF PCI transactions to be cleared after reset. Returns -EIO
 617  * if the transactions never clear.
 618  **/
 619 static int i40e_quiesce_vf_pci(struct i40e_vf *vf)
 620 {
 621         struct i40e_pf *pf = vf->pf;
 622         struct i40e_hw *hw = &pf->hw;
 623         int vf_abs_id, i;
 624         u32 reg;
 625
 626         vf_abs_id = vf->vf_id + hw->func_caps.vf_base_id;
 627
 628         wr32(hw, I40E_PF_PCI_CIAA,
 629              VF_DEVICE_STATUS | (vf_abs_id << I40E_PF_PCI_CIAA_VF_NUM_SHIFT));
 630         for (i = 0; i < 100; i++) {
 631                 reg = rd32(hw, I40E_PF_PCI_CIAD);
 632                 if ((reg & VF_TRANS_PENDING_MASK) == 0)
 633                         return 0;
 634                 udelay(1);
 635         }
 636         return -EIO;
 637 }
 638
 639 /**
 640  * i40e_reset_vf
 641  * @vf: pointer to the vf structure
 642  * @flr: VFLR was issued or not
 643  *
 644  * reset the vf
 645  **/
 646 void i40e_reset_vf(struct i40e_vf *vf, bool flr)
 647 {
 648         struct i40e_pf *pf = vf->pf;
 649         struct i40e_hw *hw = &pf->hw;
 650         bool rsd = false;
 651         int i;
 652         u32 reg;
 653
 654         /* warn the VF */
 655         clear_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
 656
 657         /* In the case of a VFLR, the HW has already reset the VF and we
 658          * just need to clean up, so don't hit the VFRTRIG register.
 659          */
 660         if (!flr) {
 661                 /* reset vf using VPGEN_VFRTRIG reg */
 662                 reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
 663                 reg |= I40E_VPGEN_VFRTRIG_VFSWR_MASK;
 664                 wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
 665                 i40e_flush(hw);
 666         }
 667
 668         if (i40e_quiesce_vf_pci(vf))
 669                 dev_err(&pf->pdev->dev, "VF %d PCI transactions stuck\n",
 670                         vf->vf_id);
 671
 672         /* poll VPGEN_VFRSTAT reg to make sure
 673          * that reset is complete
 674          */
 675         for (i = 0; i < 100; i++) {
 676                 /* vf reset requires driver to first reset the
 677                  * vf & than poll the status register to make sure
 678                  * that the requested op was completed
 679                  * successfully
 680                  */
 681                 udelay(10);
 682                 reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
 683                 if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) {
 684                         rsd = true;
 685                         break;
 686                 }
 687         }
 688
 689         if (!rsd)
 690                 dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
 691                         vf->vf_id);
 692         wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), I40E_VFR_COMPLETED);
 693         /* clear the reset bit in the VPGEN_VFRTRIG reg */
 694         reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
 695         reg &= ~I40E_VPGEN_VFRTRIG_VFSWR_MASK;
 696         wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
 697
 698         /* On initial reset, we won't have any queues */
 699         if (vf->lan_vsi_index == 0)
 700                 goto complete_reset;
 701
 702         i40e_vsi_control_rings(pf->vsi[vf->lan_vsi_index], false);
 703 complete_reset:
 704         /* reallocate vf resources to reset the VSI state */
 705         i40e_free_vf_res(vf);
 706         i40e_alloc_vf_res(vf);
 707         i40e_enable_vf_mappings(vf);
 708         set_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
 709
 710         /* tell the VF the reset is done */
 711         wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), I40E_VFR_VFACTIVE);
 712         i40e_flush(hw);
 713 }
 714
 715 /**
 716  * i40e_vfs_are_assigned
 717  * @pf: pointer to the pf structure
 718  *
 719  * Determine if any VFs are assigned to VMs
 720  **/
 721 static bool i40e_vfs_are_assigned(struct i40e_pf *pf)
 722 {
 723         struct pci_dev *pdev = pf->pdev;
 724         struct pci_dev *vfdev;
 725
 726         /* loop through all the VFs to see if we own any that are assigned */
 727         vfdev = pci_get_device(PCI_VENDOR_ID_INTEL, I40E_DEV_ID_VF , NULL);
 728         while (vfdev) {
 729                 /* if we don't own it we don't care */
 730                 if (vfdev->is_virtfn && pci_physfn(vfdev) == pdev) {
 731                         /* if it is assigned we cannot release it */
 732                         if (vfdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED)
 733                                 return true;
 734                 }
 735
 736                 vfdev = pci_get_device(PCI_VENDOR_ID_INTEL,
 737                                        I40E_DEV_ID_VF,
 738                                        vfdev);
 739         }
 740
 741         return false;
 742 }
 743 #ifdef CONFIG_PCI_IOV
 744
 745 /**
 746  * i40e_enable_pf_switch_lb
 747  * @pf: pointer to the pf structure
 748  *
 749  * enable switch loop back or die - no point in a return value
 750  **/
 751 static void i40e_enable_pf_switch_lb(struct i40e_pf *pf)
 752 {
 753         struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
 754         struct i40e_vsi_context ctxt;
 755         int aq_ret;
 756
 757         ctxt.seid = pf->main_vsi_seid;
 758         ctxt.pf_num = pf->hw.pf_id;
 759         ctxt.vf_num = 0;
 760         aq_ret = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL);
 761         if (aq_ret) {
 762                 dev_info(&pf->pdev->dev,
 763                          "%s couldn't get pf vsi config, err %d, aq_err %d\n",
 764                          __func__, aq_ret, pf->hw.aq.asq_last_status);
 765                 return;
 766         }
 767         ctxt.flags = I40E_AQ_VSI_TYPE_PF;
 768         ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
 769         ctxt.info.switch_id |= cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
 770
 771         aq_ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
 772         if (aq_ret) {
 773                 dev_info(&pf->pdev->dev,
 774                          "%s: update vsi switch failed, aq_err=%d\n",
 775                          __func__, vsi->back->hw.aq.asq_last_status);
 776         }
 777 }
 778 #endif
 779
 780 /**
 781  * i40e_disable_pf_switch_lb
 782  * @pf: pointer to the pf structure
 783  *
 784  * disable switch loop back or die - no point in a return value
 785  **/
 786 static void i40e_disable_pf_switch_lb(struct i40e_pf *pf)
 787 {
 788         struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
 789         struct i40e_vsi_context ctxt;
 790         int aq_ret;
 791
 792         ctxt.seid = pf->main_vsi_seid;
 793         ctxt.pf_num = pf->hw.pf_id;
 794         ctxt.vf_num = 0;
 795         aq_ret = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL);
 796         if (aq_ret) {
 797                 dev_info(&pf->pdev->dev,
 798                          "%s couldn't get pf vsi config, err %d, aq_err %d\n",
 799                          __func__, aq_ret, pf->hw.aq.asq_last_status);
 800                 return;
 801         }
 802         ctxt.flags = I40E_AQ_VSI_TYPE_PF;
 803         ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
 804         ctxt.info.switch_id &= ~cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
 805
 806         aq_ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
 807         if (aq_ret) {
 808                 dev_info(&pf->pdev->dev,
 809                          "%s: update vsi switch failed, aq_err=%d\n",
 810                          __func__, vsi->back->hw.aq.asq_last_status);
 811         }
 812 }
 813
 814 /**
 815  * i40e_free_vfs
 816  * @pf: pointer to the pf structure
 817  *
 818  * free vf resources
 819  **/
 820 void i40e_free_vfs(struct i40e_pf *pf)
 821 {
 822         struct i40e_hw *hw = &pf->hw;
 823         u32 reg_idx, bit_idx;
 824         int i, tmp, vf_id;
 825
 826         if (!pf->vf)
 827                 return;
 828
 829         /* Disable interrupt 0 so we don't try to handle the VFLR. */
 830         i40e_irq_dynamic_disable_icr0(pf);
 831
 832         mdelay(10); /* let any messages in transit get finished up */
 833         /* free up vf resources */
 834         tmp = pf->num_alloc_vfs;
 835         pf->num_alloc_vfs = 0;
 836         for (i = 0; i < tmp; i++) {
 837                 if (test_bit(I40E_VF_STAT_INIT, &pf->vf[i].vf_states))
 838                         i40e_free_vf_res(&pf->vf[i]);
 839                 /* disable qp mappings */
 840                 i40e_disable_vf_mappings(&pf->vf[i]);
 841         }
 842
 843         kfree(pf->vf);
 844         pf->vf = NULL;
 845
 846         /* This check is for when the driver is unloaded while VFs are
 847          * assigned. Setting the number of VFs to 0 through sysfs is caught
 848          * before this function ever gets called.
 849          */
 850         if (!i40e_vfs_are_assigned(pf)) {
 851                 pci_disable_sriov(pf->pdev);
 852                 /* Acknowledge VFLR for all VFS. Without this, VFs will fail to
 853                  * work correctly when SR-IOV gets re-enabled.
 854                  */
 855                 for (vf_id = 0; vf_id < tmp; vf_id++) {
 856                         reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
 857                         bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
 858                         wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), (1 << bit_idx));
 859                 }
 860                 i40e_disable_pf_switch_lb(pf);
 861         } else {
 862                 dev_warn(&pf->pdev->dev,
 863                          "unable to disable SR-IOV because VFs are assigned.\n");
 864         }
 865
 866         /* Re-enable interrupt 0. */
 867         i40e_irq_dynamic_enable_icr0(pf);
 868 }
 869
 870 #ifdef CONFIG_PCI_IOV
 871 /**
 872  * i40e_alloc_vfs
 873  * @pf: pointer to the pf structure
 874  * @num_alloc_vfs: number of vfs to allocate
 875  *
 876  * allocate vf resources
 877  **/
 878 int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs)
 879 {
 880         struct i40e_vf *vfs;
 881         int i, ret = 0;
 882
 883         /* Disable interrupt 0 so we don't try to handle the VFLR. */
 884         i40e_irq_dynamic_disable_icr0(pf);
 885
 886         /* Check to see if we're just allocating resources for extant VFs */
 887         if (pci_num_vf(pf->pdev) != num_alloc_vfs) {
 888                 ret = pci_enable_sriov(pf->pdev, num_alloc_vfs);
 889                 if (ret) {
 890                         dev_err(&pf->pdev->dev,
 891                                 "Failed to enable SR-IOV, error %d.\n", ret);
 892                         pf->num_alloc_vfs = 0;
 893                         goto err_iov;
 894                 }
 895         }
 896         /* allocate memory */
 897         vfs = kcalloc(num_alloc_vfs, sizeof(struct i40e_vf), GFP_KERNEL);
 898         if (!vfs) {
 899                 ret = -ENOMEM;
 900                 goto err_alloc;
 901         }
 902         pf->vf = vfs;
 903
 904         /* apply default profile */
 905         for (i = 0; i < num_alloc_vfs; i++) {
 906                 vfs[i].pf = pf;
 907                 vfs[i].parent_type = I40E_SWITCH_ELEMENT_TYPE_VEB;
 908                 vfs[i].vf_id = i;
 909
 910                 /* assign default capabilities */
 911                 set_bit(I40E_VIRTCHNL_VF_CAP_L2, &vfs[i].vf_caps);
 912                 vfs[i].spoofchk = true;
 913                 /* vf resources get allocated during reset */
 914                 i40e_reset_vf(&vfs[i], false);
 915
 916                 /* enable vf vplan_qtable mappings */
 917                 i40e_enable_vf_mappings(&vfs[i]);
 918         }
 919         pf->num_alloc_vfs = num_alloc_vfs;
 920
 921         i40e_enable_pf_switch_lb(pf);
 922 err_alloc:
 923         if (ret)
 924                 i40e_free_vfs(pf);
 925 err_iov:
 926         /* Re-enable interrupt 0. */
 927         i40e_irq_dynamic_enable_icr0(pf);
 928         return ret;
 929 }
 930
 931 #endif
 932 /**
 933  * i40e_pci_sriov_enable
 934  * @pdev: pointer to a pci_dev structure
 935  * @num_vfs: number of vfs to allocate
 936  *
 937  * Enable or change the number of VFs
 938  **/
 939 static int i40e_pci_sriov_enable(struct pci_dev *pdev, int num_vfs)
 940 {
 941 #ifdef CONFIG_PCI_IOV
 942         struct i40e_pf *pf = pci_get_drvdata(pdev);
 943         int pre_existing_vfs = pci_num_vf(pdev);
 944         int err = 0;
 945
 946         dev_info(&pdev->dev, "Allocating %d VFs.\n", num_vfs);
 947         if (pre_existing_vfs && pre_existing_vfs != num_vfs)
 948                 i40e_free_vfs(pf);
 949         else if (pre_existing_vfs && pre_existing_vfs == num_vfs)
 950                 goto out;
 951
 952         if (num_vfs > pf->num_req_vfs) {
 953                 err = -EPERM;
 954                 goto err_out;
 955         }
 956
 957         err = i40e_alloc_vfs(pf, num_vfs);
 958         if (err) {
 959                 dev_warn(&pdev->dev, "Failed to enable SR-IOV: %d\n", err);
 960                 goto err_out;
 961         }
 962
 963 out:
 964         return num_vfs;
 965
 966 err_out:
 967         return err;
 968 #endif
 969         return 0;
 970 }
 971
 972 /**
 973  * i40e_pci_sriov_configure
 974  * @pdev: pointer to a pci_dev structure
 975  * @num_vfs: number of vfs to allocate
 976  *
 977  * Enable or change the number of VFs. Called when the user updates the number
 978  * of VFs in sysfs.
 979  **/
 980 int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
 981 {
 982         struct i40e_pf *pf = pci_get_drvdata(pdev);
 983
 984         if (num_vfs)
 985                 return i40e_pci_sriov_enable(pdev, num_vfs);
 986
 987         if (!i40e_vfs_are_assigned(pf)) {
 988                 i40e_free_vfs(pf);
 989         } else {
 990                 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n");
 991                 return -EINVAL;
 992         }
 993         return 0;
 994 }
 995
 996 /***********************virtual channel routines******************/
 997
 998 /**
 999  * i40e_vc_send_msg_to_vf
1000  * @vf: pointer to the vf info
1001  * @v_opcode: virtual channel opcode
1002  * @v_retval: virtual channel return value
1003  * @msg: pointer to the msg buffer
1004  * @msglen: msg length
1005  *
1006  * send msg to vf
1007  **/
1008 static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode,
1009                                   u32 v_retval, u8 *msg, u16 msglen)
1010 {
1011         struct i40e_pf *pf = vf->pf;
1012         struct i40e_hw *hw = &pf->hw;
1013         int true_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
1014         i40e_status aq_ret;
1015
1016         /* single place to detect unsuccessful return values */
1017         if (v_retval) {
1018                 vf->num_invalid_msgs++;
1019                 dev_err(&pf->pdev->dev, "Failed opcode %d Error: %d\n",
1020                         v_opcode, v_retval);
1021                 if (vf->num_invalid_msgs >
1022                     I40E_DEFAULT_NUM_INVALID_MSGS_ALLOWED) {
1023                         dev_err(&pf->pdev->dev,
1024                                 "Number of invalid messages exceeded for VF %d\n",
1025                                 vf->vf_id);
1026                         dev_err(&pf->pdev->dev, "Use PF Control I/F to enable the VF\n");
1027                         set_bit(I40E_VF_STAT_DISABLED, &vf->vf_states);
1028                 }
1029         } else {
1030                 vf->num_valid_msgs++;
1031         }
1032
1033         aq_ret = i40e_aq_send_msg_to_vf(hw, true_vf_id, v_opcode, v_retval,
1034                                         msg, msglen, NULL);
1035         if (aq_ret) {
1036                 dev_err(&pf->pdev->dev,
1037                         "Unable to send the message to VF %d aq_err %d\n",
1038                         vf->vf_id, pf->hw.aq.asq_last_status);
1039                 return -EIO;
1040         }
1041
1042         return 0;
1043 }
1044
1045 /**
1046  * i40e_vc_send_resp_to_vf
1047  * @vf: pointer to the vf info
1048  * @opcode: operation code
1049  * @retval: return value
1050  *
1051  * send resp msg to vf
1052  **/
1053 static int i40e_vc_send_resp_to_vf(struct i40e_vf *vf,
1054                                    enum i40e_virtchnl_ops opcode,
1055                                    i40e_status retval)
1056 {
1057         return i40e_vc_send_msg_to_vf(vf, opcode, retval, NULL, 0);
1058 }
1059
1060 /**
1061  * i40e_vc_get_version_msg
1062  * @vf: pointer to the vf info
1063  *
1064  * called from the vf to request the API version used by the PF
1065  **/
1066 static int i40e_vc_get_version_msg(struct i40e_vf *vf)
1067 {
1068         struct i40e_virtchnl_version_info info = {
1069                 I40E_VIRTCHNL_VERSION_MAJOR, I40E_VIRTCHNL_VERSION_MINOR
1070         };
1071
1072         return i40e_vc_send_msg_to_vf(vf, I40E_VIRTCHNL_OP_VERSION,
1073                                       I40E_SUCCESS, (u8 *)&info,
1074                                       sizeof(struct
1075                                              i40e_virtchnl_version_info));
1076 }
1077
1078 /**
1079  * i40e_vc_get_vf_resources_msg
1080  * @vf: pointer to the vf info
1081  * @msg: pointer to the msg buffer
1082  * @msglen: msg length
1083  *
1084  * called from the vf to request its resources
1085  **/
1086 static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf)
1087 {
1088         struct i40e_virtchnl_vf_resource *vfres = NULL;
1089         struct i40e_pf *pf = vf->pf;
1090         i40e_status aq_ret = 0;
1091         struct i40e_vsi *vsi;
1092         int i = 0, len = 0;
1093         int num_vsis = 1;
1094         int ret;
1095
1096         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
1097                 aq_ret = I40E_ERR_PARAM;
1098                 goto err;
1099         }
1100
1101         len = (sizeof(struct i40e_virtchnl_vf_resource) +
1102                sizeof(struct i40e_virtchnl_vsi_resource) * num_vsis);
1103
1104         vfres = kzalloc(len, GFP_KERNEL);
1105         if (!vfres) {
1106                 aq_ret = I40E_ERR_NO_MEMORY;
1107                 len = 0;
1108                 goto err;
1109         }
1110
1111         vfres->vf_offload_flags = I40E_VIRTCHNL_VF_OFFLOAD_L2;
1112         vsi = pf->vsi[vf->lan_vsi_index];
1113         if (!vsi->info.pvid)
1114                 vfres->vf_offload_flags |= I40E_VIRTCHNL_VF_OFFLOAD_VLAN;
1115
1116         vfres->num_vsis = num_vsis;
1117         vfres->num_queue_pairs = vf->num_queue_pairs;
1118         vfres->max_vectors = pf->hw.func_caps.num_msix_vectors_vf;
1119         if (vf->lan_vsi_index) {
1120                 vfres->vsi_res[i].vsi_id = vf->lan_vsi_index;
1121                 vfres->vsi_res[i].vsi_type = I40E_VSI_SRIOV;
1122                 vfres->vsi_res[i].num_queue_pairs =
1123                     pf->vsi[vf->lan_vsi_index]->num_queue_pairs;
1124                 memcpy(vfres->vsi_res[i].default_mac_addr,
1125                        vf->default_lan_addr.addr, ETH_ALEN);
1126                 i++;
1127         }
1128         set_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
1129
1130 err:
1131         /* send the response back to the vf */
1132         ret = i40e_vc_send_msg_to_vf(vf, I40E_VIRTCHNL_OP_GET_VF_RESOURCES,
1133                                      aq_ret, (u8 *)vfres, len);
1134
1135         kfree(vfres);
1136         return ret;
1137 }
1138
1139 /**
1140  * i40e_vc_reset_vf_msg
1141  * @vf: pointer to the vf info
1142  * @msg: pointer to the msg buffer
1143  * @msglen: msg length
1144  *
1145  * called from the vf to reset itself,
1146  * unlike other virtchnl messages, pf driver
1147  * doesn't send the response back to the vf
1148  **/
1149 static void i40e_vc_reset_vf_msg(struct i40e_vf *vf)
1150 {
1151         if (test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states))
1152                 i40e_reset_vf(vf, false);
1153 }
1154
1155 /**
1156  * i40e_vc_config_promiscuous_mode_msg
1157  * @vf: pointer to the vf info
1158  * @msg: pointer to the msg buffer
1159  * @msglen: msg length
1160  *
1161  * called from the vf to configure the promiscuous mode of
1162  * vf vsis
1163  **/
1164 static int i40e_vc_config_promiscuous_mode_msg(struct i40e_vf *vf,
1165                                                u8 *msg, u16 msglen)
1166 {
1167         struct i40e_virtchnl_promisc_info *info =
1168             (struct i40e_virtchnl_promisc_info *)msg;
1169         struct i40e_pf *pf = vf->pf;
1170         struct i40e_hw *hw = &pf->hw;
1171         bool allmulti = false;
1172         bool promisc = false;
1173         i40e_status aq_ret;
1174
1175         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
1176             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) ||
1177             !i40e_vc_isvalid_vsi_id(vf, info->vsi_id) ||
1178             (pf->vsi[info->vsi_id]->type != I40E_VSI_FCOE)) {
1179                 aq_ret = I40E_ERR_PARAM;
1180                 goto error_param;
1181         }
1182
1183         if (info->flags & I40E_FLAG_VF_UNICAST_PROMISC)
1184                 promisc = true;
1185         aq_ret = i40e_aq_set_vsi_unicast_promiscuous(hw, info->vsi_id,
1186                                                      promisc, NULL);
1187         if (aq_ret)
1188                 goto error_param;
1189
1190         if (info->flags & I40E_FLAG_VF_MULTICAST_PROMISC)
1191                 allmulti = true;
1192         aq_ret = i40e_aq_set_vsi_multicast_promiscuous(hw, info->vsi_id,
1193                                                        allmulti, NULL);
1194
1195 error_param:
1196         /* send the response to the vf */
1197         return i40e_vc_send_resp_to_vf(vf,
1198                                        I40E_VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
1199                                        aq_ret);
1200 }
1201
1202 /**
1203  * i40e_vc_config_queues_msg
1204  * @vf: pointer to the vf info
1205  * @msg: pointer to the msg buffer
1206  * @msglen: msg length
1207  *
1208  * called from the vf to configure the rx/tx
1209  * queues
1210  **/
1211 static int i40e_vc_config_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1212 {
1213         struct i40e_virtchnl_vsi_queue_config_info *qci =
1214             (struct i40e_virtchnl_vsi_queue_config_info *)msg;
1215         struct i40e_virtchnl_queue_pair_info *qpi;
1216         u16 vsi_id, vsi_queue_id;
1217         i40e_status aq_ret = 0;
1218         int i;
1219
1220         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states)) {
1221                 aq_ret = I40E_ERR_PARAM;
1222                 goto error_param;
1223         }
1224
1225         vsi_id = qci->vsi_id;
1226         if (!i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1227                 aq_ret = I40E_ERR_PARAM;
1228                 goto error_param;
1229         }
1230         for (i = 0; i < qci->num_queue_pairs; i++) {
1231                 qpi = &qci->qpair[i];
1232                 vsi_queue_id = qpi->txq.queue_id;
1233                 if ((qpi->txq.vsi_id != vsi_id) ||
1234                     (qpi->rxq.vsi_id != vsi_id) ||
1235                     (qpi->rxq.queue_id != vsi_queue_id) ||
1236                     !i40e_vc_isvalid_queue_id(vf, vsi_id, vsi_queue_id)) {
1237                         aq_ret = I40E_ERR_PARAM;
1238                         goto error_param;
1239                 }
1240
1241                 if (i40e_config_vsi_rx_queue(vf, vsi_id, vsi_queue_id,
1242                                              &qpi->rxq) ||
1243                     i40e_config_vsi_tx_queue(vf, vsi_id, vsi_queue_id,
1244                                              &qpi->txq)) {
1245                         aq_ret = I40E_ERR_PARAM;
1246                         goto error_param;
1247                 }
1248         }
1249
1250 error_param:
1251         /* send the response to the vf */
1252         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_CONFIG_VSI_QUEUES,
1253                                        aq_ret);
1254 }
1255
1256 /**
1257  * i40e_vc_config_irq_map_msg
1258  * @vf: pointer to the vf info
1259  * @msg: pointer to the msg buffer
1260  * @msglen: msg length
1261  *
1262  * called from the vf to configure the irq to
1263  * queue map
1264  **/
1265 static int i40e_vc_config_irq_map_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1266 {
1267         struct i40e_virtchnl_irq_map_info *irqmap_info =
1268             (struct i40e_virtchnl_irq_map_info *)msg;
1269         struct i40e_virtchnl_vector_map *map;
1270         u16 vsi_id, vsi_queue_id, vector_id;
1271         i40e_status aq_ret = 0;
1272         unsigned long tempmap;
1273         int i;
1274
1275         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states)) {
1276                 aq_ret = I40E_ERR_PARAM;
1277                 goto error_param;
1278         }
1279
1280         for (i = 0; i < irqmap_info->num_vectors; i++) {
1281                 map = &irqmap_info->vecmap[i];
1282
1283                 vector_id = map->vector_id;
1284                 vsi_id = map->vsi_id;
1285                 /* validate msg params */
1286                 if (!i40e_vc_isvalid_vector_id(vf, vector_id) ||
1287                     !i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1288                         aq_ret = I40E_ERR_PARAM;
1289                         goto error_param;
1290                 }
1291
1292                 /* lookout for the invalid queue index */
1293                 tempmap = map->rxq_map;
1294                 for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
1295                         if (!i40e_vc_isvalid_queue_id(vf, vsi_id,
1296                                                       vsi_queue_id)) {
1297                                 aq_ret = I40E_ERR_PARAM;
1298                                 goto error_param;
1299                         }
1300                 }
1301
1302                 tempmap = map->txq_map;
1303                 for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
1304                         if (!i40e_vc_isvalid_queue_id(vf, vsi_id,
1305                                                       vsi_queue_id)) {
1306                                 aq_ret = I40E_ERR_PARAM;
1307                                 goto error_param;
1308                         }
1309                 }
1310
1311                 i40e_config_irq_link_list(vf, vsi_id, map);
1312         }
1313 error_param:
1314         /* send the response to the vf */
1315         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_CONFIG_IRQ_MAP,
1316                                        aq_ret);
1317 }
1318
1319 /**
1320  * i40e_vc_enable_queues_msg
1321  * @vf: pointer to the vf info
1322  * @msg: pointer to the msg buffer
1323  * @msglen: msg length
1324  *
1325  * called from the vf to enable all or specific queue(s)
1326  **/
1327 static int i40e_vc_enable_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1328 {
1329         struct i40e_virtchnl_queue_select *vqs =
1330             (struct i40e_virtchnl_queue_select *)msg;
1331         struct i40e_pf *pf = vf->pf;
1332         u16 vsi_id = vqs->vsi_id;
1333         i40e_status aq_ret = 0;
1334
1335         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states)) {
1336                 aq_ret = I40E_ERR_PARAM;
1337                 goto error_param;
1338         }
1339
1340         if (!i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1341                 aq_ret = I40E_ERR_PARAM;
1342                 goto error_param;
1343         }
1344
1345         if ((0 == vqs->rx_queues) && (0 == vqs->tx_queues)) {
1346                 aq_ret = I40E_ERR_PARAM;
1347                 goto error_param;
1348         }
1349         if (i40e_vsi_control_rings(pf->vsi[vsi_id], true))
1350                 aq_ret = I40E_ERR_TIMEOUT;
1351 error_param:
1352         /* send the response to the vf */
1353         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_ENABLE_QUEUES,
1354                                        aq_ret);
1355 }
1356
1357 /**
1358  * i40e_vc_disable_queues_msg
1359  * @vf: pointer to the vf info
1360  * @msg: pointer to the msg buffer
1361  * @msglen: msg length
1362  *
1363  * called from the vf to disable all or specific
1364  * queue(s)
1365  **/
1366 static int i40e_vc_disable_queues_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1367 {
1368         struct i40e_virtchnl_queue_select *vqs =
1369             (struct i40e_virtchnl_queue_select *)msg;
1370         struct i40e_pf *pf = vf->pf;
1371         u16 vsi_id = vqs->vsi_id;
1372         i40e_status aq_ret = 0;
1373
1374         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states)) {
1375                 aq_ret = I40E_ERR_PARAM;
1376                 goto error_param;
1377         }
1378
1379         if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
1380                 aq_ret = I40E_ERR_PARAM;
1381                 goto error_param;
1382         }
1383
1384         if ((0 == vqs->rx_queues) && (0 == vqs->tx_queues)) {
1385                 aq_ret = I40E_ERR_PARAM;
1386                 goto error_param;
1387         }
1388         if (i40e_vsi_control_rings(pf->vsi[vsi_id], false))
1389                 aq_ret = I40E_ERR_TIMEOUT;
1390
1391 error_param:
1392         /* send the response to the vf */
1393         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_DISABLE_QUEUES,
1394                                        aq_ret);
1395 }
1396
1397 /**
1398  * i40e_vc_get_stats_msg
1399  * @vf: pointer to the vf info
1400  * @msg: pointer to the msg buffer
1401  * @msglen: msg length
1402  *
1403  * called from the vf to get vsi stats
1404  **/
1405 static int i40e_vc_get_stats_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1406 {
1407         struct i40e_virtchnl_queue_select *vqs =
1408             (struct i40e_virtchnl_queue_select *)msg;
1409         struct i40e_pf *pf = vf->pf;
1410         struct i40e_eth_stats stats;
1411         i40e_status aq_ret = 0;
1412         struct i40e_vsi *vsi;
1413
1414         memset(&stats, 0, sizeof(struct i40e_eth_stats));
1415
1416         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states)) {
1417                 aq_ret = I40E_ERR_PARAM;
1418                 goto error_param;
1419         }
1420
1421         if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
1422                 aq_ret = I40E_ERR_PARAM;
1423                 goto error_param;
1424         }
1425
1426         vsi = pf->vsi[vqs->vsi_id];
1427         if (!vsi) {
1428                 aq_ret = I40E_ERR_PARAM;
1429                 goto error_param;
1430         }
1431         i40e_update_eth_stats(vsi);
1432         stats = vsi->eth_stats;
1433
1434 error_param:
1435         /* send the response back to the vf */
1436         return i40e_vc_send_msg_to_vf(vf, I40E_VIRTCHNL_OP_GET_STATS, aq_ret,
1437                                       (u8 *)&stats, sizeof(stats));
1438 }
1439
1440 /**
1441  * i40e_check_vf_permission
1442  * @vf: pointer to the vf info
1443  * @macaddr: pointer to the MAC Address being checked
1444  *
1445  * Check if the VF has permission to add or delete unicast MAC address
1446  * filters and return error code -EPERM if not.  Then check if the
1447  * address filter requested is broadcast or zero and if so return
1448  * an invalid MAC address error code.
1449  **/
1450 static inline int i40e_check_vf_permission(struct i40e_vf *vf, u8 *macaddr)
1451 {
1452         struct i40e_pf *pf = vf->pf;
1453         int ret = 0;
1454
1455         if (is_broadcast_ether_addr(macaddr) ||
1456                    is_zero_ether_addr(macaddr)) {
1457                 dev_err(&pf->pdev->dev, "invalid VF MAC addr %pM\n", macaddr);
1458                 ret = I40E_ERR_INVALID_MAC_ADDR;
1459         } else if (vf->pf_set_mac && !is_multicast_ether_addr(macaddr) &&
1460                    !ether_addr_equal(macaddr, vf->default_lan_addr.addr)) {
1461                 /* If the host VMM administrator has set the VF MAC address
1462                  * administratively via the ndo_set_vf_mac command then deny
1463                  * permission to the VF to add or delete unicast MAC addresses.
1464                  * The VF may request to set the MAC address filter already
1465                  * assigned to it so do not return an error in that case.
1466                  */
1467                 dev_err(&pf->pdev->dev,
1468                         "VF attempting to override administratively set MAC address\nPlease reload the VF driver to resume normal operation\n");
1469                 ret = -EPERM;
1470         }
1471         return ret;
1472 }
1473
1474 /**
1475  * i40e_vc_add_mac_addr_msg
1476  * @vf: pointer to the vf info
1477  * @msg: pointer to the msg buffer
1478  * @msglen: msg length
1479  *
1480  * add guest mac address filter
1481  **/
1482 static int i40e_vc_add_mac_addr_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1483 {
1484         struct i40e_virtchnl_ether_addr_list *al =
1485             (struct i40e_virtchnl_ether_addr_list *)msg;
1486         struct i40e_pf *pf = vf->pf;
1487         struct i40e_vsi *vsi = NULL;
1488         u16 vsi_id = al->vsi_id;
1489         i40e_status ret = 0;
1490         int i;
1491
1492         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
1493             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) ||
1494             !i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1495                 ret = I40E_ERR_PARAM;
1496                 goto error_param;
1497         }
1498
1499         for (i = 0; i < al->num_elements; i++) {
1500                 ret = i40e_check_vf_permission(vf, al->list[i].addr);
1501                 if (ret)
1502                         goto error_param;
1503         }
1504         vsi = pf->vsi[vsi_id];
1505
1506         /* add new addresses to the list */
1507         for (i = 0; i < al->num_elements; i++) {
1508                 struct i40e_mac_filter *f;
1509
1510                 f = i40e_find_mac(vsi, al->list[i].addr, true, false);
1511                 if (!f) {
1512                         if (i40e_is_vsi_in_vlan(vsi))
1513                                 f = i40e_put_mac_in_vlan(vsi, al->list[i].addr,
1514                                                          true, false);
1515                         else
1516                                 f = i40e_add_filter(vsi, al->list[i].addr, -1,
1517                                                     true, false);
1518                 }
1519
1520                 if (!f) {
1521                         dev_err(&pf->pdev->dev,
1522                                 "Unable to add VF MAC filter\n");
1523                         ret = I40E_ERR_PARAM;
1524                         goto error_param;
1525                 }
1526         }
1527
1528         /* program the updated filter list */
1529         if (i40e_sync_vsi_filters(vsi))
1530                 dev_err(&pf->pdev->dev, "Unable to program VF MAC filters\n");
1531
1532 error_param:
1533         /* send the response to the vf */
1534         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_ADD_ETHER_ADDRESS,
1535                                        ret);
1536 }
1537
1538 /**
1539  * i40e_vc_del_mac_addr_msg
1540  * @vf: pointer to the vf info
1541  * @msg: pointer to the msg buffer
1542  * @msglen: msg length
1543  *
1544  * remove guest mac address filter
1545  **/
1546 static int i40e_vc_del_mac_addr_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1547 {
1548         struct i40e_virtchnl_ether_addr_list *al =
1549             (struct i40e_virtchnl_ether_addr_list *)msg;
1550         struct i40e_pf *pf = vf->pf;
1551         struct i40e_vsi *vsi = NULL;
1552         u16 vsi_id = al->vsi_id;
1553         i40e_status ret = 0;
1554         int i;
1555
1556         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
1557             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) ||
1558             !i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1559                 ret = I40E_ERR_PARAM;
1560                 goto error_param;
1561         }
1562
1563         for (i = 0; i < al->num_elements; i++) {
1564                 if (is_broadcast_ether_addr(al->list[i].addr) ||
1565                     is_zero_ether_addr(al->list[i].addr)) {
1566                         dev_err(&pf->pdev->dev, "invalid VF MAC addr %pM\n",
1567                                 al->list[i].addr);
1568                         ret = I40E_ERR_INVALID_MAC_ADDR;
1569                         goto error_param;
1570                 }
1571         }
1572         vsi = pf->vsi[vsi_id];
1573
1574         /* delete addresses from the list */
1575         for (i = 0; i < al->num_elements; i++)
1576                 i40e_del_filter(vsi, al->list[i].addr,
1577                                 I40E_VLAN_ANY, true, false);
1578
1579         /* program the updated filter list */
1580         if (i40e_sync_vsi_filters(vsi))
1581                 dev_err(&pf->pdev->dev, "Unable to program VF MAC filters\n");
1582
1583 error_param:
1584         /* send the response to the vf */
1585         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_DEL_ETHER_ADDRESS,
1586                                        ret);
1587 }
1588
1589 /**
1590  * i40e_vc_add_vlan_msg
1591  * @vf: pointer to the vf info
1592  * @msg: pointer to the msg buffer
1593  * @msglen: msg length
1594  *
1595  * program guest vlan id
1596  **/
1597 static int i40e_vc_add_vlan_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1598 {
1599         struct i40e_virtchnl_vlan_filter_list *vfl =
1600             (struct i40e_virtchnl_vlan_filter_list *)msg;
1601         struct i40e_pf *pf = vf->pf;
1602         struct i40e_vsi *vsi = NULL;
1603         u16 vsi_id = vfl->vsi_id;
1604         i40e_status aq_ret = 0;
1605         int i;
1606
1607         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
1608             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) ||
1609             !i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1610                 aq_ret = I40E_ERR_PARAM;
1611                 goto error_param;
1612         }
1613
1614         for (i = 0; i < vfl->num_elements; i++) {
1615                 if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
1616                         aq_ret = I40E_ERR_PARAM;
1617                         dev_err(&pf->pdev->dev,
1618                                 "invalid VF VLAN id %d\n", vfl->vlan_id[i]);
1619                         goto error_param;
1620                 }
1621         }
1622         vsi = pf->vsi[vsi_id];
1623         if (vsi->info.pvid) {
1624                 aq_ret = I40E_ERR_PARAM;
1625                 goto error_param;
1626         }
1627
1628         i40e_vlan_stripping_enable(vsi);
1629         for (i = 0; i < vfl->num_elements; i++) {
1630                 /* add new VLAN filter */
1631                 int ret = i40e_vsi_add_vlan(vsi, vfl->vlan_id[i]);
1632                 if (ret)
1633                         dev_err(&pf->pdev->dev,
1634                                 "Unable to add VF vlan filter %d, error %d\n",
1635                                 vfl->vlan_id[i], ret);
1636         }
1637
1638 error_param:
1639         /* send the response to the vf */
1640         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_ADD_VLAN, aq_ret);
1641 }
1642
1643 /**
1644  * i40e_vc_remove_vlan_msg
1645  * @vf: pointer to the vf info
1646  * @msg: pointer to the msg buffer
1647  * @msglen: msg length
1648  *
1649  * remove programmed guest vlan id
1650  **/
1651 static int i40e_vc_remove_vlan_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
1652 {
1653         struct i40e_virtchnl_vlan_filter_list *vfl =
1654             (struct i40e_virtchnl_vlan_filter_list *)msg;
1655         struct i40e_pf *pf = vf->pf;
1656         struct i40e_vsi *vsi = NULL;
1657         u16 vsi_id = vfl->vsi_id;
1658         i40e_status aq_ret = 0;
1659         int i;
1660
1661         if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
1662             !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) ||
1663             !i40e_vc_isvalid_vsi_id(vf, vsi_id)) {
1664                 aq_ret = I40E_ERR_PARAM;
1665                 goto error_param;
1666         }
1667
1668         for (i = 0; i < vfl->num_elements; i++) {
1669                 if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
1670                         aq_ret = I40E_ERR_PARAM;
1671                         goto error_param;
1672                 }
1673         }
1674
1675         vsi = pf->vsi[vsi_id];
1676         if (vsi->info.pvid) {
1677                 aq_ret = I40E_ERR_PARAM;
1678                 goto error_param;
1679         }
1680
1681         for (i = 0; i < vfl->num_elements; i++) {
1682                 int ret = i40e_vsi_kill_vlan(vsi, vfl->vlan_id[i]);
1683                 if (ret)
1684                         dev_err(&pf->pdev->dev,
1685                                 "Unable to delete VF vlan filter %d, error %d\n",
1686                                 vfl->vlan_id[i], ret);
1687         }
1688
1689 error_param:
1690         /* send the response to the vf */
1691         return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_DEL_VLAN, aq_ret);
1692 }
1693
1694 /**
1695  * i40e_vc_validate_vf_msg
1696  * @vf: pointer to the vf info
1697  * @msg: pointer to the msg buffer
1698  * @msglen: msg length
1699  * @msghndl: msg handle
1700  *
1701  * validate msg
1702  **/
1703 static int i40e_vc_validate_vf_msg(struct i40e_vf *vf, u32 v_opcode,
1704                                    u32 v_retval, u8 *msg, u16 msglen)
1705 {
1706         bool err_msg_format = false;
1707         int valid_len;
1708
1709         /* Check if VF is disabled. */
1710         if (test_bit(I40E_VF_STAT_DISABLED, &vf->vf_states))
1711                 return I40E_ERR_PARAM;
1712
1713         /* Validate message length. */
1714         switch (v_opcode) {
1715         case I40E_VIRTCHNL_OP_VERSION:
1716                 valid_len = sizeof(struct i40e_virtchnl_version_info);
1717                 break;
1718         case I40E_VIRTCHNL_OP_RESET_VF:
1719         case I40E_VIRTCHNL_OP_GET_VF_RESOURCES:
1720                 valid_len = 0;
1721                 break;
1722         case I40E_VIRTCHNL_OP_CONFIG_TX_QUEUE:
1723                 valid_len = sizeof(struct i40e_virtchnl_txq_info);
1724                 break;
1725         case I40E_VIRTCHNL_OP_CONFIG_RX_QUEUE:
1726                 valid_len = sizeof(struct i40e_virtchnl_rxq_info);
1727                 break;
1728         case I40E_VIRTCHNL_OP_CONFIG_VSI_QUEUES:
1729                 valid_len = sizeof(struct i40e_virtchnl_vsi_queue_config_info);
1730                 if (msglen >= valid_len) {
1731                         struct i40e_virtchnl_vsi_queue_config_info *vqc =
1732                             (struct i40e_virtchnl_vsi_queue_config_info *)msg;
1733                         valid_len += (vqc->num_queue_pairs *
1734                                       sizeof(struct
1735                                              i40e_virtchnl_queue_pair_info));
1736                         if (vqc->num_queue_pairs == 0)
1737                                 err_msg_format = true;
1738                 }
1739                 break;
1740         case I40E_VIRTCHNL_OP_CONFIG_IRQ_MAP:
1741                 valid_len = sizeof(struct i40e_virtchnl_irq_map_info);
1742                 if (msglen >= valid_len) {
1743                         struct i40e_virtchnl_irq_map_info *vimi =
1744                             (struct i40e_virtchnl_irq_map_info *)msg;
1745                         valid_len += (vimi->num_vectors *
1746                                       sizeof(struct i40e_virtchnl_vector_map));
1747                         if (vimi->num_vectors == 0)
1748                                 err_msg_format = true;
1749                 }
1750                 break;
1751         case I40E_VIRTCHNL_OP_ENABLE_QUEUES:
1752         case I40E_VIRTCHNL_OP_DISABLE_QUEUES:
1753                 valid_len = sizeof(struct i40e_virtchnl_queue_select);
1754                 break;
1755         case I40E_VIRTCHNL_OP_ADD_ETHER_ADDRESS:
1756         case I40E_VIRTCHNL_OP_DEL_ETHER_ADDRESS:
1757                 valid_len = sizeof(struct i40e_virtchnl_ether_addr_list);
1758                 if (msglen >= valid_len) {
1759                         struct i40e_virtchnl_ether_addr_list *veal =
1760                             (struct i40e_virtchnl_ether_addr_list *)msg;
1761                         valid_len += veal->num_elements *
1762                             sizeof(struct i40e_virtchnl_ether_addr);
1763                         if (veal->num_elements == 0)
1764                                 err_msg_format = true;
1765                 }
1766                 break;
1767         case I40E_VIRTCHNL_OP_ADD_VLAN:
1768         case I40E_VIRTCHNL_OP_DEL_VLAN:
1769                 valid_len = sizeof(struct i40e_virtchnl_vlan_filter_list);
1770                 if (msglen >= valid_len) {
1771                         struct i40e_virtchnl_vlan_filter_list *vfl =
1772                             (struct i40e_virtchnl_vlan_filter_list *)msg;
1773                         valid_len += vfl->num_elements * sizeof(u16);
1774                         if (vfl->num_elements == 0)
1775                                 err_msg_format = true;
1776                 }
1777                 break;
1778         case I40E_VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
1779                 valid_len = sizeof(struct i40e_virtchnl_promisc_info);
1780                 break;
1781         case I40E_VIRTCHNL_OP_GET_STATS:
1782                 valid_len = sizeof(struct i40e_virtchnl_queue_select);
1783                 break;
1784         /* These are always errors coming from the VF. */
1785         case I40E_VIRTCHNL_OP_EVENT:
1786         case I40E_VIRTCHNL_OP_UNKNOWN:
1787         default:
1788                 return -EPERM;
1789                 break;
1790         }
1791         /* few more checks */
1792         if ((valid_len != msglen) || (err_msg_format)) {
1793                 i40e_vc_send_resp_to_vf(vf, v_opcode, I40E_ERR_PARAM);
1794                 return -EINVAL;
1795         } else {
1796                 return 0;
1797         }
1798 }
1799
1800 /**
1801  * i40e_vc_process_vf_msg
1802  * @pf: pointer to the pf structure
1803  * @vf_id: source vf id
1804  * @msg: pointer to the msg buffer
1805  * @msglen: msg length
1806  * @msghndl: msg handle
1807  *
1808  * called from the common aeq/arq handler to
1809  * process request from vf
1810  **/
1811 int i40e_vc_process_vf_msg(struct i40e_pf *pf, u16 vf_id, u32 v_opcode,
1812                            u32 v_retval, u8 *msg, u16 msglen)
1813 {
1814         struct i40e_hw *hw = &pf->hw;
1815         unsigned int local_vf_id = vf_id - hw->func_caps.vf_base_id;
1816         struct i40e_vf *vf;
1817         int ret;
1818
1819         pf->vf_aq_requests++;
1820         if (local_vf_id >= pf->num_alloc_vfs)
1821                 return -EINVAL;
1822         vf = &(pf->vf[local_vf_id]);
1823         /* perform basic checks on the msg */
1824         ret = i40e_vc_validate_vf_msg(vf, v_opcode, v_retval, msg, msglen);
1825
1826         if (ret) {
1827                 dev_err(&pf->pdev->dev, "Invalid message from vf %d, opcode %d, len %d\n",
1828                         local_vf_id, v_opcode, msglen);
1829                 return ret;
1830         }
1831
1832         switch (v_opcode) {
1833         case I40E_VIRTCHNL_OP_VERSION:
1834                 ret = i40e_vc_get_version_msg(vf);
1835                 break;
1836         case I40E_VIRTCHNL_OP_GET_VF_RESOURCES:
1837                 ret = i40e_vc_get_vf_resources_msg(vf);
1838                 break;
1839         case I40E_VIRTCHNL_OP_RESET_VF:
1840                 i40e_vc_reset_vf_msg(vf);
1841                 ret = 0;
1842                 break;
1843         case I40E_VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
1844                 ret = i40e_vc_config_promiscuous_mode_msg(vf, msg, msglen);
1845                 break;
1846         case I40E_VIRTCHNL_OP_CONFIG_VSI_QUEUES:
1847                 ret = i40e_vc_config_queues_msg(vf, msg, msglen);
1848                 break;
1849         case I40E_VIRTCHNL_OP_CONFIG_IRQ_MAP:
1850                 ret = i40e_vc_config_irq_map_msg(vf, msg, msglen);
1851                 break;
1852         case I40E_VIRTCHNL_OP_ENABLE_QUEUES:
1853                 ret = i40e_vc_enable_queues_msg(vf, msg, msglen);
1854                 break;
1855         case I40E_VIRTCHNL_OP_DISABLE_QUEUES:
1856                 ret = i40e_vc_disable_queues_msg(vf, msg, msglen);
1857                 break;
1858         case I40E_VIRTCHNL_OP_ADD_ETHER_ADDRESS:
1859                 ret = i40e_vc_add_mac_addr_msg(vf, msg, msglen);
1860                 break;
1861         case I40E_VIRTCHNL_OP_DEL_ETHER_ADDRESS:
1862                 ret = i40e_vc_del_mac_addr_msg(vf, msg, msglen);
1863                 break;
1864         case I40E_VIRTCHNL_OP_ADD_VLAN:
1865                 ret = i40e_vc_add_vlan_msg(vf, msg, msglen);
1866                 break;
1867         case I40E_VIRTCHNL_OP_DEL_VLAN:
1868                 ret = i40e_vc_remove_vlan_msg(vf, msg, msglen);
1869                 break;
1870         case I40E_VIRTCHNL_OP_GET_STATS:
1871                 ret = i40e_vc_get_stats_msg(vf, msg, msglen);
1872                 break;
1873         case I40E_VIRTCHNL_OP_UNKNOWN:
1874         default:
1875                 dev_err(&pf->pdev->dev, "Unsupported opcode %d from vf %d\n",
1876                         v_opcode, local_vf_id);
1877                 ret = i40e_vc_send_resp_to_vf(vf, v_opcode,
1878                                               I40E_ERR_NOT_IMPLEMENTED);
1879                 break;
1880         }
1881
1882         return ret;
1883 }
1884
1885 /**
1886  * i40e_vc_process_vflr_event
1887  * @pf: pointer to the pf structure
1888  *
1889  * called from the vlfr irq handler to
1890  * free up vf resources and state variables
1891  **/
1892 int i40e_vc_process_vflr_event(struct i40e_pf *pf)
1893 {
1894         u32 reg, reg_idx, bit_idx, vf_id;
1895         struct i40e_hw *hw = &pf->hw;
1896         struct i40e_vf *vf;
1897
1898         if (!test_bit(__I40E_VFLR_EVENT_PENDING, &pf->state))
1899                 return 0;
1900
1901         clear_bit(__I40E_VFLR_EVENT_PENDING, &pf->state);
1902         for (vf_id = 0; vf_id < pf->num_alloc_vfs; vf_id++) {
1903                 reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
1904                 bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
1905                 /* read GLGEN_VFLRSTAT register to find out the flr vfs */
1906                 vf = &pf->vf[vf_id];
1907                 reg = rd32(hw, I40E_GLGEN_VFLRSTAT(reg_idx));
1908                 if (reg & (1 << bit_idx)) {
1909                         /* clear the bit in GLGEN_VFLRSTAT */
1910                         wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), (1 << bit_idx));
1911
1912                         if (!test_bit(__I40E_DOWN, &pf->state))
1913                                 i40e_reset_vf(vf, true);
1914                 }
1915         }
1916
1917         /* re-enable vflr interrupt cause */
1918         reg = rd32(hw, I40E_PFINT_ICR0_ENA);
1919         reg |= I40E_PFINT_ICR0_ENA_VFLR_MASK;
1920         wr32(hw, I40E_PFINT_ICR0_ENA, reg);
1921         i40e_flush(hw);
1922
1923         return 0;
1924 }
1925
1926 /**
1927  * i40e_vc_vf_broadcast
1928  * @pf: pointer to the pf structure
1929  * @opcode: operation code
1930  * @retval: return value
1931  * @msg: pointer to the msg buffer
1932  * @msglen: msg length
1933  *
1934  * send a message to all VFs on a given PF
1935  **/
1936 static void i40e_vc_vf_broadcast(struct i40e_pf *pf,
1937                                  enum i40e_virtchnl_ops v_opcode,
1938                                  i40e_status v_retval, u8 *msg,
1939                                  u16 msglen)
1940 {
1941         struct i40e_hw *hw = &pf->hw;
1942         struct i40e_vf *vf = pf->vf;
1943         int i;
1944
1945         for (i = 0; i < pf->num_alloc_vfs; i++) {
1946                 /* Ignore return value on purpose - a given VF may fail, but
1947                  * we need to keep going and send to all of them
1948                  */
1949                 i40e_aq_send_msg_to_vf(hw, vf->vf_id, v_opcode, v_retval,
1950                                        msg, msglen, NULL);
1951                 vf++;
1952         }
1953 }
1954
1955 /**
1956  * i40e_vc_notify_link_state
1957  * @pf: pointer to the pf structure
1958  *
1959  * send a link status message to all VFs on a given PF
1960  **/
1961 void i40e_vc_notify_link_state(struct i40e_pf *pf)
1962 {
1963         struct i40e_virtchnl_pf_event pfe;
1964         struct i40e_hw *hw = &pf->hw;
1965         struct i40e_vf *vf = pf->vf;
1966         struct i40e_link_status *ls = &pf->hw.phy.link_info;
1967         int i;
1968
1969         pfe.event = I40E_VIRTCHNL_EVENT_LINK_CHANGE;
1970         pfe.severity = I40E_PF_EVENT_SEVERITY_INFO;
1971         for (i = 0; i < pf->num_alloc_vfs; i++) {
1972                 if (vf->link_forced) {
1973                         pfe.event_data.link_event.link_status = vf->link_up;
1974                         pfe.event_data.link_event.link_speed =
1975                                 (vf->link_up ? I40E_LINK_SPEED_40GB : 0);
1976                 } else {
1977                         pfe.event_data.link_event.link_status =
1978                                 ls->link_info & I40E_AQ_LINK_UP;
1979                         pfe.event_data.link_event.link_speed = ls->link_speed;
1980                 }
1981                 i40e_aq_send_msg_to_vf(hw, vf->vf_id, I40E_VIRTCHNL_OP_EVENT,
1982                                        0, (u8 *)&pfe, sizeof(pfe),
1983                                        NULL);
1984                 vf++;
1985         }
1986 }
1987
1988 /**
1989  * i40e_vc_notify_reset
1990  * @pf: pointer to the pf structure
1991  *
1992  * indicate a pending reset to all VFs on a given PF
1993  **/
1994 void i40e_vc_notify_reset(struct i40e_pf *pf)
1995 {
1996         struct i40e_virtchnl_pf_event pfe;
1997
1998         pfe.event = I40E_VIRTCHNL_EVENT_RESET_IMPENDING;
1999         pfe.severity = I40E_PF_EVENT_SEVERITY_CERTAIN_DOOM;
2000         i40e_vc_vf_broadcast(pf, I40E_VIRTCHNL_OP_EVENT, I40E_SUCCESS,
2001                              (u8 *)&pfe, sizeof(struct i40e_virtchnl_pf_event));
2002 }
2003
2004 /**
2005  * i40e_vc_notify_vf_reset
2006  * @vf: pointer to the vf structure
2007  *
2008  * indicate a pending reset to the given VF
2009  **/
2010 void i40e_vc_notify_vf_reset(struct i40e_vf *vf)
2011 {
2012         struct i40e_virtchnl_pf_event pfe;
2013
2014         pfe.event = I40E_VIRTCHNL_EVENT_RESET_IMPENDING;
2015         pfe.severity = I40E_PF_EVENT_SEVERITY_CERTAIN_DOOM;
2016         i40e_aq_send_msg_to_vf(&vf->pf->hw, vf->vf_id, I40E_VIRTCHNL_OP_EVENT,
2017                                I40E_SUCCESS, (u8 *)&pfe,
2018                                sizeof(struct i40e_virtchnl_pf_event), NULL);
2019 }
2020
2021 /**
2022  * i40e_ndo_set_vf_mac
2023  * @netdev: network interface device structure
2024  * @vf_id: vf identifier
2025  * @mac: mac address
2026  *
2027  * program vf mac address
2028  **/
2029 int i40e_ndo_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac)
2030 {
2031         struct i40e_netdev_priv *np = netdev_priv(netdev);
2032         struct i40e_vsi *vsi = np->vsi;
2033         struct i40e_pf *pf = vsi->back;
2034         struct i40e_mac_filter *f;
2035         struct i40e_vf *vf;
2036         int ret = 0;
2037
2038         /* validate the request */
2039         if (vf_id >= pf->num_alloc_vfs) {
2040                 dev_err(&pf->pdev->dev,
2041                         "Invalid VF Identifier %d\n", vf_id);
2042                 ret = -EINVAL;
2043                 goto error_param;
2044         }
2045
2046         vf = &(pf->vf[vf_id]);
2047         vsi = pf->vsi[vf->lan_vsi_index];
2048         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
2049                 dev_err(&pf->pdev->dev,
2050                         "Uninitialized VF %d\n", vf_id);
2051                 ret = -EINVAL;
2052                 goto error_param;
2053         }
2054
2055         if (!is_valid_ether_addr(mac)) {
2056                 dev_err(&pf->pdev->dev,
2057                         "Invalid VF ethernet address\n");
2058                 ret = -EINVAL;
2059                 goto error_param;
2060         }
2061
2062         /* delete the temporary mac address */
2063         i40e_del_filter(vsi, vf->default_lan_addr.addr, vf->port_vlan_id,
2064                         true, false);
2065
2066         /* add the new mac address */
2067         f = i40e_add_filter(vsi, mac, vf->port_vlan_id, true, false);
2068         if (!f) {
2069                 dev_err(&pf->pdev->dev,
2070                         "Unable to add VF ucast filter\n");
2071                 ret = -ENOMEM;
2072                 goto error_param;
2073         }
2074
2075         dev_info(&pf->pdev->dev, "Setting MAC %pM on VF %d\n", mac, vf_id);
2076         /* program mac filter */
2077         if (i40e_sync_vsi_filters(vsi)) {
2078                 dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
2079                 ret = -EIO;
2080                 goto error_param;
2081         }
2082         memcpy(vf->default_lan_addr.addr, mac, ETH_ALEN);
2083         vf->pf_set_mac = true;
2084         dev_info(&pf->pdev->dev, "Reload the VF driver to make this change effective.\n");
2085         ret = 0;
2086
2087 error_param:
2088         return ret;
2089 }
2090
2091 /**
2092  * i40e_ndo_set_vf_port_vlan
2093  * @netdev: network interface device structure
2094  * @vf_id: vf identifier
2095  * @vlan_id: mac address
2096  * @qos: priority setting
2097  *
2098  * program vf vlan id and/or qos
2099  **/
2100 int i40e_ndo_set_vf_port_vlan(struct net_device *netdev,
2101                               int vf_id, u16 vlan_id, u8 qos)
2102 {
2103         struct i40e_netdev_priv *np = netdev_priv(netdev);
2104         struct i40e_pf *pf = np->vsi->back;
2105         struct i40e_vsi *vsi;
2106         struct i40e_vf *vf;
2107         int ret = 0;
2108
2109         /* validate the request */
2110         if (vf_id >= pf->num_alloc_vfs) {
2111                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
2112                 ret = -EINVAL;
2113                 goto error_pvid;
2114         }
2115
2116         if ((vlan_id > I40E_MAX_VLANID) || (qos > 7)) {
2117                 dev_err(&pf->pdev->dev, "Invalid VF Parameters\n");
2118                 ret = -EINVAL;
2119                 goto error_pvid;
2120         }
2121
2122         vf = &(pf->vf[vf_id]);
2123         vsi = pf->vsi[vf->lan_vsi_index];
2124         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
2125                 dev_err(&pf->pdev->dev, "Uninitialized VF %d\n", vf_id);
2126                 ret = -EINVAL;
2127                 goto error_pvid;
2128         }
2129
2130         if (vsi->info.pvid == 0 && i40e_is_vsi_in_vlan(vsi)) {
2131                 dev_err(&pf->pdev->dev,
2132                         "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",
2133                         vf_id);
2134                 /* Administrator Error - knock the VF offline until he does
2135                  * the right thing by reconfiguring his network correctly
2136                  * and then reloading the VF driver.
2137                  */
2138                 i40e_vc_disable_vf(pf, vf);
2139         }
2140
2141         /* Check for condition where there was already a port VLAN ID
2142          * filter set and now it is being deleted by setting it to zero.
2143          * Additionally check for the condition where there was a port
2144          * VLAN but now there is a new and different port VLAN being set.
2145          * Before deleting all the old VLAN filters we must add new ones
2146          * with -1 (I40E_VLAN_ANY) or otherwise we're left with all our
2147          * MAC addresses deleted.
2148          */
2149         if ((!(vlan_id || qos) ||
2150             (vlan_id | qos) != le16_to_cpu(vsi->info.pvid)) &&
2151             vsi->info.pvid)
2152                 ret = i40e_vsi_add_vlan(vsi, I40E_VLAN_ANY);
2153
2154         if (vsi->info.pvid) {
2155                 /* kill old VLAN */
2156                 ret = i40e_vsi_kill_vlan(vsi, (le16_to_cpu(vsi->info.pvid) &
2157                                                VLAN_VID_MASK));
2158                 if (ret) {
2159                         dev_info(&vsi->back->pdev->dev,
2160                                  "remove VLAN failed, ret=%d, aq_err=%d\n",
2161                                  ret, pf->hw.aq.asq_last_status);
2162                 }
2163         }
2164         if (vlan_id || qos)
2165                 ret = i40e_vsi_add_pvid(vsi,
2166                                 vlan_id | (qos << I40E_VLAN_PRIORITY_SHIFT));
2167         else
2168                 i40e_vsi_remove_pvid(vsi);
2169
2170         if (vlan_id) {
2171                 dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",
2172                          vlan_id, qos, vf_id);
2173
2174                 /* add new VLAN filter */
2175                 ret = i40e_vsi_add_vlan(vsi, vlan_id);
2176                 if (ret) {
2177                         dev_info(&vsi->back->pdev->dev,
2178                                  "add VF VLAN failed, ret=%d aq_err=%d\n", ret,
2179                                  vsi->back->hw.aq.asq_last_status);
2180                         goto error_pvid;
2181                 }
2182                 /* Kill non-vlan MAC filters - ignore error return since
2183                  * there might not be any non-vlan MAC filters.
2184                  */
2185                 i40e_vsi_kill_vlan(vsi, I40E_VLAN_ANY);
2186         }
2187
2188         if (ret) {
2189                 dev_err(&pf->pdev->dev, "Unable to update VF vsi context\n");
2190                 goto error_pvid;
2191         }
2192         /* The Port VLAN needs to be saved across resets the same as the
2193          * default LAN MAC address.
2194          */
2195         vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);
2196         ret = 0;
2197
2198 error_pvid:
2199         return ret;
2200 }
2201
2202 #define I40E_BW_CREDIT_DIVISOR 50     /* 50Mbps per BW credit */
2203 #define I40E_MAX_BW_INACTIVE_ACCUM 4  /* device can accumulate 4 credits max */
2204 /**
2205  * i40e_ndo_set_vf_bw
2206  * @netdev: network interface device structure
2207  * @vf_id: vf identifier
2208  * @tx_rate: tx rate
2209  *
2210  * configure vf tx rate
2211  **/
2212 int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
2213                        int max_tx_rate)
2214 {
2215         struct i40e_netdev_priv *np = netdev_priv(netdev);
2216         struct i40e_pf *pf = np->vsi->back;
2217         struct i40e_vsi *vsi;
2218         struct i40e_vf *vf;
2219         int speed = 0;
2220         int ret = 0;
2221
2222         /* validate the request */
2223         if (vf_id >= pf->num_alloc_vfs) {
2224                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d.\n", vf_id);
2225                 ret = -EINVAL;
2226                 goto error;
2227         }
2228
2229         if (min_tx_rate) {
2230                 dev_err(&pf->pdev->dev, "Invalid min tx rate (%d) (greater than 0) specified for vf %d.\n",
2231                         min_tx_rate, vf_id);
2232                 return -EINVAL;
2233         }
2234
2235         vf = &(pf->vf[vf_id]);
2236         vsi = pf->vsi[vf->lan_vsi_index];
2237         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
2238                 dev_err(&pf->pdev->dev, "Uninitialized VF %d.\n", vf_id);
2239                 ret = -EINVAL;
2240                 goto error;
2241         }
2242
2243         switch (pf->hw.phy.link_info.link_speed) {
2244         case I40E_LINK_SPEED_40GB:
2245                 speed = 40000;
2246                 break;
2247         case I40E_LINK_SPEED_10GB:
2248                 speed = 10000;
2249                 break;
2250         case I40E_LINK_SPEED_1GB:
2251                 speed = 1000;
2252                 break;
2253         default:
2254                 break;
2255         }
2256
2257         if (max_tx_rate > speed) {
2258                 dev_err(&pf->pdev->dev, "Invalid max tx rate %d specified for vf %d.",
2259                         max_tx_rate, vf->vf_id);
2260                 ret = -EINVAL;
2261                 goto error;
2262         }
2263
2264         if ((max_tx_rate < 50) && (max_tx_rate > 0)) {
2265                 dev_warn(&pf->pdev->dev, "Setting max Tx rate to minimum usable value of 50Mbps.\n");
2266                 max_tx_rate = 50;
2267         }
2268
2269         /* Tx rate credits are in values of 50Mbps, 0 is disabled*/
2270         ret = i40e_aq_config_vsi_bw_limit(&pf->hw, vsi->seid,
2271                                           max_tx_rate / I40E_BW_CREDIT_DIVISOR,
2272                                           I40E_MAX_BW_INACTIVE_ACCUM, NULL);
2273         if (ret) {
2274                 dev_err(&pf->pdev->dev, "Unable to set max tx rate, error code %d.\n",
2275                         ret);
2276                 ret = -EIO;
2277                 goto error;
2278         }
2279         vf->tx_rate = max_tx_rate;
2280 error:
2281         return ret;
2282 }
2283
2284 /**
2285  * i40e_ndo_get_vf_config
2286  * @netdev: network interface device structure
2287  * @vf_id: vf identifier
2288  * @ivi: vf configuration structure
2289  *
2290  * return vf configuration
2291  **/
2292 int i40e_ndo_get_vf_config(struct net_device *netdev,
2293                            int vf_id, struct ifla_vf_info *ivi)
2294 {
2295         struct i40e_netdev_priv *np = netdev_priv(netdev);
2296         struct i40e_vsi *vsi = np->vsi;
2297         struct i40e_pf *pf = vsi->back;
2298         struct i40e_vf *vf;
2299         int ret = 0;
2300
2301         /* validate the request */
2302         if (vf_id >= pf->num_alloc_vfs) {
2303                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
2304                 ret = -EINVAL;
2305                 goto error_param;
2306         }
2307
2308         vf = &(pf->vf[vf_id]);
2309         /* first vsi is always the LAN vsi */
2310         vsi = pf->vsi[vf->lan_vsi_index];
2311         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
2312                 dev_err(&pf->pdev->dev, "Uninitialized VF %d\n", vf_id);
2313                 ret = -EINVAL;
2314                 goto error_param;
2315         }
2316
2317         ivi->vf = vf_id;
2318
2319         memcpy(&ivi->mac, vf->default_lan_addr.addr, ETH_ALEN);
2320
2321         ivi->max_tx_rate = vf->tx_rate;
2322         ivi->min_tx_rate = 0;
2323         ivi->vlan = le16_to_cpu(vsi->info.pvid) & I40E_VLAN_MASK;
2324         ivi->qos = (le16_to_cpu(vsi->info.pvid) & I40E_PRIORITY_MASK) >>
2325                    I40E_VLAN_PRIORITY_SHIFT;
2326         if (vf->link_forced == false)
2327                 ivi->linkstate = IFLA_VF_LINK_STATE_AUTO;
2328         else if (vf->link_up == true)
2329                 ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE;
2330         else
2331                 ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE;
2332         ivi->spoofchk = vf->spoofchk;
2333         ret = 0;
2334
2335 error_param:
2336         return ret;
2337 }
2338
2339 /**
2340  * i40e_ndo_set_vf_link_state
2341  * @netdev: network interface device structure
2342  * @vf_id: vf identifier
2343  * @link: required link state
2344  *
2345  * Set the link state of a specified VF, regardless of physical link state
2346  **/
2347 int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link)
2348 {
2349         struct i40e_netdev_priv *np = netdev_priv(netdev);
2350         struct i40e_pf *pf = np->vsi->back;
2351         struct i40e_virtchnl_pf_event pfe;
2352         struct i40e_hw *hw = &pf->hw;
2353         struct i40e_vf *vf;
2354         int ret = 0;
2355
2356         /* validate the request */
2357         if (vf_id >= pf->num_alloc_vfs) {
2358                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
2359                 ret = -EINVAL;
2360                 goto error_out;
2361         }
2362
2363         vf = &pf->vf[vf_id];
2364
2365         pfe.event = I40E_VIRTCHNL_EVENT_LINK_CHANGE;
2366         pfe.severity = I40E_PF_EVENT_SEVERITY_INFO;
2367
2368         switch (link) {
2369         case IFLA_VF_LINK_STATE_AUTO:
2370                 vf->link_forced = false;
2371                 pfe.event_data.link_event.link_status =
2372                         pf->hw.phy.link_info.link_info & I40E_AQ_LINK_UP;
2373                 pfe.event_data.link_event.link_speed =
2374                         pf->hw.phy.link_info.link_speed;
2375                 break;
2376         case IFLA_VF_LINK_STATE_ENABLE:
2377                 vf->link_forced = true;
2378                 vf->link_up = true;
2379                 pfe.event_data.link_event.link_status = true;
2380                 pfe.event_data.link_event.link_speed = I40E_LINK_SPEED_40GB;
2381                 break;
2382         case IFLA_VF_LINK_STATE_DISABLE:
2383                 vf->link_forced = true;
2384                 vf->link_up = false;
2385                 pfe.event_data.link_event.link_status = false;
2386                 pfe.event_data.link_event.link_speed = 0;
2387                 break;
2388         default:
2389                 ret = -EINVAL;
2390                 goto error_out;
2391         }
2392         /* Notify the VF of its new link state */
2393         i40e_aq_send_msg_to_vf(hw, vf->vf_id, I40E_VIRTCHNL_OP_EVENT,
2394                                0, (u8 *)&pfe, sizeof(pfe), NULL);
2395
2396 error_out:
2397         return ret;
2398 }
2399
2400 /**
2401  * i40e_ndo_set_vf_spoofchk
2402  * @netdev: network interface device structure
2403  * @vf_id: vf identifier
2404  * @enable: flag to enable or disable feature
2405  *
2406  * Enable or disable VF spoof checking
2407  **/
2408 int i40e_ndo_set_vf_spoofck(struct net_device *netdev, int vf_id, bool enable)
2409 {
2410         struct i40e_netdev_priv *np = netdev_priv(netdev);
2411         struct i40e_vsi *vsi = np->vsi;
2412         struct i40e_pf *pf = vsi->back;
2413         struct i40e_vsi_context ctxt;
2414         struct i40e_hw *hw = &pf->hw;
2415         struct i40e_vf *vf;
2416         int ret = 0;
2417
2418         /* validate the request */
2419         if (vf_id >= pf->num_alloc_vfs) {
2420                 dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
2421                 ret = -EINVAL;
2422                 goto out;
2423         }
2424
2425         vf = &(pf->vf[vf_id]);
2426
2427         if (enable == vf->spoofchk)
2428                 goto out;
2429
2430         vf->spoofchk = enable;
2431         memset(&ctxt, 0, sizeof(ctxt));
2432         ctxt.seid = pf->vsi[vf->lan_vsi_index]->seid;
2433         ctxt.pf_num = pf->hw.pf_id;
2434         ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SECURITY_VALID);
2435         if (enable)
2436                 ctxt.info.sec_flags |= I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK;
2437         ret = i40e_aq_update_vsi_params(hw, &ctxt, NULL);
2438         if (ret) {
2439                 dev_err(&pf->pdev->dev, "Error %d updating VSI parameters\n",
2440                         ret);
2441                 ret = -EIO;
2442         }
2443 out:
2444         return ret;
2445 }