drivers/net/ethernet/intel/ixgbevf/vf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 #include "vf.h"
   5 #include "ixgbevf.h"
   6
   7 /* On Hyper-V, to reset, we need to read from this offset
   8  * from the PCI config space. This is the mechanism used on
   9  * Hyper-V to support PF/VF communication.
  10  */
  11 #define IXGBE_HV_RESET_OFFSET           0x201
  12
  13 static inline s32 ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, u32 *msg,
  14                                              u32 *retmsg, u16 size)
  15 {
  16         s32 retval = ixgbevf_write_mbx(hw, msg, size);
  17
  18         if (retval)
  19                 return retval;
  20
  21         return ixgbevf_poll_mbx(hw, retmsg, size);
  22 }
  23
  24 /**
  25  *  ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx
  26  *  @hw: pointer to hardware structure
  27  *
  28  *  Starts the hardware by filling the bus info structure and media type, clears
  29  *  all on chip counters, initializes receive address registers, multicast
  30  *  table, VLAN filter table, calls routine to set up link and flow control
  31  *  settings, and leaves transmit and receive units disabled and uninitialized
  32  **/
  33 static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw)
  34 {
  35         /* Clear adapter stopped flag */
  36         hw->adapter_stopped = false;
  37
  38         return 0;
  39 }
  40
  41 /**
  42  *  ixgbevf_init_hw_vf - virtual function hardware initialization
  43  *  @hw: pointer to hardware structure
  44  *
  45  *  Initialize the hardware by resetting the hardware and then starting
  46  *  the hardware
  47  **/
  48 static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw)
  49 {
  50         s32 status = hw->mac.ops.start_hw(hw);
  51
  52         hw->mac.ops.get_mac_addr(hw, hw->mac.addr);
  53
  54         return status;
  55 }
  56
  57 /**
  58  *  ixgbevf_reset_hw_vf - Performs hardware reset
  59  *  @hw: pointer to hardware structure
  60  *
  61  *  Resets the hardware by resetting the transmit and receive units, masks and
  62  *  clears all interrupts.
  63  **/
  64 static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw)
  65 {
  66         struct ixgbe_mbx_info *mbx = &hw->mbx;
  67         u32 timeout = IXGBE_VF_INIT_TIMEOUT;
  68         u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN];
  69         u8 *addr = (u8 *)(&msgbuf[1]);
  70         s32 ret_val;
  71
  72         /* Call adapter stop to disable tx/rx and clear interrupts */
  73         hw->mac.ops.stop_adapter(hw);
  74
  75         /* reset the api version */
  76         hw->api_version = ixgbe_mbox_api_10;
  77         hw->mbx.ops.init_params(hw);
  78         memcpy(&hw->mbx.ops, &ixgbevf_mbx_ops_legacy,
  79                sizeof(struct ixgbe_mbx_operations));
  80
  81         IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST);
  82         IXGBE_WRITE_FLUSH(hw);
  83
  84         /* we cannot reset while the RSTI / RSTD bits are asserted */
  85         while (!mbx->ops.check_for_rst(hw) && timeout) {
  86                 timeout--;
  87                 udelay(5);
  88         }
  89
  90         if (!timeout)
  91                 return IXGBE_ERR_RESET_FAILED;
  92
  93         /* mailbox timeout can now become active */
  94         mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
  95
  96         msgbuf[0] = IXGBE_VF_RESET;
  97         ixgbevf_write_mbx(hw, msgbuf, 1);
  98
  99         mdelay(10);
 100
 101         /* set our "perm_addr" based on info provided by PF
 102          * also set up the mc_filter_type which is piggy backed
 103          * on the mac address in word 3
 104          */
 105         ret_val = ixgbevf_poll_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN);
 106         if (ret_val)
 107                 return ret_val;
 108
 109         /* New versions of the PF may NACK the reset return message
 110          * to indicate that no MAC address has yet been assigned for
 111          * the VF.
 112          */
 113         if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS) &&
 114             msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_FAILURE))
 115                 return IXGBE_ERR_INVALID_MAC_ADDR;
 116
 117         if (msgbuf[0] == (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_SUCCESS))
 118                 ether_addr_copy(hw->mac.perm_addr, addr);
 119
 120         hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD];
 121
 122         return 0;
 123 }
 124
 125 /**
 126  * ixgbevf_hv_reset_hw_vf - reset via Hyper-V
 127  * @hw: pointer to private hardware struct
 128  *
 129  * Hyper-V variant; the VF/PF communication is through the PCI
 130  * config space.
 131  */
 132 static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw)
 133 {
 134 #if IS_ENABLED(CONFIG_PCI_MMCONFIG)
 135         struct ixgbevf_adapter *adapter = hw->back;
 136         int i;
 137
 138         for (i = 0; i < 6; i++)
 139                 pci_read_config_byte(adapter->pdev,
 140                                      (i + IXGBE_HV_RESET_OFFSET),
 141                                      &hw->mac.perm_addr[i]);
 142         return 0;
 143 #else
 144         pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n");
 145         return -EOPNOTSUPP;
 146 #endif
 147 }
 148
 149 /**
 150  *  ixgbevf_stop_hw_vf - Generic stop Tx/Rx units
 151  *  @hw: pointer to hardware structure
 152  *
 153  *  Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts,
 154  *  disables transmit and receive units. The adapter_stopped flag is used by
 155  *  the shared code and drivers to determine if the adapter is in a stopped
 156  *  state and should not touch the hardware.
 157  **/
 158 static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw)
 159 {
 160         u32 number_of_queues;
 161         u32 reg_val;
 162         u16 i;
 163
 164         /* Set the adapter_stopped flag so other driver functions stop touching
 165          * the hardware
 166          */
 167         hw->adapter_stopped = true;
 168
 169         /* Disable the receive unit by stopped each queue */
 170         number_of_queues = hw->mac.max_rx_queues;
 171         for (i = 0; i < number_of_queues; i++) {
 172                 reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
 173                 if (reg_val & IXGBE_RXDCTL_ENABLE) {
 174                         reg_val &= ~IXGBE_RXDCTL_ENABLE;
 175                         IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val);
 176                 }
 177         }
 178
 179         IXGBE_WRITE_FLUSH(hw);
 180
 181         /* Clear interrupt mask to stop from interrupts being generated */
 182         IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK);
 183
 184         /* Clear any pending interrupts */
 185         IXGBE_READ_REG(hw, IXGBE_VTEICR);
 186
 187         /* Disable the transmit unit.  Each queue must be disabled. */
 188         number_of_queues = hw->mac.max_tx_queues;
 189         for (i = 0; i < number_of_queues; i++) {
 190                 reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
 191                 if (reg_val & IXGBE_TXDCTL_ENABLE) {
 192                         reg_val &= ~IXGBE_TXDCTL_ENABLE;
 193                         IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val);
 194                 }
 195         }
 196
 197         return 0;
 198 }
 199
 200 /**
 201  *  ixgbevf_mta_vector - Determines bit-vector in multicast table to set
 202  *  @hw: pointer to hardware structure
 203  *  @mc_addr: the multicast address
 204  *
 205  *  Extracts the 12 bits, from a multicast address, to determine which
 206  *  bit-vector to set in the multicast table. The hardware uses 12 bits, from
 207  *  incoming Rx multicast addresses, to determine the bit-vector to check in
 208  *  the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set
 209  *  by the MO field of the MCSTCTRL. The MO field is set during initialization
 210  *  to mc_filter_type.
 211  **/
 212 static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr)
 213 {
 214         u32 vector = 0;
 215
 216         switch (hw->mac.mc_filter_type) {
 217         case 0:   /* use bits [47:36] of the address */
 218                 vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
 219                 break;
 220         case 1:   /* use bits [46:35] of the address */
 221                 vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
 222                 break;
 223         case 2:   /* use bits [45:34] of the address */
 224                 vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
 225                 break;
 226         case 3:   /* use bits [43:32] of the address */
 227                 vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
 228                 break;
 229         default:  /* Invalid mc_filter_type */
 230                 break;
 231         }
 232
 233         /* vector can only be 12-bits or boundary will be exceeded */
 234         vector &= 0xFFF;
 235         return vector;
 236 }
 237
 238 /**
 239  *  ixgbevf_get_mac_addr_vf - Read device MAC address
 240  *  @hw: pointer to the HW structure
 241  *  @mac_addr: pointer to storage for retrieved MAC address
 242  **/
 243 static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr)
 244 {
 245         ether_addr_copy(mac_addr, hw->mac.perm_addr);
 246
 247         return 0;
 248 }
 249
 250 static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr)
 251 {
 252         u32 msgbuf[3], msgbuf_chk;
 253         u8 *msg_addr = (u8 *)(&msgbuf[1]);
 254         s32 ret_val;
 255
 256         memset(msgbuf, 0, sizeof(msgbuf));
 257         /* If index is one then this is the start of a new list and needs
 258          * indication to the PF so it can do it's own list management.
 259          * If it is zero then that tells the PF to just clear all of
 260          * this VF's macvlans and there is no new list.
 261          */
 262         msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT;
 263         msgbuf[0] |= IXGBE_VF_SET_MACVLAN;
 264         msgbuf_chk = msgbuf[0];
 265
 266         if (addr)
 267                 ether_addr_copy(msg_addr, addr);
 268
 269         ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 270                                              ARRAY_SIZE(msgbuf));
 271         if (!ret_val) {
 272                 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 273
 274                 if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_FAILURE))
 275                         return -ENOMEM;
 276         }
 277
 278         return ret_val;
 279 }
 280
 281 static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr)
 282 {
 283         return -EOPNOTSUPP;
 284 }
 285
 286 /**
 287  * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents.
 288  * @hw: pointer to hardware structure
 289  * @reta: buffer to fill with RETA contents.
 290  * @num_rx_queues: Number of Rx queues configured for this port
 291  *
 292  * The "reta" buffer should be big enough to contain 32 registers.
 293  *
 294  * Returns: 0 on success.
 295  *          if API doesn't support this operation - (-EOPNOTSUPP).
 296  */
 297 int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues)
 298 {
 299         int err, i, j;
 300         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
 301         u32 *hw_reta = &msgbuf[1];
 302         u32 mask = 0;
 303
 304         /* We have to use a mailbox for 82599 and x540 devices only.
 305          * For these devices RETA has 128 entries.
 306          * Also these VFs support up to 4 RSS queues. Therefore PF will compress
 307          * 16 RETA entries in each DWORD giving 2 bits to each entry.
 308          */
 309         int dwords = IXGBEVF_82599_RETA_SIZE / 16;
 310
 311         /* We support the RSS querying for 82599 and x540 devices only.
 312          * Thus return an error if API doesn't support RETA querying or querying
 313          * is not supported for this device type.
 314          */
 315         switch (hw->api_version) {
 316         case ixgbe_mbox_api_15:
 317         case ixgbe_mbox_api_14:
 318         case ixgbe_mbox_api_13:
 319         case ixgbe_mbox_api_12:
 320                 if (hw->mac.type < ixgbe_mac_X550_vf)
 321                         break;
 322                 fallthrough;
 323         default:
 324                 return -EOPNOTSUPP;
 325         }
 326
 327         msgbuf[0] = IXGBE_VF_GET_RETA;
 328
 329         err = ixgbevf_write_mbx(hw, msgbuf, 1);
 330
 331         if (err)
 332                 return err;
 333
 334         err = ixgbevf_poll_mbx(hw, msgbuf, dwords + 1);
 335
 336         if (err)
 337                 return err;
 338
 339         msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 340
 341         /* If the operation has been refused by a PF return -EPERM */
 342         if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_FAILURE))
 343                 return -EPERM;
 344
 345         /* If we didn't get an ACK there must have been
 346          * some sort of mailbox error so we should treat it
 347          * as such.
 348          */
 349         if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_SUCCESS))
 350                 return IXGBE_ERR_MBX;
 351
 352         /* ixgbevf doesn't support more than 2 queues at the moment */
 353         if (num_rx_queues > 1)
 354                 mask = 0x1;
 355
 356         for (i = 0; i < dwords; i++)
 357                 for (j = 0; j < 16; j++)
 358                         reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask;
 359
 360         return 0;
 361 }
 362
 363 /**
 364  * ixgbevf_get_rss_key_locked - get the RSS Random Key
 365  * @hw: pointer to the HW structure
 366  * @rss_key: buffer to fill with RSS Hash Key contents.
 367  *
 368  * The "rss_key" buffer should be big enough to contain 10 registers.
 369  *
 370  * Returns: 0 on success.
 371  *          if API doesn't support this operation - (-EOPNOTSUPP).
 372  */
 373 int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key)
 374 {
 375         int err;
 376         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
 377
 378         /* We currently support the RSS Random Key retrieval for 82599 and x540
 379          * devices only.
 380          *
 381          * Thus return an error if API doesn't support RSS Random Key retrieval
 382          * or if the operation is not supported for this device type.
 383          */
 384         switch (hw->api_version) {
 385         case ixgbe_mbox_api_15:
 386         case ixgbe_mbox_api_14:
 387         case ixgbe_mbox_api_13:
 388         case ixgbe_mbox_api_12:
 389                 if (hw->mac.type < ixgbe_mac_X550_vf)
 390                         break;
 391                 fallthrough;
 392         default:
 393                 return -EOPNOTSUPP;
 394         }
 395
 396         msgbuf[0] = IXGBE_VF_GET_RSS_KEY;
 397         err = ixgbevf_write_mbx(hw, msgbuf, 1);
 398
 399         if (err)
 400                 return err;
 401
 402         err = ixgbevf_poll_mbx(hw, msgbuf, 11);
 403
 404         if (err)
 405                 return err;
 406
 407         msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 408
 409         /* If the operation has been refused by a PF return -EPERM */
 410         if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_FAILURE))
 411                 return -EPERM;
 412
 413         /* If we didn't get an ACK there must have been
 414          * some sort of mailbox error so we should treat it
 415          * as such.
 416          */
 417         if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_SUCCESS))
 418                 return IXGBE_ERR_MBX;
 419
 420         memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE);
 421
 422         return 0;
 423 }
 424
 425 /**
 426  *  ixgbevf_set_rar_vf - set device MAC address
 427  *  @hw: pointer to hardware structure
 428  *  @index: Receive address register to write
 429  *  @addr: Address to put into receive address register
 430  *  @vmdq: Unused in this implementation
 431  **/
 432 static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
 433                               u32 vmdq)
 434 {
 435         u32 msgbuf[3];
 436         u8 *msg_addr = (u8 *)(&msgbuf[1]);
 437         s32 ret_val;
 438
 439         memset(msgbuf, 0, sizeof(msgbuf));
 440         msgbuf[0] = IXGBE_VF_SET_MAC_ADDR;
 441         ether_addr_copy(msg_addr, addr);
 442
 443         ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 444                                              ARRAY_SIZE(msgbuf));
 445         msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 446
 447         /* if nacked the address was rejected, use "perm_addr" */
 448         if (!ret_val &&
 449             (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_FAILURE))) {
 450                 ixgbevf_get_mac_addr_vf(hw, hw->mac.addr);
 451                 return IXGBE_ERR_MBX;
 452         }
 453
 454         return ret_val;
 455 }
 456
 457 /**
 458  *  ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant
 459  *  @hw: pointer to hardware structure
 460  *  @index: Receive address register to write
 461  *  @addr: Address to put into receive address register
 462  *  @vmdq: Unused in this implementation
 463  *
 464  * We don't really allow setting the device MAC address. However,
 465  * if the address being set is the permanent MAC address we will
 466  * permit that.
 467  **/
 468 static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
 469                                  u32 vmdq)
 470 {
 471         if (ether_addr_equal(addr, hw->mac.perm_addr))
 472                 return 0;
 473
 474         return -EOPNOTSUPP;
 475 }
 476
 477 /**
 478  *  ixgbevf_update_mc_addr_list_vf - Update Multicast addresses
 479  *  @hw: pointer to the HW structure
 480  *  @netdev: pointer to net device structure
 481  *
 482  *  Updates the Multicast Table Array.
 483  **/
 484 static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw,
 485                                           struct net_device *netdev)
 486 {
 487         struct netdev_hw_addr *ha;
 488         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
 489         u16 *vector_list = (u16 *)&msgbuf[1];
 490         u32 cnt, i;
 491
 492         /* Each entry in the list uses 1 16 bit word.  We have 30
 493          * 16 bit words available in our HW msg buffer (minus 1 for the
 494          * msg type).  That's 30 hash values if we pack 'em right.  If
 495          * there are more than 30 MC addresses to add then punt the
 496          * extras for now and then add code to handle more than 30 later.
 497          * It would be unusual for a server to request that many multi-cast
 498          * addresses except for in large enterprise network environments.
 499          */
 500
 501         cnt = netdev_mc_count(netdev);
 502         if (cnt > 30)
 503                 cnt = 30;
 504         msgbuf[0] = IXGBE_VF_SET_MULTICAST;
 505         msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT;
 506
 507         i = 0;
 508         netdev_for_each_mc_addr(ha, netdev) {
 509                 if (i == cnt)
 510                         break;
 511                 if (is_link_local_ether_addr(ha->addr))
 512                         continue;
 513
 514                 vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr);
 515         }
 516
 517         return ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 518                         IXGBE_VFMAILBOX_SIZE);
 519 }
 520
 521 /**
 522  * ixgbevf_hv_update_mc_addr_list_vf - stub
 523  * @hw: unused
 524  * @netdev: unused
 525  *
 526  * Hyper-V variant - just a stub.
 527  */
 528 static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw,
 529                                              struct net_device *netdev)
 530 {
 531         return -EOPNOTSUPP;
 532 }
 533
 534 /**
 535  *  ixgbevf_update_xcast_mode - Update Multicast mode
 536  *  @hw: pointer to the HW structure
 537  *  @xcast_mode: new multicast mode
 538  *
 539  *  Updates the Multicast Mode of VF.
 540  **/
 541 static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode)
 542 {
 543         u32 msgbuf[2];
 544         s32 err;
 545
 546         switch (hw->api_version) {
 547         case ixgbe_mbox_api_12:
 548                 /* promisc introduced in 1.3 version */
 549                 if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC)
 550                         return -EOPNOTSUPP;
 551                 fallthrough;
 552         case ixgbe_mbox_api_13:
 553         case ixgbe_mbox_api_14:
 554         case ixgbe_mbox_api_15:
 555                 break;
 556         default:
 557                 return -EOPNOTSUPP;
 558         }
 559
 560         msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE;
 561         msgbuf[1] = xcast_mode;
 562
 563         err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 564                                          ARRAY_SIZE(msgbuf));
 565         if (err)
 566                 return err;
 567
 568         msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 569         if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_FAILURE))
 570                 return -EPERM;
 571
 572         return 0;
 573 }
 574
 575 /**
 576  * ixgbevf_hv_update_xcast_mode - stub
 577  * @hw: unused
 578  * @xcast_mode: unused
 579  *
 580  * Hyper-V variant - just a stub.
 581  */
 582 static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode)
 583 {
 584         return -EOPNOTSUPP;
 585 }
 586
 587 /**
 588  * ixgbevf_get_link_state_vf - Get VF link state from PF
 589  * @hw: pointer to the HW structure
 590  * @link_state: link state storage
 591  *
 592  * Returns state of the operation error or success.
 593  */
 594 static s32 ixgbevf_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state)
 595 {
 596         u32 msgbuf[2];
 597         s32 ret_val;
 598         s32 err;
 599
 600         msgbuf[0] = IXGBE_VF_GET_LINK_STATE;
 601         msgbuf[1] = 0x0;
 602
 603         err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 2);
 604
 605         if (err || (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE)) {
 606                 ret_val = IXGBE_ERR_MBX;
 607         } else {
 608                 ret_val = 0;
 609                 *link_state = msgbuf[1];
 610         }
 611
 612         return ret_val;
 613 }
 614
 615 /**
 616  * ixgbevf_hv_get_link_state_vf - * Hyper-V variant - just a stub.
 617  * @hw: unused
 618  * @link_state: unused
 619  *
 620  * Hyper-V variant; there is no mailbox communication.
 621  */
 622 static s32 ixgbevf_hv_get_link_state_vf(struct ixgbe_hw *hw, bool *link_state)
 623 {
 624         return -EOPNOTSUPP;
 625 }
 626
 627 /**
 628  *  ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address
 629  *  @hw: pointer to the HW structure
 630  *  @vlan: 12 bit VLAN ID
 631  *  @vind: unused by VF drivers
 632  *  @vlan_on: if true then set bit, else clear bit
 633  **/
 634 static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind,
 635                                bool vlan_on)
 636 {
 637         u32 msgbuf[2];
 638         s32 err;
 639
 640         msgbuf[0] = IXGBE_VF_SET_VLAN;
 641         msgbuf[1] = vlan;
 642         /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */
 643         msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT;
 644
 645         err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 646                                          ARRAY_SIZE(msgbuf));
 647         if (err)
 648                 goto mbx_err;
 649
 650         /* remove extra bits from the message */
 651         msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 652         msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT);
 653
 654         if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_SUCCESS))
 655                 err = IXGBE_ERR_INVALID_ARGUMENT;
 656
 657 mbx_err:
 658         return err;
 659 }
 660
 661 /**
 662  * ixgbevf_hv_set_vfta_vf - * Hyper-V variant - just a stub.
 663  * @hw: unused
 664  * @vlan: unused
 665  * @vind: unused
 666  * @vlan_on: unused
 667  */
 668 static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind,
 669                                   bool vlan_on)
 670 {
 671         return -EOPNOTSUPP;
 672 }
 673
 674 /**
 675  *  ixgbevf_setup_mac_link_vf - Setup MAC link settings
 676  *  @hw: pointer to hardware structure
 677  *  @speed: Unused in this implementation
 678  *  @autoneg: Unused in this implementation
 679  *  @autoneg_wait_to_complete: Unused in this implementation
 680  *
 681  *  Do nothing and return success.  VF drivers are not allowed to change
 682  *  global settings.  Maintained for driver compatibility.
 683  **/
 684 static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw,
 685                                      ixgbe_link_speed speed, bool autoneg,
 686                                      bool autoneg_wait_to_complete)
 687 {
 688         return 0;
 689 }
 690
 691 /**
 692  *  ixgbevf_check_mac_link_vf - Get link/speed status
 693  *  @hw: pointer to hardware structure
 694  *  @speed: pointer to link speed
 695  *  @link_up: true is link is up, false otherwise
 696  *  @autoneg_wait_to_complete: unused
 697  *
 698  *  Reads the links register to determine if link is up and the current speed
 699  **/
 700 static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw,
 701                                      ixgbe_link_speed *speed,
 702                                      bool *link_up,
 703                                      bool autoneg_wait_to_complete)
 704 {
 705         struct ixgbe_mbx_info *mbx = &hw->mbx;
 706         struct ixgbe_mac_info *mac = &hw->mac;
 707         s32 ret_val = 0;
 708         u32 links_reg;
 709         u32 in_msg = 0;
 710
 711         /* If we were hit with a reset drop the link */
 712         if (!mbx->ops.check_for_rst(hw) || !mbx->timeout)
 713                 mac->get_link_status = true;
 714
 715         if (!mac->get_link_status)
 716                 goto out;
 717
 718         /* if link status is down no point in checking to see if pf is up */
 719         links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 720         if (!(links_reg & IXGBE_LINKS_UP))
 721                 goto out;
 722
 723         /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs
 724          * before the link status is correct
 725          */
 726         if (mac->type == ixgbe_mac_82599_vf) {
 727                 int i;
 728
 729                 for (i = 0; i < 5; i++) {
 730                         udelay(100);
 731                         links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 732
 733                         if (!(links_reg & IXGBE_LINKS_UP))
 734                                 goto out;
 735                 }
 736         }
 737
 738         switch (links_reg & IXGBE_LINKS_SPEED_82599) {
 739         case IXGBE_LINKS_SPEED_10G_82599:
 740                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 741                 break;
 742         case IXGBE_LINKS_SPEED_1G_82599:
 743                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 744                 break;
 745         case IXGBE_LINKS_SPEED_100_82599:
 746                 *speed = IXGBE_LINK_SPEED_100_FULL;
 747                 break;
 748         }
 749
 750         /* if the read failed it could just be a mailbox collision, best wait
 751          * until we are called again and don't report an error
 752          */
 753         if (mbx->ops.read(hw, &in_msg, 1)) {
 754                 if (hw->api_version >= ixgbe_mbox_api_15)
 755                         mac->get_link_status = false;
 756                 goto out;
 757         }
 758
 759         if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) {
 760                 /* msg is not CTS and is NACK we must have lost CTS status */
 761                 if (in_msg & IXGBE_VT_MSGTYPE_FAILURE)
 762                         ret_val = -1;
 763                 goto out;
 764         }
 765
 766         /* the pf is talking, if we timed out in the past we reinit */
 767         if (!mbx->timeout) {
 768                 ret_val = -1;
 769                 goto out;
 770         }
 771
 772         /* if we passed all the tests above then the link is up and we no
 773          * longer need to check for link
 774          */
 775         mac->get_link_status = false;
 776
 777 out:
 778         *link_up = !mac->get_link_status;
 779         return ret_val;
 780 }
 781
 782 /**
 783  * ixgbevf_hv_check_mac_link_vf - check link
 784  * @hw: pointer to private hardware struct
 785  * @speed: pointer to link speed
 786  * @link_up: true is link is up, false otherwise
 787  * @autoneg_wait_to_complete: unused
 788  *
 789  * Hyper-V variant; there is no mailbox communication.
 790  */
 791 static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw,
 792                                         ixgbe_link_speed *speed,
 793                                         bool *link_up,
 794                                         bool autoneg_wait_to_complete)
 795 {
 796         struct ixgbe_mbx_info *mbx = &hw->mbx;
 797         struct ixgbe_mac_info *mac = &hw->mac;
 798         u32 links_reg;
 799
 800         /* If we were hit with a reset drop the link */
 801         if (!mbx->ops.check_for_rst(hw) || !mbx->timeout)
 802                 mac->get_link_status = true;
 803
 804         if (!mac->get_link_status)
 805                 goto out;
 806
 807         /* if link status is down no point in checking to see if pf is up */
 808         links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 809         if (!(links_reg & IXGBE_LINKS_UP))
 810                 goto out;
 811
 812         /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs
 813          * before the link status is correct
 814          */
 815         if (mac->type == ixgbe_mac_82599_vf) {
 816                 int i;
 817
 818                 for (i = 0; i < 5; i++) {
 819                         udelay(100);
 820                         links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 821
 822                         if (!(links_reg & IXGBE_LINKS_UP))
 823                                 goto out;
 824                 }
 825         }
 826
 827         switch (links_reg & IXGBE_LINKS_SPEED_82599) {
 828         case IXGBE_LINKS_SPEED_10G_82599:
 829                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 830                 break;
 831         case IXGBE_LINKS_SPEED_1G_82599:
 832                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 833                 break;
 834         case IXGBE_LINKS_SPEED_100_82599:
 835                 *speed = IXGBE_LINK_SPEED_100_FULL;
 836                 break;
 837         }
 838
 839         /* if we passed all the tests above then the link is up and we no
 840          * longer need to check for link
 841          */
 842         mac->get_link_status = false;
 843
 844 out:
 845         *link_up = !mac->get_link_status;
 846         return 0;
 847 }
 848
 849 /**
 850  *  ixgbevf_set_rlpml_vf - Set the maximum receive packet length
 851  *  @hw: pointer to the HW structure
 852  *  @max_size: value to assign to max frame size
 853  **/
 854 static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size)
 855 {
 856         u32 msgbuf[2];
 857         s32 ret_val;
 858
 859         msgbuf[0] = IXGBE_VF_SET_LPE;
 860         msgbuf[1] = max_size;
 861
 862         ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf,
 863                                              ARRAY_SIZE(msgbuf));
 864         if (ret_val)
 865                 return ret_val;
 866         if ((msgbuf[0] & IXGBE_VF_SET_LPE) &&
 867             (msgbuf[0] & IXGBE_VT_MSGTYPE_FAILURE))
 868                 return IXGBE_ERR_MBX;
 869
 870         return 0;
 871 }
 872
 873 /**
 874  * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length
 875  * @hw: pointer to the HW structure
 876  * @max_size: value to assign to max frame size
 877  * Hyper-V variant.
 878  **/
 879 static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size)
 880 {
 881         u32 reg;
 882
 883         /* If we are on Hyper-V, we implement this functionality
 884          * differently.
 885          */
 886         reg =  IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0));
 887         /* CRC == 4 */
 888         reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN);
 889         IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg);
 890
 891         return 0;
 892 }
 893
 894 /**
 895  *  ixgbevf_negotiate_api_version_vf - Negotiate supported API version
 896  *  @hw: pointer to the HW structure
 897  *  @api: integer containing requested API version
 898  **/
 899 static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api)
 900 {
 901         int err;
 902         u32 msg[3];
 903
 904         /* Negotiate the mailbox API version */
 905         msg[0] = IXGBE_VF_API_NEGOTIATE;
 906         msg[1] = api;
 907         msg[2] = 0;
 908
 909         err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg));
 910         if (!err) {
 911                 msg[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 912
 913                 /* Store value and return 0 on success */
 914                 if (msg[0] == (IXGBE_VF_API_NEGOTIATE |
 915                               IXGBE_VT_MSGTYPE_SUCCESS)) {
 916                         hw->api_version = api;
 917                         return 0;
 918                 }
 919
 920                 err = IXGBE_ERR_INVALID_ARGUMENT;
 921         }
 922
 923         return err;
 924 }
 925
 926 /**
 927  *  ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version
 928  *  @hw: pointer to the HW structure
 929  *  @api: integer containing requested API version
 930  *  Hyper-V version - only ixgbe_mbox_api_10 supported.
 931  **/
 932 static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api)
 933 {
 934         /* Hyper-V only supports api version ixgbe_mbox_api_10 */
 935         if (api != ixgbe_mbox_api_10)
 936                 return IXGBE_ERR_INVALID_ARGUMENT;
 937
 938         return 0;
 939 }
 940
 941 int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs,
 942                        unsigned int *default_tc)
 943 {
 944         int err;
 945         u32 msg[5];
 946
 947         /* do nothing if API doesn't support ixgbevf_get_queues */
 948         switch (hw->api_version) {
 949         case ixgbe_mbox_api_11:
 950         case ixgbe_mbox_api_12:
 951         case ixgbe_mbox_api_13:
 952         case ixgbe_mbox_api_14:
 953         case ixgbe_mbox_api_15:
 954                 break;
 955         default:
 956                 return 0;
 957         }
 958
 959         /* Fetch queue configuration from the PF */
 960         msg[0] = IXGBE_VF_GET_QUEUE;
 961         msg[1] = msg[2] = msg[3] = msg[4] = 0;
 962
 963         err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg));
 964         if (!err) {
 965                 msg[0] &= ~IXGBE_VT_MSGTYPE_CTS;
 966
 967                 /* if we didn't get an ACK there must have been
 968                  * some sort of mailbox error so we should treat it
 969                  * as such
 970                  */
 971                 if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_SUCCESS))
 972                         return IXGBE_ERR_MBX;
 973
 974                 /* record and validate values from message */
 975                 hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES];
 976                 if (hw->mac.max_tx_queues == 0 ||
 977                     hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES)
 978                         hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES;
 979
 980                 hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES];
 981                 if (hw->mac.max_rx_queues == 0 ||
 982                     hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES)
 983                         hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES;
 984
 985                 *num_tcs = msg[IXGBE_VF_TRANS_VLAN];
 986                 /* in case of unknown state assume we cannot tag frames */
 987                 if (*num_tcs > hw->mac.max_rx_queues)
 988                         *num_tcs = 1;
 989
 990                 *default_tc = msg[IXGBE_VF_DEF_QUEUE];
 991                 /* default to queue 0 on out-of-bounds queue number */
 992                 if (*default_tc >= hw->mac.max_tx_queues)
 993                         *default_tc = 0;
 994         }
 995
 996         return err;
 997 }
 998
 999 static const struct ixgbe_mac_operations ixgbevf_mac_ops = {
1000         .init_hw                = ixgbevf_init_hw_vf,
1001         .reset_hw               = ixgbevf_reset_hw_vf,
1002         .start_hw               = ixgbevf_start_hw_vf,
1003         .get_mac_addr           = ixgbevf_get_mac_addr_vf,
1004         .stop_adapter           = ixgbevf_stop_hw_vf,
1005         .setup_link             = ixgbevf_setup_mac_link_vf,
1006         .check_link             = ixgbevf_check_mac_link_vf,
1007         .negotiate_api_version  = ixgbevf_negotiate_api_version_vf,
1008         .set_rar                = ixgbevf_set_rar_vf,
1009         .update_mc_addr_list    = ixgbevf_update_mc_addr_list_vf,
1010         .update_xcast_mode      = ixgbevf_update_xcast_mode,
1011         .get_link_state         = ixgbevf_get_link_state_vf,
1012         .set_uc_addr            = ixgbevf_set_uc_addr_vf,
1013         .set_vfta               = ixgbevf_set_vfta_vf,
1014         .set_rlpml              = ixgbevf_set_rlpml_vf,
1015 };
1016
1017 static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = {
1018         .init_hw                = ixgbevf_init_hw_vf,
1019         .reset_hw               = ixgbevf_hv_reset_hw_vf,
1020         .start_hw               = ixgbevf_start_hw_vf,
1021         .get_mac_addr           = ixgbevf_get_mac_addr_vf,
1022         .stop_adapter           = ixgbevf_stop_hw_vf,
1023         .setup_link             = ixgbevf_setup_mac_link_vf,
1024         .check_link             = ixgbevf_hv_check_mac_link_vf,
1025         .negotiate_api_version  = ixgbevf_hv_negotiate_api_version_vf,
1026         .set_rar                = ixgbevf_hv_set_rar_vf,
1027         .update_mc_addr_list    = ixgbevf_hv_update_mc_addr_list_vf,
1028         .update_xcast_mode      = ixgbevf_hv_update_xcast_mode,
1029         .get_link_state         = ixgbevf_hv_get_link_state_vf,
1030         .set_uc_addr            = ixgbevf_hv_set_uc_addr_vf,
1031         .set_vfta               = ixgbevf_hv_set_vfta_vf,
1032         .set_rlpml              = ixgbevf_hv_set_rlpml_vf,
1033 };
1034
1035 const struct ixgbevf_info ixgbevf_82599_vf_info = {
1036         .mac = ixgbe_mac_82599_vf,
1037         .mac_ops = &ixgbevf_mac_ops,
1038 };
1039
1040 const struct ixgbevf_info ixgbevf_82599_vf_hv_info = {
1041         .mac = ixgbe_mac_82599_vf,
1042         .mac_ops = &ixgbevf_hv_mac_ops,
1043 };
1044
1045 const struct ixgbevf_info ixgbevf_X540_vf_info = {
1046         .mac = ixgbe_mac_X540_vf,
1047         .mac_ops = &ixgbevf_mac_ops,
1048 };
1049
1050 const struct ixgbevf_info ixgbevf_X540_vf_hv_info = {
1051         .mac = ixgbe_mac_X540_vf,
1052         .mac_ops = &ixgbevf_hv_mac_ops,
1053 };
1054
1055 const struct ixgbevf_info ixgbevf_X550_vf_info = {
1056         .mac = ixgbe_mac_X550_vf,
1057         .mac_ops = &ixgbevf_mac_ops,
1058 };
1059
1060 const struct ixgbevf_info ixgbevf_X550_vf_hv_info = {
1061         .mac = ixgbe_mac_X550_vf,
1062         .mac_ops = &ixgbevf_hv_mac_ops,
1063 };
1064
1065 const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = {
1066         .mac = ixgbe_mac_X550EM_x_vf,
1067         .mac_ops = &ixgbevf_mac_ops,
1068 };
1069
1070 const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = {
1071         .mac = ixgbe_mac_X550EM_x_vf,
1072         .mac_ops = &ixgbevf_hv_mac_ops,
1073 };
1074
1075 const struct ixgbevf_info ixgbevf_x550em_a_vf_info = {
1076         .mac = ixgbe_mac_x550em_a_vf,
1077         .mac_ops = &ixgbevf_mac_ops,
1078 };