drivers/net/fm10k/base/fm10k_pf.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2013 - 2015, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 #include "fm10k_pf.h"
  35 #include "fm10k_vf.h"
  36
  37 /**
  38  *  fm10k_reset_hw_pf - PF hardware reset
  39  *  @hw: pointer to hardware structure
  40  *
  41  *  This function should return the hardware to a state similar to the
  42  *  one it is in after being powered on.
  43  **/
  44 STATIC s32 fm10k_reset_hw_pf(struct fm10k_hw *hw)
  45 {
  46         s32 err;
  47         u32 reg;
  48         u16 i;
  49
  50         DEBUGFUNC("fm10k_reset_hw_pf");
  51
  52         /* Disable interrupts */
  53         FM10K_WRITE_REG(hw, FM10K_EIMR, FM10K_EIMR_DISABLE(ALL));
  54
  55         /* Lock ITR2 reg 0 into itself and disable interrupt moderation */
  56         FM10K_WRITE_REG(hw, FM10K_ITR2(0), 0);
  57         FM10K_WRITE_REG(hw, FM10K_INT_CTRL, 0);
  58
  59         /* We assume here Tx and Rx queue 0 are owned by the PF */
  60
  61         /* Shut off VF access to their queues forcing them to queue 0 */
  62         for (i = 0; i < FM10K_TQMAP_TABLE_SIZE; i++) {
  63                 FM10K_WRITE_REG(hw, FM10K_TQMAP(i), 0);
  64                 FM10K_WRITE_REG(hw, FM10K_RQMAP(i), 0);
  65         }
  66
  67         /* shut down all rings */
  68         err = fm10k_disable_queues_generic(hw, FM10K_MAX_QUEUES);
  69         if (err == FM10K_ERR_REQUESTS_PENDING) {
  70                 hw->mac.reset_while_pending++;
  71                 goto force_reset;
  72         } else if (err) {
  73                 return err;
  74         }
  75
  76         /* Verify that DMA is no longer active */
  77         reg = FM10K_READ_REG(hw, FM10K_DMA_CTRL);
  78         if (reg & (FM10K_DMA_CTRL_TX_ACTIVE | FM10K_DMA_CTRL_RX_ACTIVE))
  79                 return FM10K_ERR_DMA_PENDING;
  80
  81 force_reset:
  82         /* Inititate data path reset */
  83         reg = FM10K_DMA_CTRL_DATAPATH_RESET;
  84         FM10K_WRITE_REG(hw, FM10K_DMA_CTRL, reg);
  85
  86         /* Flush write and allow 100us for reset to complete */
  87         FM10K_WRITE_FLUSH(hw);
  88         usec_delay(FM10K_RESET_TIMEOUT);
  89
  90         /* Verify we made it out of reset */
  91         reg = FM10K_READ_REG(hw, FM10K_IP);
  92         if (!(reg & FM10K_IP_NOTINRESET))
  93                 return FM10K_ERR_RESET_FAILED;
  94
  95         return FM10K_SUCCESS;
  96 }
  97
  98 /**
  99  *  fm10k_is_ari_hierarchy_pf - Indicate ARI hierarchy support
 100  *  @hw: pointer to hardware structure
 101  *
 102  *  Looks at the ARI hierarchy bit to determine whether ARI is supported or not.
 103  **/
 104 STATIC bool fm10k_is_ari_hierarchy_pf(struct fm10k_hw *hw)
 105 {
 106         u16 sriov_ctrl = FM10K_READ_PCI_WORD(hw, FM10K_PCIE_SRIOV_CTRL);
 107
 108         DEBUGFUNC("fm10k_is_ari_hierarchy_pf");
 109
 110         return !!(sriov_ctrl & FM10K_PCIE_SRIOV_CTRL_VFARI);
 111 }
 112
 113 /**
 114  *  fm10k_init_hw_pf - PF hardware initialization
 115  *  @hw: pointer to hardware structure
 116  *
 117  **/
 118 STATIC s32 fm10k_init_hw_pf(struct fm10k_hw *hw)
 119 {
 120         u32 dma_ctrl, txqctl;
 121         u16 i;
 122
 123         DEBUGFUNC("fm10k_init_hw_pf");
 124
 125         /* Establish default VSI as valid */
 126         FM10K_WRITE_REG(hw, FM10K_DGLORTDEC(fm10k_dglort_default), 0);
 127         FM10K_WRITE_REG(hw, FM10K_DGLORTMAP(fm10k_dglort_default),
 128                         FM10K_DGLORTMAP_ANY);
 129
 130         /* Invalidate all other GLORT entries */
 131         for (i = 1; i < FM10K_DGLORT_COUNT; i++)
 132                 FM10K_WRITE_REG(hw, FM10K_DGLORTMAP(i), FM10K_DGLORTMAP_NONE);
 133
 134         /* reset ITR2(0) to point to itself */
 135         FM10K_WRITE_REG(hw, FM10K_ITR2(0), 0);
 136
 137         /* reset VF ITR2(0) to point to 0 avoid PF registers */
 138         FM10K_WRITE_REG(hw, FM10K_ITR2(FM10K_ITR_REG_COUNT_PF), 0);
 139
 140         /* loop through all PF ITR2 registers pointing them to the previous */
 141         for (i = 1; i < FM10K_ITR_REG_COUNT_PF; i++)
 142                 FM10K_WRITE_REG(hw, FM10K_ITR2(i), i - 1);
 143
 144         /* Enable interrupt moderator if not already enabled */
 145         FM10K_WRITE_REG(hw, FM10K_INT_CTRL, FM10K_INT_CTRL_ENABLEMODERATOR);
 146
 147         /* compute the default txqctl configuration */
 148         txqctl = FM10K_TXQCTL_PF | FM10K_TXQCTL_UNLIMITED_BW |
 149                  (hw->mac.default_vid << FM10K_TXQCTL_VID_SHIFT);
 150
 151         for (i = 0; i < FM10K_MAX_QUEUES; i++) {
 152                 /* configure rings for 256 Queue / 32 Descriptor cache mode */
 153                 FM10K_WRITE_REG(hw, FM10K_TQDLOC(i),
 154                                 (i * FM10K_TQDLOC_BASE_32_DESC) |
 155                                 FM10K_TQDLOC_SIZE_32_DESC);
 156                 FM10K_WRITE_REG(hw, FM10K_TXQCTL(i), txqctl);
 157
 158                 /* configure rings to provide TPH processing hints */
 159                 FM10K_WRITE_REG(hw, FM10K_TPH_TXCTRL(i),
 160                                 FM10K_TPH_TXCTRL_DESC_TPHEN |
 161                                 FM10K_TPH_TXCTRL_DESC_RROEN |
 162                                 FM10K_TPH_TXCTRL_DESC_WROEN |
 163                                 FM10K_TPH_TXCTRL_DATA_RROEN);
 164                 FM10K_WRITE_REG(hw, FM10K_TPH_RXCTRL(i),
 165                                 FM10K_TPH_RXCTRL_DESC_TPHEN |
 166                                 FM10K_TPH_RXCTRL_DESC_RROEN |
 167                                 FM10K_TPH_RXCTRL_DATA_WROEN |
 168                                 FM10K_TPH_RXCTRL_HDR_WROEN);
 169         }
 170
 171         /* set max hold interval to align with 1.024 usec in all modes and
 172          * store ITR scale
 173          */
 174         switch (hw->bus.speed) {
 175         case fm10k_bus_speed_2500:
 176                 dma_ctrl = FM10K_DMA_CTRL_MAX_HOLD_1US_GEN1;
 177                 hw->mac.itr_scale = FM10K_TDLEN_ITR_SCALE_GEN1;
 178                 break;
 179         case fm10k_bus_speed_5000:
 180                 dma_ctrl = FM10K_DMA_CTRL_MAX_HOLD_1US_GEN2;
 181                 hw->mac.itr_scale = FM10K_TDLEN_ITR_SCALE_GEN2;
 182                 break;
 183         case fm10k_bus_speed_8000:
 184                 dma_ctrl = FM10K_DMA_CTRL_MAX_HOLD_1US_GEN3;
 185                 hw->mac.itr_scale = FM10K_TDLEN_ITR_SCALE_GEN3;
 186                 break;
 187         default:
 188                 dma_ctrl = 0;
 189                 /* just in case, assume Gen3 ITR scale */
 190                 hw->mac.itr_scale = FM10K_TDLEN_ITR_SCALE_GEN3;
 191                 break;
 192         }
 193
 194         /* Configure TSO flags */
 195         FM10K_WRITE_REG(hw, FM10K_DTXTCPFLGL, FM10K_TSO_FLAGS_LOW);
 196         FM10K_WRITE_REG(hw, FM10K_DTXTCPFLGH, FM10K_TSO_FLAGS_HI);
 197
 198         /* Enable DMA engine
 199          * Set Rx Descriptor size to 32
 200          * Set Minimum MSS to 64
 201          * Set Maximum number of Rx queues to 256 / 32 Descriptor
 202          */
 203         dma_ctrl |= FM10K_DMA_CTRL_TX_ENABLE | FM10K_DMA_CTRL_RX_ENABLE |
 204                     FM10K_DMA_CTRL_RX_DESC_SIZE | FM10K_DMA_CTRL_MINMSS_64 |
 205                     FM10K_DMA_CTRL_32_DESC;
 206
 207         FM10K_WRITE_REG(hw, FM10K_DMA_CTRL, dma_ctrl);
 208
 209         /* record maximum queue count, we limit ourselves to 128 */
 210         hw->mac.max_queues = FM10K_MAX_QUEUES_PF;
 211
 212         /* We support either 64 VFs or 7 VFs depending on if we have ARI */
 213         hw->iov.total_vfs = fm10k_is_ari_hierarchy_pf(hw) ? 64 : 7;
 214
 215         return FM10K_SUCCESS;
 216 }
 217
 218 #ifndef NO_IS_SLOT_APPROPRIATE_CHECK
 219 /**
 220  *  fm10k_is_slot_appropriate_pf - Indicate appropriate slot for this SKU
 221  *  @hw: pointer to hardware structure
 222  *
 223  *  Looks at the PCIe bus info to confirm whether or not this slot can support
 224  *  the necessary bandwidth for this device.
 225  **/
 226 STATIC bool fm10k_is_slot_appropriate_pf(struct fm10k_hw *hw)
 227 {
 228         DEBUGFUNC("fm10k_is_slot_appropriate_pf");
 229
 230         return (hw->bus.speed == hw->bus_caps.speed) &&
 231                (hw->bus.width == hw->bus_caps.width);
 232 }
 233
 234 #endif
 235 /**
 236  *  fm10k_update_vlan_pf - Update status of VLAN ID in VLAN filter table
 237  *  @hw: pointer to hardware structure
 238  *  @vid: VLAN ID to add to table
 239  *  @vsi: Index indicating VF ID or PF ID in table
 240  *  @set: Indicates if this is a set or clear operation
 241  *
 242  *  This function adds or removes the corresponding VLAN ID from the VLAN
 243  *  filter table for the corresponding function.  In addition to the
 244  *  standard set/clear that supports one bit a multi-bit write is
 245  *  supported to set 64 bits at a time.
 246  **/
 247 STATIC s32 fm10k_update_vlan_pf(struct fm10k_hw *hw, u32 vid, u8 vsi, bool set)
 248 {
 249         u32 vlan_table, reg, mask, bit, len;
 250
 251         /* verify the VSI index is valid */
 252         if (vsi > FM10K_VLAN_TABLE_VSI_MAX)
 253                 return FM10K_ERR_PARAM;
 254
 255         /* VLAN multi-bit write:
 256          * The multi-bit write has several parts to it.
 257          *               24              16               8               0
 258          *  7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
 259          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 260          * | RSVD0 |         Length        |C|RSVD0|        VLAN ID        |
 261          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 262          *
 263          * VLAN ID: Vlan Starting value
 264          * RSVD0: Reserved section, must be 0
 265          * C: Flag field, 0 is set, 1 is clear (Used in VF VLAN message)
 266          * Length: Number of times to repeat the bit being set
 267          */
 268         len = vid >> 16;
 269         vid = (vid << 17) >> 17;
 270
 271         /* verify the reserved 0 fields are 0 */
 272         if (len >= FM10K_VLAN_TABLE_VID_MAX || vid >= FM10K_VLAN_TABLE_VID_MAX)
 273                 return FM10K_ERR_PARAM;
 274
 275         /* Loop through the table updating all required VLANs */
 276         for (reg = FM10K_VLAN_TABLE(vsi, vid / 32), bit = vid % 32;
 277              len < FM10K_VLAN_TABLE_VID_MAX;
 278              len -= 32 - bit, reg++, bit = 0) {
 279                 /* record the initial state of the register */
 280                 vlan_table = FM10K_READ_REG(hw, reg);
 281
 282                 /* truncate mask if we are at the start or end of the run */
 283                 mask = (~(u32)0 >> ((len < 31) ? 31 - len : 0)) << bit;
 284
 285                 /* make necessary modifications to the register */
 286                 mask &= set ? ~vlan_table : vlan_table;
 287                 if (mask)
 288                         FM10K_WRITE_REG(hw, reg, vlan_table ^ mask);
 289         }
 290
 291         return FM10K_SUCCESS;
 292 }
 293
 294 /**
 295  *  fm10k_read_mac_addr_pf - Read device MAC address
 296  *  @hw: pointer to the HW structure
 297  *
 298  *  Reads the device MAC address from the SM_AREA and stores the value.
 299  **/
 300 STATIC s32 fm10k_read_mac_addr_pf(struct fm10k_hw *hw)
 301 {
 302         u8 perm_addr[ETH_ALEN];
 303         u32 serial_num;
 304
 305         DEBUGFUNC("fm10k_read_mac_addr_pf");
 306
 307         serial_num = FM10K_READ_REG(hw, FM10K_SM_AREA(1));
 308
 309         /* last byte should be all 1's */
 310         if ((~serial_num) << 24)
 311                 return  FM10K_ERR_INVALID_MAC_ADDR;
 312
 313         perm_addr[0] = (u8)(serial_num >> 24);
 314         perm_addr[1] = (u8)(serial_num >> 16);
 315         perm_addr[2] = (u8)(serial_num >> 8);
 316
 317         serial_num = FM10K_READ_REG(hw, FM10K_SM_AREA(0));
 318
 319         /* first byte should be all 1's */
 320         if ((~serial_num) >> 24)
 321                 return  FM10K_ERR_INVALID_MAC_ADDR;
 322
 323         perm_addr[3] = (u8)(serial_num >> 16);
 324         perm_addr[4] = (u8)(serial_num >> 8);
 325         perm_addr[5] = (u8)(serial_num);
 326
 327         memcpy(hw->mac.perm_addr, perm_addr, ETH_ALEN);
 328         memcpy(hw->mac.addr, perm_addr, ETH_ALEN);
 329
 330         return FM10K_SUCCESS;
 331 }
 332
 333 /**
 334  *  fm10k_glort_valid_pf - Validate that the provided glort is valid
 335  *  @hw: pointer to the HW structure
 336  *  @glort: base glort to be validated
 337  *
 338  *  This function will return an error if the provided glort is invalid
 339  **/
 340 bool fm10k_glort_valid_pf(struct fm10k_hw *hw, u16 glort)
 341 {
 342         glort &= hw->mac.dglort_map >> FM10K_DGLORTMAP_MASK_SHIFT;
 343
 344         return glort == (hw->mac.dglort_map & FM10K_DGLORTMAP_NONE);
 345 }
 346
 347 /**
 348  *  fm10k_update_xc_addr_pf - Update device addresses
 349  *  @hw: pointer to the HW structure
 350  *  @glort: base resource tag for this request
 351  *  @mac: MAC address to add/remove from table
 352  *  @vid: VLAN ID to add/remove from table
 353  *  @add: Indicates if this is an add or remove operation
 354  *  @flags: flags field to indicate add and secure
 355  *
 356  *  This function generates a message to the Switch API requesting
 357  *  that the given logical port add/remove the given L2 MAC/VLAN address.
 358  **/
 359 STATIC s32 fm10k_update_xc_addr_pf(struct fm10k_hw *hw, u16 glort,
 360                                    const u8 *mac, u16 vid, bool add, u8 flags)
 361 {
 362         struct fm10k_mbx_info *mbx = &hw->mbx;
 363         struct fm10k_mac_update mac_update;
 364         u32 msg[5];
 365
 366         DEBUGFUNC("fm10k_update_xc_addr_pf");
 367
 368         /* clear set bit from VLAN ID */
 369         vid &= ~FM10K_VLAN_CLEAR;
 370
 371         /* if glort or VLAN are not valid return error */
 372         if (!fm10k_glort_valid_pf(hw, glort) || vid >= FM10K_VLAN_TABLE_VID_MAX)
 373                 return FM10K_ERR_PARAM;
 374
 375         /* record fields */
 376         mac_update.mac_lower = FM10K_CPU_TO_LE32(((u32)mac[2] << 24) |
 377                                                  ((u32)mac[3] << 16) |
 378                                                  ((u32)mac[4] << 8) |
 379                                                  ((u32)mac[5]));
 380         mac_update.mac_upper = FM10K_CPU_TO_LE16(((u16)mac[0] << 8) |
 381                                            ((u16)mac[1]));
 382         mac_update.vlan = FM10K_CPU_TO_LE16(vid);
 383         mac_update.glort = FM10K_CPU_TO_LE16(glort);
 384         mac_update.action = add ? 0 : 1;
 385         mac_update.flags = flags;
 386
 387         /* populate mac_update fields */
 388         fm10k_tlv_msg_init(msg, FM10K_PF_MSG_ID_UPDATE_MAC_FWD_RULE);
 389         fm10k_tlv_attr_put_le_struct(msg, FM10K_PF_ATTR_ID_MAC_UPDATE,
 390                                      &mac_update, sizeof(mac_update));
 391
 392         /* load onto outgoing mailbox */
 393         return mbx->ops.enqueue_tx(hw, mbx, msg);
 394 }
 395
 396 /**
 397  *  fm10k_update_uc_addr_pf - Update device unicast addresses
 398  *  @hw: pointer to the HW structure
 399  *  @glort: base resource tag for this request
 400  *  @mac: MAC address to add/remove from table
 401  *  @vid: VLAN ID to add/remove from table
 402  *  @add: Indicates if this is an add or remove operation
 403  *  @flags: flags field to indicate add and secure
 404  *
 405  *  This function is used to add or remove unicast addresses for
 406  *  the PF.
 407  **/
 408 STATIC s32 fm10k_update_uc_addr_pf(struct fm10k_hw *hw, u16 glort,
 409                                    const u8 *mac, u16 vid, bool add, u8 flags)
 410 {
 411         DEBUGFUNC("fm10k_update_uc_addr_pf");
 412
 413         /* verify MAC address is valid */
 414         if (!FM10K_IS_VALID_ETHER_ADDR(mac))
 415                 return FM10K_ERR_PARAM;
 416
 417         return fm10k_update_xc_addr_pf(hw, glort, mac, vid, add, flags);
 418 }
 419
 420 /**
 421  *  fm10k_update_mc_addr_pf - Update device multicast addresses
 422  *  @hw: pointer to the HW structure
 423  *  @glort: base resource tag for this request
 424  *  @mac: MAC address to add/remove from table
 425  *  @vid: VLAN ID to add/remove from table
 426  *  @add: Indicates if this is an add or remove operation
 427  *
 428  *  This function is used to add or remove multicast MAC addresses for
 429  *  the PF.
 430  **/
 431 STATIC s32 fm10k_update_mc_addr_pf(struct fm10k_hw *hw, u16 glort,
 432                                    const u8 *mac, u16 vid, bool add)
 433 {
 434         DEBUGFUNC("fm10k_update_mc_addr_pf");
 435
 436         /* verify multicast address is valid */
 437         if (!FM10K_IS_MULTICAST_ETHER_ADDR(mac))
 438                 return FM10K_ERR_PARAM;
 439
 440         return fm10k_update_xc_addr_pf(hw, glort, mac, vid, add, 0);
 441 }
 442
 443 /**
 444  *  fm10k_update_xcast_mode_pf - Request update of multicast mode
 445  *  @hw: pointer to hardware structure
 446  *  @glort: base resource tag for this request
 447  *  @mode: integer value indicating mode being requested
 448  *
 449  *  This function will attempt to request a higher mode for the port
 450  *  so that it can enable either multicast, multicast promiscuous, or
 451  *  promiscuous mode of operation.
 452  **/
 453 STATIC s32 fm10k_update_xcast_mode_pf(struct fm10k_hw *hw, u16 glort, u8 mode)
 454 {
 455         struct fm10k_mbx_info *mbx = &hw->mbx;
 456         u32 msg[3], xcast_mode;
 457
 458         DEBUGFUNC("fm10k_update_xcast_mode_pf");
 459
 460         if (mode > FM10K_XCAST_MODE_NONE)
 461                 return FM10K_ERR_PARAM;
 462
 463         /* if glort is not valid return error */
 464         if (!fm10k_glort_valid_pf(hw, glort))
 465                 return FM10K_ERR_PARAM;
 466
 467         /* write xcast mode as a single u32 value,
 468          * lower 16 bits: glort
 469          * upper 16 bits: mode
 470          */
 471         xcast_mode = ((u32)mode << 16) | glort;
 472
 473         /* generate message requesting to change xcast mode */
 474         fm10k_tlv_msg_init(msg, FM10K_PF_MSG_ID_XCAST_MODES);
 475         fm10k_tlv_attr_put_u32(msg, FM10K_PF_ATTR_ID_XCAST_MODE, xcast_mode);
 476
 477         /* load onto outgoing mailbox */
 478         return mbx->ops.enqueue_tx(hw, mbx, msg);
 479 }
 480
 481 /**
 482  *  fm10k_update_int_moderator_pf - Update interrupt moderator linked list
 483  *  @hw: pointer to hardware structure
 484  *
 485  *  This function walks through the MSI-X vector table to determine the
 486  *  number of active interrupts and based on that information updates the
 487  *  interrupt moderator linked list.
 488  **/
 489 STATIC void fm10k_update_int_moderator_pf(struct fm10k_hw *hw)
 490 {
 491         u32 i;
 492
 493         /* Disable interrupt moderator */
 494         FM10K_WRITE_REG(hw, FM10K_INT_CTRL, 0);
 495
 496         /* loop through PF from last to first looking enabled vectors */
 497         for (i = FM10K_ITR_REG_COUNT_PF - 1; i; i--) {
 498                 if (!FM10K_READ_REG(hw, FM10K_MSIX_VECTOR_MASK(i)))
 499                         break;
 500         }
 501
 502         /* always reset VFITR2[0] to point to last enabled PF vector */
 503         FM10K_WRITE_REG(hw, FM10K_ITR2(FM10K_ITR_REG_COUNT_PF), i);
 504
 505         /* reset ITR2[0] to point to last enabled PF vector */
 506         if (!hw->iov.num_vfs)
 507                 FM10K_WRITE_REG(hw, FM10K_ITR2(0), i);
 508
 509         /* Enable interrupt moderator */
 510         FM10K_WRITE_REG(hw, FM10K_INT_CTRL, FM10K_INT_CTRL_ENABLEMODERATOR);
 511 }
 512
 513 /**
 514  *  fm10k_update_lport_state_pf - Notify the switch of a change in port state
 515  *  @hw: pointer to the HW structure
 516  *  @glort: base resource tag for this request
 517  *  @count: number of logical ports being updated
 518  *  @enable: boolean value indicating enable or disable
 519  *
 520  *  This function is used to add/remove a logical port from the switch.
 521  **/
 522 STATIC s32 fm10k_update_lport_state_pf(struct fm10k_hw *hw, u16 glort,
 523                                        u16 count, bool enable)
 524 {
 525         struct fm10k_mbx_info *mbx = &hw->mbx;
 526         u32 msg[3], lport_msg;
 527
 528         DEBUGFUNC("fm10k_lport_state_pf");
 529
 530         /* do nothing if we are being asked to create or destroy 0 ports */
 531         if (!count)
 532                 return FM10K_SUCCESS;
 533
 534         /* if glort is not valid return error */
 535         if (!fm10k_glort_valid_pf(hw, glort))
 536                 return FM10K_ERR_PARAM;
 537
 538         /* reset multicast mode if deleting lport */
 539         if (!enable)
 540                 fm10k_update_xcast_mode_pf(hw, glort, FM10K_XCAST_MODE_NONE);
 541
 542         /* construct the lport message from the 2 pieces of data we have */
 543         lport_msg = ((u32)count << 16) | glort;
 544
 545         /* generate lport create/delete message */
 546         fm10k_tlv_msg_init(msg, enable ? FM10K_PF_MSG_ID_LPORT_CREATE :
 547                                          FM10K_PF_MSG_ID_LPORT_DELETE);
 548         fm10k_tlv_attr_put_u32(msg, FM10K_PF_ATTR_ID_PORT, lport_msg);
 549
 550         /* load onto outgoing mailbox */
 551         return mbx->ops.enqueue_tx(hw, mbx, msg);
 552 }
 553
 554 /**
 555  *  fm10k_configure_dglort_map_pf - Configures GLORT entry and queues
 556  *  @hw: pointer to hardware structure
 557  *  @dglort: pointer to dglort configuration structure
 558  *
 559  *  Reads the configuration structure contained in dglort_cfg and uses
 560  *  that information to then populate a DGLORTMAP/DEC entry and the queues
 561  *  to which it has been assigned.
 562  **/
 563 STATIC s32 fm10k_configure_dglort_map_pf(struct fm10k_hw *hw,
 564                                          struct fm10k_dglort_cfg *dglort)
 565 {
 566         u16 glort, queue_count, vsi_count, pc_count;
 567         u16 vsi, queue, pc, q_idx;
 568         u32 txqctl, dglortdec, dglortmap;
 569
 570         /* verify the dglort pointer */
 571         if (!dglort)
 572                 return FM10K_ERR_PARAM;
 573
 574         /* verify the dglort values */
 575         if ((dglort->idx > 7) || (dglort->rss_l > 7) || (dglort->pc_l > 3) ||
 576             (dglort->vsi_l > 6) || (dglort->vsi_b > 64) ||
 577             (dglort->queue_l > 8) || (dglort->queue_b >= 256))
 578                 return FM10K_ERR_PARAM;
 579
 580         /* determine count of VSIs and queues */
 581         queue_count = BIT(dglort->rss_l + dglort->pc_l);
 582         vsi_count = BIT(dglort->vsi_l + dglort->queue_l);
 583         glort = dglort->glort;
 584         q_idx = dglort->queue_b;
 585
 586         /* configure SGLORT for queues */
 587         for (vsi = 0; vsi < vsi_count; vsi++, glort++) {
 588                 for (queue = 0; queue < queue_count; queue++, q_idx++) {
 589                         if (q_idx >= FM10K_MAX_QUEUES)
 590                                 break;
 591
 592                         FM10K_WRITE_REG(hw, FM10K_TX_SGLORT(q_idx), glort);
 593                         FM10K_WRITE_REG(hw, FM10K_RX_SGLORT(q_idx), glort);
 594                 }
 595         }
 596
 597         /* determine count of PCs and queues */
 598         queue_count = BIT(dglort->queue_l + dglort->rss_l + dglort->vsi_l);
 599         pc_count = BIT(dglort->pc_l);
 600
 601         /* configure PC for Tx queues */
 602         for (pc = 0; pc < pc_count; pc++) {
 603                 q_idx = pc + dglort->queue_b;
 604                 for (queue = 0; queue < queue_count; queue++) {
 605                         if (q_idx >= FM10K_MAX_QUEUES)
 606                                 break;
 607
 608                         txqctl = FM10K_READ_REG(hw, FM10K_TXQCTL(q_idx));
 609                         txqctl &= ~FM10K_TXQCTL_PC_MASK;
 610                         txqctl |= pc << FM10K_TXQCTL_PC_SHIFT;
 611                         FM10K_WRITE_REG(hw, FM10K_TXQCTL(q_idx), txqctl);
 612
 613                         q_idx += pc_count;
 614                 }
 615         }
 616
 617         /* configure DGLORTDEC */
 618         dglortdec = ((u32)(dglort->rss_l) << FM10K_DGLORTDEC_RSSLENGTH_SHIFT) |
 619                     ((u32)(dglort->queue_b) << FM10K_DGLORTDEC_QBASE_SHIFT) |
 620                     ((u32)(dglort->pc_l) << FM10K_DGLORTDEC_PCLENGTH_SHIFT) |
 621                     ((u32)(dglort->vsi_b) << FM10K_DGLORTDEC_VSIBASE_SHIFT) |
 622                     ((u32)(dglort->vsi_l) << FM10K_DGLORTDEC_VSILENGTH_SHIFT) |
 623                     ((u32)(dglort->queue_l));
 624         if (dglort->inner_rss)
 625                 dglortdec |=  FM10K_DGLORTDEC_INNERRSS_ENABLE;
 626
 627         /* configure DGLORTMAP */
 628         dglortmap = (dglort->idx == fm10k_dglort_default) ?
 629                         FM10K_DGLORTMAP_ANY : FM10K_DGLORTMAP_ZERO;
 630         dglortmap <<= dglort->vsi_l + dglort->queue_l + dglort->shared_l;
 631         dglortmap |= dglort->glort;
 632
 633         /* write values to hardware */
 634         FM10K_WRITE_REG(hw, FM10K_DGLORTDEC(dglort->idx), dglortdec);
 635         FM10K_WRITE_REG(hw, FM10K_DGLORTMAP(dglort->idx), dglortmap);
 636
 637         return FM10K_SUCCESS;
 638 }
 639
 640 u16 fm10k_queues_per_pool(struct fm10k_hw *hw)
 641 {
 642         u16 num_pools = hw->iov.num_pools;
 643
 644         return (num_pools > 32) ? 2 : (num_pools > 16) ? 4 : (num_pools > 8) ?
 645                8 : FM10K_MAX_QUEUES_POOL;
 646 }
 647
 648 u16 fm10k_vf_queue_index(struct fm10k_hw *hw, u16 vf_idx)
 649 {
 650         u16 num_vfs = hw->iov.num_vfs;
 651         u16 vf_q_idx = FM10K_MAX_QUEUES;
 652
 653         vf_q_idx -= fm10k_queues_per_pool(hw) * (num_vfs - vf_idx);
 654
 655         return vf_q_idx;
 656 }
 657
 658 STATIC u16 fm10k_vectors_per_pool(struct fm10k_hw *hw)
 659 {
 660         u16 num_pools = hw->iov.num_pools;
 661
 662         return (num_pools > 32) ? 8 : (num_pools > 16) ? 16 :
 663                FM10K_MAX_VECTORS_POOL;
 664 }
 665
 666 STATIC u16 fm10k_vf_vector_index(struct fm10k_hw *hw, u16 vf_idx)
 667 {
 668         u16 vf_v_idx = FM10K_MAX_VECTORS_PF;
 669
 670         vf_v_idx += fm10k_vectors_per_pool(hw) * vf_idx;
 671
 672         return vf_v_idx;
 673 }
 674
 675 /**
 676  *  fm10k_iov_assign_resources_pf - Assign pool resources for virtualization
 677  *  @hw: pointer to the HW structure
 678  *  @num_vfs: number of VFs to be allocated
 679  *  @num_pools: number of virtualization pools to be allocated
 680  *
 681  *  Allocates queues and traffic classes to virtualization entities to prepare
 682  *  the PF for SR-IOV and VMDq
 683  **/
 684 STATIC s32 fm10k_iov_assign_resources_pf(struct fm10k_hw *hw, u16 num_vfs,
 685                                          u16 num_pools)
 686 {
 687         u16 qmap_stride, qpp, vpp, vf_q_idx, vf_q_idx0, qmap_idx;
 688         u32 vid = hw->mac.default_vid << FM10K_TXQCTL_VID_SHIFT;
 689         int i, j;
 690
 691         /* hardware only supports up to 64 pools */
 692         if (num_pools > 64)
 693                 return FM10K_ERR_PARAM;
 694
 695         /* the number of VFs cannot exceed the number of pools */
 696         if ((num_vfs > num_pools) || (num_vfs > hw->iov.total_vfs))
 697                 return FM10K_ERR_PARAM;
 698
 699         /* record number of virtualization entities */
 700         hw->iov.num_vfs = num_vfs;
 701         hw->iov.num_pools = num_pools;
 702
 703         /* determine qmap offsets and counts */
 704         qmap_stride = (num_vfs > 8) ? 32 : 256;
 705         qpp = fm10k_queues_per_pool(hw);
 706         vpp = fm10k_vectors_per_pool(hw);
 707
 708         /* calculate starting index for queues */
 709         vf_q_idx = fm10k_vf_queue_index(hw, 0);
 710         qmap_idx = 0;
 711
 712         /* establish TCs with -1 credits and no quanta to prevent transmit */
 713         for (i = 0; i < num_vfs; i++) {
 714                 FM10K_WRITE_REG(hw, FM10K_TC_MAXCREDIT(i), 0);
 715                 FM10K_WRITE_REG(hw, FM10K_TC_RATE(i), 0);
 716                 FM10K_WRITE_REG(hw, FM10K_TC_CREDIT(i),
 717                                 FM10K_TC_CREDIT_CREDIT_MASK);
 718         }
 719
 720         /* zero out all mbmem registers */
 721         for (i = FM10K_VFMBMEM_LEN * num_vfs; i--;)
 722                 FM10K_WRITE_REG(hw, FM10K_MBMEM(i), 0);
 723
 724         /* clear event notification of VF FLR */
 725         FM10K_WRITE_REG(hw, FM10K_PFVFLREC(0), ~0);
 726         FM10K_WRITE_REG(hw, FM10K_PFVFLREC(1), ~0);
 727
 728         /* loop through unallocated rings assigning them back to PF */
 729         for (i = FM10K_MAX_QUEUES_PF; i < vf_q_idx; i++) {
 730                 FM10K_WRITE_REG(hw, FM10K_TXDCTL(i), 0);
 731                 FM10K_WRITE_REG(hw, FM10K_TXQCTL(i), FM10K_TXQCTL_PF |
 732                                 FM10K_TXQCTL_UNLIMITED_BW | vid);
 733                 FM10K_WRITE_REG(hw, FM10K_RXQCTL(i), FM10K_RXQCTL_PF);
 734         }
 735
 736         /* PF should have already updated VFITR2[0] */
 737
 738         /* update all ITR registers to flow to VFITR2[0] */
 739         for (i = FM10K_ITR_REG_COUNT_PF + 1; i < FM10K_ITR_REG_COUNT; i++) {
 740                 if (!(i & (vpp - 1)))
 741                         FM10K_WRITE_REG(hw, FM10K_ITR2(i), i - vpp);
 742                 else
 743                         FM10K_WRITE_REG(hw, FM10K_ITR2(i), i - 1);
 744         }
 745
 746         /* update PF ITR2[0] to reference the last vector */
 747         FM10K_WRITE_REG(hw, FM10K_ITR2(0),
 748                         fm10k_vf_vector_index(hw, num_vfs - 1));
 749
 750         /* loop through rings populating rings and TCs */
 751         for (i = 0; i < num_vfs; i++) {
 752                 /* record index for VF queue 0 for use in end of loop */
 753                 vf_q_idx0 = vf_q_idx;
 754
 755                 for (j = 0; j < qpp; j++, qmap_idx++, vf_q_idx++) {
 756                         /* assign VF and locked TC to queues */
 757                         FM10K_WRITE_REG(hw, FM10K_TXDCTL(vf_q_idx), 0);
 758                         FM10K_WRITE_REG(hw, FM10K_TXQCTL(vf_q_idx),
 759                                         (i << FM10K_TXQCTL_TC_SHIFT) | i |
 760                                         FM10K_TXQCTL_VF | vid);
 761                         FM10K_WRITE_REG(hw, FM10K_RXDCTL(vf_q_idx),
 762                                         FM10K_RXDCTL_WRITE_BACK_MIN_DELAY |
 763                                         FM10K_RXDCTL_DROP_ON_EMPTY);
 764                         FM10K_WRITE_REG(hw, FM10K_RXQCTL(vf_q_idx),
 765                                         (i << FM10K_RXQCTL_VF_SHIFT) |
 766                                         FM10K_RXQCTL_VF);
 767
 768                         /* map queue pair to VF */
 769                         FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx), vf_q_idx);
 770                         FM10K_WRITE_REG(hw, FM10K_RQMAP(qmap_idx), vf_q_idx);
 771                 }
 772
 773                 /* repeat the first ring for all of the remaining VF rings */
 774                 for (; j < qmap_stride; j++, qmap_idx++) {
 775                         FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx), vf_q_idx0);
 776                         FM10K_WRITE_REG(hw, FM10K_RQMAP(qmap_idx), vf_q_idx0);
 777                 }
 778         }
 779
 780         /* loop through remaining indexes assigning all to queue 0 */
 781         while (qmap_idx < FM10K_TQMAP_TABLE_SIZE) {
 782                 FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx), 0);
 783                 FM10K_WRITE_REG(hw, FM10K_RQMAP(qmap_idx), 0);
 784                 qmap_idx++;
 785         }
 786
 787         return FM10K_SUCCESS;
 788 }
 789
 790 /**
 791  *  fm10k_iov_configure_tc_pf - Configure the shaping group for VF
 792  *  @hw: pointer to the HW structure
 793  *  @vf_idx: index of VF receiving GLORT
 794  *  @rate: Rate indicated in Mb/s
 795  *
 796  *  Configured the TC for a given VF to allow only up to a given number
 797  *  of Mb/s of outgoing Tx throughput.
 798  **/
 799 STATIC s32 fm10k_iov_configure_tc_pf(struct fm10k_hw *hw, u16 vf_idx, int rate)
 800 {
 801         /* configure defaults */
 802         u32 interval = FM10K_TC_RATE_INTERVAL_4US_GEN3;
 803         u32 tc_rate = FM10K_TC_RATE_QUANTA_MASK;
 804
 805         /* verify vf is in range */
 806         if (vf_idx >= hw->iov.num_vfs)
 807                 return FM10K_ERR_PARAM;
 808
 809         /* set interval to align with 4.096 usec in all modes */
 810         switch (hw->bus.speed) {
 811         case fm10k_bus_speed_2500:
 812                 interval = FM10K_TC_RATE_INTERVAL_4US_GEN1;
 813                 break;
 814         case fm10k_bus_speed_5000:
 815                 interval = FM10K_TC_RATE_INTERVAL_4US_GEN2;
 816                 break;
 817         default:
 818                 break;
 819         }
 820
 821         if (rate) {
 822                 if (rate > FM10K_VF_TC_MAX || rate < FM10K_VF_TC_MIN)
 823                         return FM10K_ERR_PARAM;
 824
 825                 /* The quanta is measured in Bytes per 4.096 or 8.192 usec
 826                  * The rate is provided in Mbits per second
 827                  * To tralslate from rate to quanta we need to multiply the
 828                  * rate by 8.192 usec and divide by 8 bits/byte.  To avoid
 829                  * dealing with floating point we can round the values up
 830                  * to the nearest whole number ratio which gives us 128 / 125.
 831                  */
 832                 tc_rate = (rate * 128) / 125;
 833
 834                 /* try to keep the rate limiting accurate by increasing
 835                  * the number of credits and interval for rates less than 4Gb/s
 836                  */
 837                 if (rate < 4000)
 838                         interval <<= 1;
 839                 else
 840                         tc_rate >>= 1;
 841         }
 842
 843         /* update rate limiter with new values */
 844         FM10K_WRITE_REG(hw, FM10K_TC_RATE(vf_idx), tc_rate | interval);
 845         FM10K_WRITE_REG(hw, FM10K_TC_MAXCREDIT(vf_idx), FM10K_TC_MAXCREDIT_64K);
 846         FM10K_WRITE_REG(hw, FM10K_TC_CREDIT(vf_idx), FM10K_TC_MAXCREDIT_64K);
 847
 848         return FM10K_SUCCESS;
 849 }
 850
 851 /**
 852  *  fm10k_iov_assign_int_moderator_pf - Add VF interrupts to moderator list
 853  *  @hw: pointer to the HW structure
 854  *  @vf_idx: index of VF receiving GLORT
 855  *
 856  *  Update the interrupt moderator linked list to include any MSI-X
 857  *  interrupts which the VF has enabled in the MSI-X vector table.
 858  **/
 859 STATIC s32 fm10k_iov_assign_int_moderator_pf(struct fm10k_hw *hw, u16 vf_idx)
 860 {
 861         u16 vf_v_idx, vf_v_limit, i;
 862
 863         /* verify vf is in range */
 864         if (vf_idx >= hw->iov.num_vfs)
 865                 return FM10K_ERR_PARAM;
 866
 867         /* determine vector offset and count */
 868         vf_v_idx = fm10k_vf_vector_index(hw, vf_idx);
 869         vf_v_limit = vf_v_idx + fm10k_vectors_per_pool(hw);
 870
 871         /* search for first vector that is not masked */
 872         for (i = vf_v_limit - 1; i > vf_v_idx; i--) {
 873                 if (!FM10K_READ_REG(hw, FM10K_MSIX_VECTOR_MASK(i)))
 874                         break;
 875         }
 876
 877         /* reset linked list so it now includes our active vectors */
 878         if (vf_idx == (hw->iov.num_vfs - 1))
 879                 FM10K_WRITE_REG(hw, FM10K_ITR2(0), i);
 880         else
 881                 FM10K_WRITE_REG(hw, FM10K_ITR2(vf_v_limit), i);
 882
 883         return FM10K_SUCCESS;
 884 }
 885
 886 /**
 887  *  fm10k_iov_assign_default_mac_vlan_pf - Assign a MAC and VLAN to VF
 888  *  @hw: pointer to the HW structure
 889  *  @vf_info: pointer to VF information structure
 890  *
 891  *  Assign a MAC address and default VLAN to a VF and notify it of the update
 892  **/
 893 STATIC s32 fm10k_iov_assign_default_mac_vlan_pf(struct fm10k_hw *hw,
 894                                                 struct fm10k_vf_info *vf_info)
 895 {
 896         u16 qmap_stride, queues_per_pool, vf_q_idx, timeout, qmap_idx, i;
 897         u32 msg[4], txdctl, txqctl, tdbal = 0, tdbah = 0;
 898         s32 err = FM10K_SUCCESS;
 899         u16 vf_idx, vf_vid;
 900
 901         /* verify vf is in range */
 902         if (!vf_info || vf_info->vf_idx >= hw->iov.num_vfs)
 903                 return FM10K_ERR_PARAM;
 904
 905         /* determine qmap offsets and counts */
 906         qmap_stride = (hw->iov.num_vfs > 8) ? 32 : 256;
 907         queues_per_pool = fm10k_queues_per_pool(hw);
 908
 909         /* calculate starting index for queues */
 910         vf_idx = vf_info->vf_idx;
 911         vf_q_idx = fm10k_vf_queue_index(hw, vf_idx);
 912         qmap_idx = qmap_stride * vf_idx;
 913
 914         /* Determine correct default VLAN ID. The FM10K_VLAN_OVERRIDE bit is
 915          * used here to indicate to the VF that it will not have privilege to
 916          * write VLAN_TABLE. All policy is enforced on the PF but this allows
 917          * the VF to correctly report errors to userspace rqeuests.
 918          */
 919         if (vf_info->pf_vid)
 920                 vf_vid = vf_info->pf_vid | FM10K_VLAN_OVERRIDE;
 921         else
 922                 vf_vid = vf_info->sw_vid;
 923
 924         /* generate MAC_ADDR request */
 925         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 926         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_DEFAULT_MAC,
 927                                     vf_info->mac, vf_vid);
 928
 929         /* load onto outgoing mailbox, ignore any errors on enqueue */
 930         if (vf_info->mbx.ops.enqueue_tx)
 931                 vf_info->mbx.ops.enqueue_tx(hw, &vf_info->mbx, msg);
 932
 933         /* verify ring has disabled before modifying base address registers */
 934         txdctl = FM10K_READ_REG(hw, FM10K_TXDCTL(vf_q_idx));
 935         for (timeout = 0; txdctl & FM10K_TXDCTL_ENABLE; timeout++) {
 936                 /* limit ourselves to a 1ms timeout */
 937                 if (timeout == 10) {
 938                         err = FM10K_ERR_DMA_PENDING;
 939                         goto err_out;
 940                 }
 941
 942                 usec_delay(100);
 943                 txdctl = FM10K_READ_REG(hw, FM10K_TXDCTL(vf_q_idx));
 944         }
 945
 946         /* Update base address registers to contain MAC address */
 947         if (FM10K_IS_VALID_ETHER_ADDR(vf_info->mac)) {
 948                 tdbal = (((u32)vf_info->mac[3]) << 24) |
 949                         (((u32)vf_info->mac[4]) << 16) |
 950                         (((u32)vf_info->mac[5]) << 8);
 951
 952                 tdbah = (((u32)0xFF)            << 24) |
 953                         (((u32)vf_info->mac[0]) << 16) |
 954                         (((u32)vf_info->mac[1]) << 8) |
 955                         ((u32)vf_info->mac[2]);
 956         }
 957
 958         /* Record the base address into queue 0 */
 959         FM10K_WRITE_REG(hw, FM10K_TDBAL(vf_q_idx), tdbal);
 960         FM10K_WRITE_REG(hw, FM10K_TDBAH(vf_q_idx), tdbah);
 961
 962         /* Provide the VF the ITR scale, using software-defined fields in TDLEN
 963          * to pass the information during VF initialization. See definition of
 964          * FM10K_TDLEN_ITR_SCALE_SHIFT for more details.
 965          */
 966         FM10K_WRITE_REG(hw, FM10K_TDLEN(vf_q_idx), hw->mac.itr_scale <<
 967                                                    FM10K_TDLEN_ITR_SCALE_SHIFT);
 968
 969 err_out:
 970         /* configure Queue control register */
 971         txqctl = ((u32)vf_vid << FM10K_TXQCTL_VID_SHIFT) &
 972                  FM10K_TXQCTL_VID_MASK;
 973         txqctl |= (vf_idx << FM10K_TXQCTL_TC_SHIFT) |
 974                   FM10K_TXQCTL_VF | vf_idx;
 975
 976         /* assign VLAN ID */
 977         for (i = 0; i < queues_per_pool; i++)
 978                 FM10K_WRITE_REG(hw, FM10K_TXQCTL(vf_q_idx + i), txqctl);
 979
 980         /* restore the queue back to VF ownership */
 981         FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx), vf_q_idx);
 982         return err;
 983 }
 984
 985 /**
 986  *  fm10k_iov_reset_resources_pf - Reassign queues and interrupts to a VF
 987  *  @hw: pointer to the HW structure
 988  *  @vf_info: pointer to VF information structure
 989  *
 990  *  Reassign the interrupts and queues to a VF following an FLR
 991  **/
 992 STATIC s32 fm10k_iov_reset_resources_pf(struct fm10k_hw *hw,
 993                                         struct fm10k_vf_info *vf_info)
 994 {
 995         u16 qmap_stride, queues_per_pool, vf_q_idx, qmap_idx;
 996         u32 tdbal = 0, tdbah = 0, txqctl, rxqctl;
 997         u16 vf_v_idx, vf_v_limit, vf_vid;
 998         u8 vf_idx = vf_info->vf_idx;
 999         int i;
1000
1001         /* verify vf is in range */
1002         if (vf_idx >= hw->iov.num_vfs)
1003                 return FM10K_ERR_PARAM;
1004
1005         /* clear event notification of VF FLR */
1006         FM10K_WRITE_REG(hw, FM10K_PFVFLREC(vf_idx / 32), BIT(vf_idx % 32));
1007
1008         /* force timeout and then disconnect the mailbox */
1009         vf_info->mbx.timeout = 0;
1010         if (vf_info->mbx.ops.disconnect)
1011                 vf_info->mbx.ops.disconnect(hw, &vf_info->mbx);
1012
1013         /* determine vector offset and count */
1014         vf_v_idx = fm10k_vf_vector_index(hw, vf_idx);
1015         vf_v_limit = vf_v_idx + fm10k_vectors_per_pool(hw);
1016
1017         /* determine qmap offsets and counts */
1018         qmap_stride = (hw->iov.num_vfs > 8) ? 32 : 256;
1019         queues_per_pool = fm10k_queues_per_pool(hw);
1020         qmap_idx = qmap_stride * vf_idx;
1021
1022         /* make all the queues inaccessible to the VF */
1023         for (i = qmap_idx; i < (qmap_idx + qmap_stride); i++) {
1024                 FM10K_WRITE_REG(hw, FM10K_TQMAP(i), 0);
1025                 FM10K_WRITE_REG(hw, FM10K_RQMAP(i), 0);
1026         }
1027
1028         /* calculate starting index for queues */
1029         vf_q_idx = fm10k_vf_queue_index(hw, vf_idx);
1030
1031         /* determine correct default VLAN ID */
1032         if (vf_info->pf_vid)
1033                 vf_vid = vf_info->pf_vid;
1034         else
1035                 vf_vid = vf_info->sw_vid;
1036
1037         /* configure Queue control register */
1038         txqctl = ((u32)vf_vid << FM10K_TXQCTL_VID_SHIFT) |
1039                  (vf_idx << FM10K_TXQCTL_TC_SHIFT) |
1040                  FM10K_TXQCTL_VF | vf_idx;
1041         rxqctl = (vf_idx << FM10K_RXQCTL_VF_SHIFT) | FM10K_RXQCTL_VF;
1042
1043         /* stop further DMA and reset queue ownership back to VF */
1044         for (i = vf_q_idx; i < (queues_per_pool + vf_q_idx); i++) {
1045                 FM10K_WRITE_REG(hw, FM10K_TXDCTL(i), 0);
1046                 FM10K_WRITE_REG(hw, FM10K_TXQCTL(i), txqctl);
1047                 FM10K_WRITE_REG(hw, FM10K_RXDCTL(i),
1048                                 FM10K_RXDCTL_WRITE_BACK_MIN_DELAY |
1049                                 FM10K_RXDCTL_DROP_ON_EMPTY);
1050                 FM10K_WRITE_REG(hw, FM10K_RXQCTL(i), rxqctl);
1051         }
1052
1053         /* reset TC with -1 credits and no quanta to prevent transmit */
1054         FM10K_WRITE_REG(hw, FM10K_TC_MAXCREDIT(vf_idx), 0);
1055         FM10K_WRITE_REG(hw, FM10K_TC_RATE(vf_idx), 0);
1056         FM10K_WRITE_REG(hw, FM10K_TC_CREDIT(vf_idx),
1057                         FM10K_TC_CREDIT_CREDIT_MASK);
1058
1059         /* update our first entry in the table based on previous VF */
1060         if (!vf_idx)
1061                 hw->mac.ops.update_int_moderator(hw);
1062         else
1063                 hw->iov.ops.assign_int_moderator(hw, vf_idx - 1);
1064
1065         /* reset linked list so it now includes our active vectors */
1066         if (vf_idx == (hw->iov.num_vfs - 1))
1067                 FM10K_WRITE_REG(hw, FM10K_ITR2(0), vf_v_idx);
1068         else
1069                 FM10K_WRITE_REG(hw, FM10K_ITR2(vf_v_limit), vf_v_idx);
1070
1071         /* link remaining vectors so that next points to previous */
1072         for (vf_v_idx++; vf_v_idx < vf_v_limit; vf_v_idx++)
1073                 FM10K_WRITE_REG(hw, FM10K_ITR2(vf_v_idx), vf_v_idx - 1);
1074
1075         /* zero out MBMEM, VLAN_TABLE, RETA, RSSRK, and MRQC registers */
1076         for (i = FM10K_VFMBMEM_LEN; i--;)
1077                 FM10K_WRITE_REG(hw, FM10K_MBMEM_VF(vf_idx, i), 0);
1078         for (i = FM10K_VLAN_TABLE_SIZE; i--;)
1079                 FM10K_WRITE_REG(hw, FM10K_VLAN_TABLE(vf_info->vsi, i), 0);
1080         for (i = FM10K_RETA_SIZE; i--;)
1081                 FM10K_WRITE_REG(hw, FM10K_RETA(vf_info->vsi, i), 0);
1082         for (i = FM10K_RSSRK_SIZE; i--;)
1083                 FM10K_WRITE_REG(hw, FM10K_RSSRK(vf_info->vsi, i), 0);
1084         FM10K_WRITE_REG(hw, FM10K_MRQC(vf_info->vsi), 0);
1085
1086         /* Update base address registers to contain MAC address */
1087         if (FM10K_IS_VALID_ETHER_ADDR(vf_info->mac)) {
1088                 tdbal = (((u32)vf_info->mac[3]) << 24) |
1089                         (((u32)vf_info->mac[4]) << 16) |
1090                         (((u32)vf_info->mac[5]) << 8);
1091                 tdbah = (((u32)0xFF)       << 24) |
1092                         (((u32)vf_info->mac[0]) << 16) |
1093                         (((u32)vf_info->mac[1]) << 8) |
1094                         ((u32)vf_info->mac[2]);
1095         }
1096
1097         /* map queue pairs back to VF from last to first */
1098         for (i = queues_per_pool; i--;) {
1099                 FM10K_WRITE_REG(hw, FM10K_TDBAL(vf_q_idx + i), tdbal);
1100                 FM10K_WRITE_REG(hw, FM10K_TDBAH(vf_q_idx + i), tdbah);
1101                 /* See definition of FM10K_TDLEN_ITR_SCALE_SHIFT for an
1102                  * explanation of how TDLEN is used.
1103                  */
1104                 FM10K_WRITE_REG(hw, FM10K_TDLEN(vf_q_idx + i),
1105                                 hw->mac.itr_scale <<
1106                                 FM10K_TDLEN_ITR_SCALE_SHIFT);
1107                 FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx + i), vf_q_idx + i);
1108                 FM10K_WRITE_REG(hw, FM10K_RQMAP(qmap_idx + i), vf_q_idx + i);
1109         }
1110
1111         /* repeat the first ring for all the remaining VF rings */
1112         for (i = queues_per_pool; i < qmap_stride; i++) {
1113                 FM10K_WRITE_REG(hw, FM10K_TQMAP(qmap_idx + i), vf_q_idx);
1114                 FM10K_WRITE_REG(hw, FM10K_RQMAP(qmap_idx + i), vf_q_idx);
1115         }
1116
1117         return FM10K_SUCCESS;
1118 }
1119
1120 /**
1121  *  fm10k_iov_set_lport_pf - Assign and enable a logical port for a given VF
1122  *  @hw: pointer to hardware structure
1123  *  @vf_info: pointer to VF information structure
1124  *  @lport_idx: Logical port offset from the hardware glort
1125  *  @flags: Set of capability flags to extend port beyond basic functionality
1126  *
1127  *  This function allows enabling a VF port by assigning it a GLORT and
1128  *  setting the flags so that it can enable an Rx mode.
1129  **/
1130 STATIC s32 fm10k_iov_set_lport_pf(struct fm10k_hw *hw,
1131                                   struct fm10k_vf_info *vf_info,
1132                                   u16 lport_idx, u8 flags)
1133 {
1134         u16 glort = (hw->mac.dglort_map + lport_idx) & FM10K_DGLORTMAP_NONE;
1135
1136         DEBUGFUNC("fm10k_iov_set_lport_state_pf");
1137
1138         /* if glort is not valid return error */
1139         if (!fm10k_glort_valid_pf(hw, glort))
1140                 return FM10K_ERR_PARAM;
1141
1142         vf_info->vf_flags = flags | FM10K_VF_FLAG_NONE_CAPABLE;
1143         vf_info->glort = glort;
1144
1145         return FM10K_SUCCESS;
1146 }
1147
1148 /**
1149  *  fm10k_iov_reset_lport_pf - Disable a logical port for a given VF
1150  *  @hw: pointer to hardware structure
1151  *  @vf_info: pointer to VF information structure
1152  *
1153  *  This function disables a VF port by stripping it of a GLORT and
1154  *  setting the flags so that it cannot enable any Rx mode.
1155  **/
1156 STATIC void fm10k_iov_reset_lport_pf(struct fm10k_hw *hw,
1157                                      struct fm10k_vf_info *vf_info)
1158 {
1159         u32 msg[1];
1160
1161         DEBUGFUNC("fm10k_iov_reset_lport_state_pf");
1162
1163         /* need to disable the port if it is already enabled */
1164         if (FM10K_VF_FLAG_ENABLED(vf_info)) {
1165                 /* notify switch that this port has been disabled */
1166                 fm10k_update_lport_state_pf(hw, vf_info->glort, 1, false);
1167
1168                 /* generate port state response to notify VF it is not ready */
1169                 fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
1170                 vf_info->mbx.ops.enqueue_tx(hw, &vf_info->mbx, msg);
1171         }
1172
1173         /* clear flags and glort if it exists */
1174         vf_info->vf_flags = 0;
1175         vf_info->glort = 0;
1176 }
1177
1178 /**
1179  *  fm10k_iov_update_stats_pf - Updates hardware related statistics for VFs
1180  *  @hw: pointer to hardware structure
1181  *  @q: stats for all queues of a VF
1182  *  @vf_idx: index of VF
1183  *
1184  *  This function collects queue stats for VFs.
1185  **/
1186 STATIC void fm10k_iov_update_stats_pf(struct fm10k_hw *hw,
1187                                       struct fm10k_hw_stats_q *q,
1188                                       u16 vf_idx)
1189 {
1190         u32 idx, qpp;
1191
1192         /* get stats for all of the queues */
1193         qpp = fm10k_queues_per_pool(hw);
1194         idx = fm10k_vf_queue_index(hw, vf_idx);
1195         fm10k_update_hw_stats_q(hw, q, idx, qpp);
1196 }
1197
1198 /**
1199  *  fm10k_iov_msg_msix_pf - Message handler for MSI-X request from VF
1200  *  @hw: Pointer to hardware structure
1201  *  @results: Pointer array to message, results[0] is pointer to message
1202  *  @mbx: Pointer to mailbox information structure
1203  *
1204  *  This function is a default handler for MSI-X requests from the VF.  The
1205  *  assumption is that in this case it is acceptable to just directly
1206  *  hand off the message from the VF to the underlying shared code.
1207  **/
1208 s32 fm10k_iov_msg_msix_pf(struct fm10k_hw *hw, u32 **results,
1209                           struct fm10k_mbx_info *mbx)
1210 {
1211         struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;
1212         u8 vf_idx = vf_info->vf_idx;
1213
1214         UNREFERENCED_1PARAMETER(results);
1215         DEBUGFUNC("fm10k_iov_msg_msix_pf");
1216
1217         return hw->iov.ops.assign_int_moderator(hw, vf_idx);
1218 }
1219
1220 /**
1221  * fm10k_iov_select_vid - Select correct default VLAN ID
1222  * @hw: Pointer to hardware structure
1223  * @vid: VLAN ID to correct
1224  *
1225  * Will report an error if the VLAN ID is out of range. For VID = 0, it will
1226  * return either the pf_vid or sw_vid depending on which one is set.
1227  */
1228 STATIC s32 fm10k_iov_select_vid(struct fm10k_vf_info *vf_info, u16 vid)
1229 {
1230         if (!vid)
1231                 return vf_info->pf_vid ? vf_info->pf_vid : vf_info->sw_vid;
1232         else if (vf_info->pf_vid && vid != vf_info->pf_vid)
1233                 return FM10K_ERR_PARAM;
1234         else
1235                 return vid;
1236 }
1237
1238 /**
1239  *  fm10k_iov_msg_mac_vlan_pf - Message handler for MAC/VLAN request from VF
1240  *  @hw: Pointer to hardware structure
1241  *  @results: Pointer array to message, results[0] is pointer to message
1242  *  @mbx: Pointer to mailbox information structure
1243  *
1244  *  This function is a default handler for MAC/VLAN requests from the VF.
1245  *  The assumption is that in this case it is acceptable to just directly
1246  *  hand off the message from the VF to the underlying shared code.
1247  **/
1248 s32 fm10k_iov_msg_mac_vlan_pf(struct fm10k_hw *hw, u32 **results,
1249                               struct fm10k_mbx_info *mbx)
1250 {
1251         struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;
1252         u8 mac[ETH_ALEN];
1253         u32 *result;
1254         int err = FM10K_SUCCESS;
1255         bool set;
1256         u16 vlan;
1257         u32 vid;
1258
1259         DEBUGFUNC("fm10k_iov_msg_mac_vlan_pf");
1260
1261         /* we shouldn't be updating rules on a disabled interface */
1262         if (!FM10K_VF_FLAG_ENABLED(vf_info))
1263                 err = FM10K_ERR_PARAM;
1264
1265         if (!err && !!results[FM10K_MAC_VLAN_MSG_VLAN]) {
1266                 result = results[FM10K_MAC_VLAN_MSG_VLAN];
1267
1268                 /* record VLAN id requested */
1269                 err = fm10k_tlv_attr_get_u32(result, &vid);
1270                 if (err)
1271                         return err;
1272
1273                 set = !(vid & FM10K_VLAN_CLEAR);
1274                 vid &= ~FM10K_VLAN_CLEAR;
1275
1276                 /* if the length field has been set, this is a multi-bit
1277                  * update request. For multi-bit requests, simply disallow
1278                  * them when the pf_vid has been set. In this case, the PF
1279                  * should have already cleared the VLAN_TABLE, and if we
1280                  * allowed them, it could allow a rogue VF to receive traffic
1281                  * on a VLAN it was not assigned. In the single-bit case, we
1282                  * need to modify requests for VLAN 0 to use the default PF or
1283                  * SW vid when assigned.
1284                  */
1285
1286                 if (vid >> 16) {
1287                         /* prevent multi-bit requests when PF has
1288                          * administratively set the VLAN for this VF
1289                          */
1290                         if (vf_info->pf_vid)
1291                                 return FM10K_ERR_PARAM;
1292                 } else {
1293                         err = fm10k_iov_select_vid(vf_info, (u16)vid);
1294                         if (err < 0)
1295                                 return err;
1296
1297                         vid = err;
1298                 }
1299
1300                 /* update VSI info for VF in regards to VLAN table */
1301                 err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set);
1302         }
1303
1304         if (!err && !!results[FM10K_MAC_VLAN_MSG_MAC]) {
1305                 result = results[FM10K_MAC_VLAN_MSG_MAC];
1306
1307                 /* record unicast MAC address requested */
1308                 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);
1309                 if (err)
1310                         return err;
1311
1312                 /* block attempts to set MAC for a locked device */
1313                 if (FM10K_IS_VALID_ETHER_ADDR(vf_info->mac) &&
1314                     memcmp(mac, vf_info->mac, ETH_ALEN))
1315                         return FM10K_ERR_PARAM;
1316
1317                 set = !(vlan & FM10K_VLAN_CLEAR);
1318                 vlan &= ~FM10K_VLAN_CLEAR;
1319
1320                 err = fm10k_iov_select_vid(vf_info, vlan);
1321                 if (err < 0)
1322                         return err;
1323
1324                 vlan = (u16)err;
1325
1326                 /* notify switch of request for new unicast address */
1327                 err = hw->mac.ops.update_uc_addr(hw, vf_info->glort,
1328                                                  mac, vlan, set, 0);
1329         }
1330
1331         if (!err && !!results[FM10K_MAC_VLAN_MSG_MULTICAST]) {
1332                 result = results[FM10K_MAC_VLAN_MSG_MULTICAST];
1333
1334                 /* record multicast MAC address requested */
1335                 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);
1336                 if (err)
1337                         return err;
1338
1339                 /* verify that the VF is allowed to request multicast */
1340                 if (!(vf_info->vf_flags & FM10K_VF_FLAG_MULTI_ENABLED))
1341                         return FM10K_ERR_PARAM;
1342
1343                 set = !(vlan & FM10K_VLAN_CLEAR);
1344                 vlan &= ~FM10K_VLAN_CLEAR;
1345
1346                 err = fm10k_iov_select_vid(vf_info, vlan);
1347                 if (err < 0)
1348                         return err;
1349
1350                 vlan = (u16)err;
1351
1352                 /* notify switch of request for new multicast address */
1353                 err = hw->mac.ops.update_mc_addr(hw, vf_info->glort,
1354                                                  mac, vlan, set);
1355         }
1356
1357         return err;
1358 }
1359
1360 /**
1361  *  fm10k_iov_supported_xcast_mode_pf - Determine best match for xcast mode
1362  *  @vf_info: VF info structure containing capability flags
1363  *  @mode: Requested xcast mode
1364  *
1365  *  This function outputs the mode that most closely matches the requested
1366  *  mode.  If not modes match it will request we disable the port
1367  **/
1368 STATIC u8 fm10k_iov_supported_xcast_mode_pf(struct fm10k_vf_info *vf_info,
1369                                             u8 mode)
1370 {
1371         u8 vf_flags = vf_info->vf_flags;
1372
1373         /* match up mode to capabilities as best as possible */
1374         switch (mode) {
1375         case FM10K_XCAST_MODE_PROMISC:
1376                 if (vf_flags & FM10K_VF_FLAG_PROMISC_CAPABLE)
1377                         return FM10K_XCAST_MODE_PROMISC;
1378                 /* fallthough */
1379         case FM10K_XCAST_MODE_ALLMULTI:
1380                 if (vf_flags & FM10K_VF_FLAG_ALLMULTI_CAPABLE)
1381                         return FM10K_XCAST_MODE_ALLMULTI;
1382                 /* fallthough */
1383         case FM10K_XCAST_MODE_MULTI:
1384                 if (vf_flags & FM10K_VF_FLAG_MULTI_CAPABLE)
1385                         return FM10K_XCAST_MODE_MULTI;
1386                 /* fallthough */
1387         case FM10K_XCAST_MODE_NONE:
1388                 if (vf_flags & FM10K_VF_FLAG_NONE_CAPABLE)
1389                         return FM10K_XCAST_MODE_NONE;
1390                 /* fallthough */
1391         default:
1392                 break;
1393         }
1394
1395         /* disable interface as it should not be able to request any */
1396         return FM10K_XCAST_MODE_DISABLE;
1397 }
1398
1399 /**
1400  *  fm10k_iov_msg_lport_state_pf - Message handler for port state requests
1401  *  @hw: Pointer to hardware structure
1402  *  @results: Pointer array to message, results[0] is pointer to message
1403  *  @mbx: Pointer to mailbox information structure
1404  *
1405  *  This function is a default handler for port state requests.  The port
1406  *  state requests for now are basic and consist of enabling or disabling
1407  *  the port.
1408  **/
1409 s32 fm10k_iov_msg_lport_state_pf(struct fm10k_hw *hw, u32 **results,
1410                                  struct fm10k_mbx_info *mbx)
1411 {
1412         struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;
1413         u32 *result;
1414         s32 err = FM10K_SUCCESS;
1415         u32 msg[2];
1416         u8 mode = 0;
1417
1418         DEBUGFUNC("fm10k_iov_msg_lport_state_pf");
1419
1420         /* verify VF is allowed to enable even minimal mode */
1421         if (!(vf_info->vf_flags & FM10K_VF_FLAG_NONE_CAPABLE))
1422                 return FM10K_ERR_PARAM;
1423
1424         if (!!results[FM10K_LPORT_STATE_MSG_XCAST_MODE]) {
1425                 result = results[FM10K_LPORT_STATE_MSG_XCAST_MODE];
1426
1427                 /* XCAST mode update requested */
1428                 err = fm10k_tlv_attr_get_u8(result, &mode);
1429                 if (err)
1430                         return FM10K_ERR_PARAM;
1431
1432                 /* prep for possible demotion depending on capabilities */
1433                 mode = fm10k_iov_supported_xcast_mode_pf(vf_info, mode);
1434
1435                 /* if mode is not currently enabled, enable it */
1436                 if (!(FM10K_VF_FLAG_ENABLED(vf_info) & BIT(mode)))
1437                         fm10k_update_xcast_mode_pf(hw, vf_info->glort, mode);
1438
1439                 /* swap mode back to a bit flag */
1440                 mode = FM10K_VF_FLAG_SET_MODE(mode);
1441         } else if (!results[FM10K_LPORT_STATE_MSG_DISABLE]) {
1442                 /* need to disable the port if it is already enabled */
1443                 if (FM10K_VF_FLAG_ENABLED(vf_info))
1444                         err = fm10k_update_lport_state_pf(hw, vf_info->glort,
1445                                                           1, false);
1446
1447                 /* we need to clear VF_FLAG_ENABLED flags in order to ensure
1448                  * that we actually re-enable the LPORT state below. Note that
1449                  * this has no impact if the VF is already disabled, as the
1450                  * flags are already cleared.
1451                  */
1452                 if (!err)
1453                         vf_info->vf_flags = FM10K_VF_FLAG_CAPABLE(vf_info);
1454
1455                 /* when enabling the port we should reset the rate limiters */
1456                 hw->iov.ops.configure_tc(hw, vf_info->vf_idx, vf_info->rate);
1457
1458                 /* set mode for minimal functionality */
1459                 mode = FM10K_VF_FLAG_SET_MODE_NONE;
1460
1461                 /* generate port state response to notify VF it is ready */
1462                 fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
1463                 fm10k_tlv_attr_put_bool(msg, FM10K_LPORT_STATE_MSG_READY);
1464                 mbx->ops.enqueue_tx(hw, mbx, msg);
1465         }
1466
1467         /* if enable state toggled note the update */
1468         if (!err && (!FM10K_VF_FLAG_ENABLED(vf_info) != !mode))
1469                 err = fm10k_update_lport_state_pf(hw, vf_info->glort, 1,
1470                                                   !!mode);
1471
1472         /* if state change succeeded, then update our stored state */
1473         mode |= FM10K_VF_FLAG_CAPABLE(vf_info);
1474         if (!err)
1475                 vf_info->vf_flags = mode;
1476
1477         return err;
1478 }
1479
1480 #ifndef NO_DEFAULT_SRIOV_MSG_HANDLERS
1481 const struct fm10k_msg_data fm10k_iov_msg_data_pf[] = {
1482         FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
1483         FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf),
1484         FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_mac_vlan_pf),
1485         FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf),
1486         FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
1487 };
1488
1489 #endif
1490 /**
1491  *  fm10k_update_stats_hw_pf - Updates hardware related statistics of PF
1492  *  @hw: pointer to hardware structure
1493  *  @stats: pointer to the stats structure to update
1494  *
1495  *  This function collects and aggregates global and per queue hardware
1496  *  statistics.
1497  **/
1498 STATIC void fm10k_update_hw_stats_pf(struct fm10k_hw *hw,
1499                                      struct fm10k_hw_stats *stats)
1500 {
1501         u32 timeout, ur, ca, um, xec, vlan_drop, loopback_drop, nodesc_drop;
1502         u32 id, id_prev;
1503
1504         DEBUGFUNC("fm10k_update_hw_stats_pf");
1505
1506         /* Use Tx queue 0 as a canary to detect a reset */
1507         id = FM10K_READ_REG(hw, FM10K_TXQCTL(0));
1508
1509         /* Read Global Statistics */
1510         do {
1511                 timeout = fm10k_read_hw_stats_32b(hw, FM10K_STATS_TIMEOUT,
1512                                                   &stats->timeout);
1513                 ur = fm10k_read_hw_stats_32b(hw, FM10K_STATS_UR, &stats->ur);
1514                 ca = fm10k_read_hw_stats_32b(hw, FM10K_STATS_CA, &stats->ca);
1515                 um = fm10k_read_hw_stats_32b(hw, FM10K_STATS_UM, &stats->um);
1516                 xec = fm10k_read_hw_stats_32b(hw, FM10K_STATS_XEC, &stats->xec);
1517                 vlan_drop = fm10k_read_hw_stats_32b(hw, FM10K_STATS_VLAN_DROP,
1518                                                     &stats->vlan_drop);
1519                 loopback_drop =
1520                         fm10k_read_hw_stats_32b(hw,
1521                                                 FM10K_STATS_LOOPBACK_DROP,
1522                                                 &stats->loopback_drop);
1523                 nodesc_drop = fm10k_read_hw_stats_32b(hw,
1524                                                       FM10K_STATS_NODESC_DROP,
1525                                                       &stats->nodesc_drop);
1526
1527                 /* if value has not changed then we have consistent data */
1528                 id_prev = id;
1529                 id = FM10K_READ_REG(hw, FM10K_TXQCTL(0));
1530         } while ((id ^ id_prev) & FM10K_TXQCTL_ID_MASK);
1531
1532         /* drop non-ID bits and set VALID ID bit */
1533         id &= FM10K_TXQCTL_ID_MASK;
1534         id |= FM10K_STAT_VALID;
1535
1536         /* Update Global Statistics */
1537         if (stats->stats_idx == id) {
1538                 stats->timeout.count += timeout;
1539                 stats->ur.count += ur;
1540                 stats->ca.count += ca;
1541                 stats->um.count += um;
1542                 stats->xec.count += xec;
1543                 stats->vlan_drop.count += vlan_drop;
1544                 stats->loopback_drop.count += loopback_drop;
1545                 stats->nodesc_drop.count += nodesc_drop;
1546         }
1547
1548         /* Update bases and record current PF id */
1549         fm10k_update_hw_base_32b(&stats->timeout, timeout);
1550         fm10k_update_hw_base_32b(&stats->ur, ur);
1551         fm10k_update_hw_base_32b(&stats->ca, ca);
1552         fm10k_update_hw_base_32b(&stats->um, um);
1553         fm10k_update_hw_base_32b(&stats->xec, xec);
1554         fm10k_update_hw_base_32b(&stats->vlan_drop, vlan_drop);
1555         fm10k_update_hw_base_32b(&stats->loopback_drop, loopback_drop);
1556         fm10k_update_hw_base_32b(&stats->nodesc_drop, nodesc_drop);
1557         stats->stats_idx = id;
1558
1559         /* Update Queue Statistics */
1560         fm10k_update_hw_stats_q(hw, stats->q, 0, hw->mac.max_queues);
1561 }
1562
1563 /**
1564  *  fm10k_rebind_hw_stats_pf - Resets base for hardware statistics of PF
1565  *  @hw: pointer to hardware structure
1566  *  @stats: pointer to the stats structure to update
1567  *
1568  *  This function resets the base for global and per queue hardware
1569  *  statistics.
1570  **/
1571 STATIC void fm10k_rebind_hw_stats_pf(struct fm10k_hw *hw,
1572                                      struct fm10k_hw_stats *stats)
1573 {
1574         DEBUGFUNC("fm10k_rebind_hw_stats_pf");
1575
1576         /* Unbind Global Statistics */
1577         fm10k_unbind_hw_stats_32b(&stats->timeout);
1578         fm10k_unbind_hw_stats_32b(&stats->ur);
1579         fm10k_unbind_hw_stats_32b(&stats->ca);
1580         fm10k_unbind_hw_stats_32b(&stats->um);
1581         fm10k_unbind_hw_stats_32b(&stats->xec);
1582         fm10k_unbind_hw_stats_32b(&stats->vlan_drop);
1583         fm10k_unbind_hw_stats_32b(&stats->loopback_drop);
1584         fm10k_unbind_hw_stats_32b(&stats->nodesc_drop);
1585
1586         /* Unbind Queue Statistics */
1587         fm10k_unbind_hw_stats_q(stats->q, 0, hw->mac.max_queues);
1588
1589         /* Reinitialize bases for all stats */
1590         fm10k_update_hw_stats_pf(hw, stats);
1591 }
1592
1593 /**
1594  *  fm10k_set_dma_mask_pf - Configures PhyAddrSpace to limit DMA to system
1595  *  @hw: pointer to hardware structure
1596  *  @dma_mask: 64 bit DMA mask required for platform
1597  *
1598  *  This function sets the PHYADDR.PhyAddrSpace bits for the endpoint in order
1599  *  to limit the access to memory beyond what is physically in the system.
1600  **/
1601 STATIC void fm10k_set_dma_mask_pf(struct fm10k_hw *hw, u64 dma_mask)
1602 {
1603         /* we need to write the upper 32 bits of DMA mask to PhyAddrSpace */
1604         u32 phyaddr = (u32)(dma_mask >> 32);
1605
1606         DEBUGFUNC("fm10k_set_dma_mask_pf");
1607
1608         FM10K_WRITE_REG(hw, FM10K_PHYADDR, phyaddr);
1609 }
1610
1611 /**
1612  *  fm10k_get_fault_pf - Record a fault in one of the interface units
1613  *  @hw: pointer to hardware structure
1614  *  @type: pointer to fault type register offset
1615  *  @fault: pointer to memory location to record the fault
1616  *
1617  *  Record the fault register contents to the fault data structure and
1618  *  clear the entry from the register.
1619  *
1620  *  Returns ERR_PARAM if invalid register is specified or no error is present.
1621  **/
1622 STATIC s32 fm10k_get_fault_pf(struct fm10k_hw *hw, int type,
1623                               struct fm10k_fault *fault)
1624 {
1625         u32 func;
1626
1627         DEBUGFUNC("fm10k_get_fault_pf");
1628
1629         /* verify the fault register is in range and is aligned */
1630         switch (type) {
1631         case FM10K_PCA_FAULT:
1632         case FM10K_THI_FAULT:
1633         case FM10K_FUM_FAULT:
1634                 break;
1635         default:
1636                 return FM10K_ERR_PARAM;
1637         }
1638
1639         /* only service faults that are valid */
1640         func = FM10K_READ_REG(hw, type + FM10K_FAULT_FUNC);
1641         if (!(func & FM10K_FAULT_FUNC_VALID))
1642                 return FM10K_ERR_PARAM;
1643
1644         /* read remaining fields */
1645         fault->address = FM10K_READ_REG(hw, type + FM10K_FAULT_ADDR_HI);
1646         fault->address <<= 32;
1647         fault->address = FM10K_READ_REG(hw, type + FM10K_FAULT_ADDR_LO);
1648         fault->specinfo = FM10K_READ_REG(hw, type + FM10K_FAULT_SPECINFO);
1649
1650         /* clear valid bit to allow for next error */
1651         FM10K_WRITE_REG(hw, type + FM10K_FAULT_FUNC, FM10K_FAULT_FUNC_VALID);
1652
1653         /* Record which function triggered the error */
1654         if (func & FM10K_FAULT_FUNC_PF)
1655                 fault->func = 0;
1656         else
1657                 fault->func = 1 + ((func & FM10K_FAULT_FUNC_VF_MASK) >>
1658                                    FM10K_FAULT_FUNC_VF_SHIFT);
1659
1660         /* record fault type */
1661         fault->type = func & FM10K_FAULT_FUNC_TYPE_MASK;
1662
1663         return FM10K_SUCCESS;
1664 }
1665
1666 /**
1667  *  fm10k_request_lport_map_pf - Request LPORT map from the switch API
1668  *  @hw: pointer to hardware structure
1669  *
1670  **/
1671 STATIC s32 fm10k_request_lport_map_pf(struct fm10k_hw *hw)
1672 {
1673         struct fm10k_mbx_info *mbx = &hw->mbx;
1674         u32 msg[1];
1675
1676         DEBUGFUNC("fm10k_request_lport_pf");
1677
1678         /* issue request asking for LPORT map */
1679         fm10k_tlv_msg_init(msg, FM10K_PF_MSG_ID_LPORT_MAP);
1680
1681         /* load onto outgoing mailbox */
1682         return mbx->ops.enqueue_tx(hw, mbx, msg);
1683 }
1684
1685 /**
1686  *  fm10k_get_host_state_pf - Returns the state of the switch and mailbox
1687  *  @hw: pointer to hardware structure
1688  *  @switch_ready: pointer to boolean value that will record switch state
1689  *
1690  *  This function will check the DMA_CTRL2 register and mailbox in order
1691  *  to determine if the switch is ready for the PF to begin requesting
1692  *  addresses and mapping traffic to the local interface.
1693  **/
1694 STATIC s32 fm10k_get_host_state_pf(struct fm10k_hw *hw, bool *switch_ready)
1695 {
1696         u32 dma_ctrl2;
1697
1698         DEBUGFUNC("fm10k_get_host_state_pf");
1699
1700         /* verify the switch is ready for interaction */
1701         dma_ctrl2 = FM10K_READ_REG(hw, FM10K_DMA_CTRL2);
1702         if (!(dma_ctrl2 & FM10K_DMA_CTRL2_SWITCH_READY))
1703                 return FM10K_SUCCESS;
1704
1705         /* retrieve generic host state info */
1706         return fm10k_get_host_state_generic(hw, switch_ready);
1707 }
1708
1709 /* This structure defines the attibutes to be parsed below */
1710 const struct fm10k_tlv_attr fm10k_lport_map_msg_attr[] = {
1711         FM10K_TLV_ATTR_LE_STRUCT(FM10K_PF_ATTR_ID_ERR,
1712                                  sizeof(struct fm10k_swapi_error)),
1713         FM10K_TLV_ATTR_U32(FM10K_PF_ATTR_ID_LPORT_MAP),
1714         FM10K_TLV_ATTR_LAST
1715 };
1716
1717 /**
1718  *  fm10k_msg_lport_map_pf - Message handler for lport_map message from SM
1719  *  @hw: Pointer to hardware structure
1720  *  @results: pointer array containing parsed data
1721  *  @mbx: Pointer to mailbox information structure
1722  *
1723  *  This handler configures the lport mapping based on the reply from the
1724  *  switch API.
1725  **/
1726 s32 fm10k_msg_lport_map_pf(struct fm10k_hw *hw, u32 **results,
1727                            struct fm10k_mbx_info *mbx)
1728 {
1729         u16 glort, mask;
1730         u32 dglort_map;
1731         s32 err;
1732
1733         UNREFERENCED_1PARAMETER(mbx);
1734         DEBUGFUNC("fm10k_msg_lport_map_pf");
1735
1736         err = fm10k_tlv_attr_get_u32(results[FM10K_PF_ATTR_ID_LPORT_MAP],
1737                                      &dglort_map);
1738         if (err)
1739                 return err;
1740
1741         /* extract values out of the header */
1742         glort = FM10K_MSG_HDR_FIELD_GET(dglort_map, LPORT_MAP_GLORT);
1743         mask = FM10K_MSG_HDR_FIELD_GET(dglort_map, LPORT_MAP_MASK);
1744
1745         /* verify mask is set and none of the masked bits in glort are set */
1746         if (!mask || (glort & ~mask))
1747                 return FM10K_ERR_PARAM;
1748
1749         /* verify the mask is contiguous, and that it is 1's followed by 0's */
1750         if (((~(mask - 1) & mask) + mask) & FM10K_DGLORTMAP_NONE)
1751                 return FM10K_ERR_PARAM;
1752
1753         /* record the glort, mask, and port count */
1754         hw->mac.dglort_map = dglort_map;
1755
1756         return FM10K_SUCCESS;
1757 }
1758
1759 const struct fm10k_tlv_attr fm10k_update_pvid_msg_attr[] = {
1760         FM10K_TLV_ATTR_U32(FM10K_PF_ATTR_ID_UPDATE_PVID),
1761         FM10K_TLV_ATTR_LAST
1762 };
1763
1764 /**
1765  *  fm10k_msg_update_pvid_pf - Message handler for port VLAN message from SM
1766  *  @hw: Pointer to hardware structure
1767  *  @results: pointer array containing parsed data
1768  *  @mbx: Pointer to mailbox information structure
1769  *
1770  *  This handler configures the default VLAN for the PF
1771  **/
1772 static s32 fm10k_msg_update_pvid_pf(struct fm10k_hw *hw, u32 **results,
1773                                     struct fm10k_mbx_info *mbx)
1774 {
1775         u16 glort, pvid;
1776         u32 pvid_update;
1777         s32 err;
1778
1779         UNREFERENCED_1PARAMETER(mbx);
1780         DEBUGFUNC("fm10k_msg_update_pvid_pf");
1781
1782         err = fm10k_tlv_attr_get_u32(results[FM10K_PF_ATTR_ID_UPDATE_PVID],
1783                                      &pvid_update);
1784         if (err)
1785                 return err;
1786
1787         /* extract values from the pvid update */
1788         glort = FM10K_MSG_HDR_FIELD_GET(pvid_update, UPDATE_PVID_GLORT);
1789         pvid = FM10K_MSG_HDR_FIELD_GET(pvid_update, UPDATE_PVID_PVID);
1790
1791         /* if glort is not valid return error */
1792         if (!fm10k_glort_valid_pf(hw, glort))
1793                 return FM10K_ERR_PARAM;
1794
1795         /* verify VLAN ID is valid */
1796         if (pvid >= FM10K_VLAN_TABLE_VID_MAX)
1797                 return FM10K_ERR_PARAM;
1798
1799         /* record the port VLAN ID value */
1800         hw->mac.default_vid = pvid;
1801
1802         return FM10K_SUCCESS;
1803 }
1804
1805 /**
1806  *  fm10k_record_global_table_data - Move global table data to swapi table info
1807  *  @from: pointer to source table data structure
1808  *  @to: pointer to destination table info structure
1809  *
1810  *  This function is will copy table_data to the table_info contained in
1811  *  the hw struct.
1812  **/
1813 static void fm10k_record_global_table_data(struct fm10k_global_table_data *from,
1814                                            struct fm10k_swapi_table_info *to)
1815 {
1816         /* convert from le32 struct to CPU byte ordered values */
1817         to->used = FM10K_LE32_TO_CPU(from->used);
1818         to->avail = FM10K_LE32_TO_CPU(from->avail);
1819 }
1820
1821 const struct fm10k_tlv_attr fm10k_err_msg_attr[] = {
1822         FM10K_TLV_ATTR_LE_STRUCT(FM10K_PF_ATTR_ID_ERR,
1823                                  sizeof(struct fm10k_swapi_error)),
1824         FM10K_TLV_ATTR_LAST
1825 };
1826
1827 /**
1828  *  fm10k_msg_err_pf - Message handler for error reply
1829  *  @hw: Pointer to hardware structure
1830  *  @results: pointer array containing parsed data
1831  *  @mbx: Pointer to mailbox information structure
1832  *
1833  *  This handler will capture the data for any error replies to previous
1834  *  messages that the PF has sent.
1835  **/
1836 s32 fm10k_msg_err_pf(struct fm10k_hw *hw, u32 **results,
1837                      struct fm10k_mbx_info *mbx)
1838 {
1839         struct fm10k_swapi_error err_msg;
1840         s32 err;
1841
1842         UNREFERENCED_1PARAMETER(mbx);
1843         DEBUGFUNC("fm10k_msg_err_pf");
1844
1845         /* extract structure from message */
1846         err = fm10k_tlv_attr_get_le_struct(results[FM10K_PF_ATTR_ID_ERR],
1847                                            &err_msg, sizeof(err_msg));
1848         if (err)
1849                 return err;
1850
1851         /* record table status */
1852         fm10k_record_global_table_data(&err_msg.mac, &hw->swapi.mac);
1853         fm10k_record_global_table_data(&err_msg.nexthop, &hw->swapi.nexthop);
1854         fm10k_record_global_table_data(&err_msg.ffu, &hw->swapi.ffu);
1855
1856         /* record SW API status value */
1857         hw->swapi.status = FM10K_LE32_TO_CPU(err_msg.status);
1858
1859         return FM10K_SUCCESS;
1860 }
1861
1862 /* currently there is no shared 1588 timestamp handler */
1863
1864 const struct fm10k_tlv_attr fm10k_1588_timestamp_msg_attr[] = {
1865         FM10K_TLV_ATTR_LE_STRUCT(FM10K_PF_ATTR_ID_1588_TIMESTAMP,
1866                                  sizeof(struct fm10k_swapi_1588_timestamp)),
1867         FM10K_TLV_ATTR_LAST
1868 };
1869
1870 const struct fm10k_tlv_attr fm10k_1588_clock_owner_attr[] = {
1871         FM10K_TLV_ATTR_LE_STRUCT(FM10K_PF_ATTR_ID_1588_CLOCK_OWNER,
1872                                  sizeof(struct fm10k_swapi_1588_clock_owner)),
1873         FM10K_TLV_ATTR_LAST
1874 };
1875
1876 const struct fm10k_tlv_attr fm10k_master_clk_offset_attr[] = {
1877         FM10K_TLV_ATTR_U64(FM10K_PF_ATTR_ID_MASTER_CLK_OFFSET),
1878         FM10K_TLV_ATTR_LAST
1879 };
1880
1881 /**
1882  *  fm10k_iov_notify_offset_pf - Notify VF of change in PTP offset
1883  *  @hw: pointer to hardware structure
1884  *  @vf_info: pointer to the vf info structure
1885  *  @offset: 64bit unsigned offset from hardware SYSTIME
1886  *
1887  *  This function sends a message to a given VF to notify it of PTP offset
1888  *  changes.
1889  **/
1890 STATIC void fm10k_iov_notify_offset_pf(struct fm10k_hw *hw,
1891                                        struct fm10k_vf_info *vf_info,
1892                                        u64 offset)
1893 {
1894         u32 msg[4];
1895
1896         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_1588);
1897         fm10k_tlv_attr_put_u64(msg, FM10K_1588_MSG_CLK_OFFSET, offset);
1898
1899         if (vf_info->mbx.ops.enqueue_tx)
1900                 vf_info->mbx.ops.enqueue_tx(hw, &vf_info->mbx, msg);
1901 }
1902
1903 /**
1904  *  fm10k_msg_1588_clock_owner_pf - Message handler for clock ownership from SM
1905  *  @hw: pointer to hardware structure
1906  *  @results: pointer to array containing parsed data,
1907  *  @mbx: Pointer to mailbox information structure
1908  *
1909  *  This handler configures the FM10K_HW_FLAG_CLOCK_OWNER field for the PF
1910  */
1911 s32 fm10k_msg_1588_clock_owner_pf(struct fm10k_hw *hw, u32 **results,
1912                                   struct fm10k_mbx_info *mbx)
1913 {
1914         struct fm10k_swapi_1588_clock_owner msg;
1915         u16 glort;
1916         s32 err;
1917
1918         UNREFERENCED_1PARAMETER(mbx);
1919         DEBUGFUNC("fm10k_msg_1588_clock_owner");
1920
1921         err = fm10k_tlv_attr_get_le_struct(
1922                 results[FM10K_PF_ATTR_ID_1588_CLOCK_OWNER],
1923                 &msg, sizeof(msg));
1924         if (err)
1925                 return err;
1926
1927         /* We own the clock iff the glort matches us and the enabled field is
1928          * true. Otherwise, the clock must belong to some other port.
1929          */
1930         glort = le16_to_cpu(msg.glort);
1931         if (fm10k_glort_valid_pf(hw, glort) && msg.enabled)
1932                 hw->flags |= FM10K_HW_FLAG_CLOCK_OWNER;
1933         else
1934                 hw->flags &= ~FM10K_HW_FLAG_CLOCK_OWNER;
1935
1936         return FM10K_SUCCESS;
1937 }
1938
1939 /**
1940  *  fm10k_adjust_systime_pf - Adjust systime frequency
1941  *  @hw: pointer to hardware structure
1942  *  @ppb: adjustment rate in parts per billion
1943  *
1944  *  This function will adjust the SYSTIME_CFG register contained in BAR 4
1945  *  if this function is supported for BAR 4 access.  The adjustment amount
1946  *  is based on the parts per billion value provided and adjusted to a
1947  *  value based on parts per 2^48 clock cycles.
1948  *
1949  *  If adjustment is not supported or the requested value is too large
1950  *  we will return an error.
1951  **/
1952 STATIC s32 fm10k_adjust_systime_pf(struct fm10k_hw *hw, s32 ppb)
1953 {
1954         u64 systime_adjust;
1955
1956         DEBUGFUNC("fm10k_adjust_systime_pf");
1957
1958         /* ensure that we control the clock */
1959         if (!(hw->flags & FM10K_HW_FLAG_CLOCK_OWNER))
1960                 return FM10K_ERR_DEVICE_NOT_SUPPORTED;
1961
1962         /* if sw_addr is not set we don't have switch register access */
1963         if (!hw->sw_addr)
1964                 return ppb ? FM10K_ERR_PARAM : FM10K_SUCCESS;
1965
1966         /* we must convert the value from parts per billion to parts per
1967          * 2^48 cycles.  In addition I have opted to only use the 30 most
1968          * significant bits of the adjustment value as the 8 least
1969          * significant bits are located in another register and represent
1970          * a value significantly less than a part per billion, the result
1971          * of dropping the 8 least significant bits is that the adjustment
1972          * value is effectively multiplied by 2^8 when we write it.
1973          *
1974          * As a result of all this the math for this breaks down as follows:
1975          *      ppb / 10^9 == adjust * 2^8 / 2^48
1976          * If we solve this for adjust, and simplify it comes out as:
1977          *      ppb * 2^31 / 5^9 == adjust
1978          */
1979         systime_adjust = (ppb < 0) ? -ppb : ppb;
1980         systime_adjust <<= 31;
1981         do_div(systime_adjust, 1953125);
1982
1983         /* verify the requested adjustment value is in range */
1984         if (systime_adjust > FM10K_SW_SYSTIME_ADJUST_MASK)
1985                 return FM10K_ERR_PARAM;
1986
1987         if (ppb > 0)
1988                 systime_adjust |= FM10K_SW_SYSTIME_ADJUST_DIR_POSITIVE;
1989
1990         FM10K_WRITE_SW_REG(hw, FM10K_SW_SYSTIME_ADJUST, (u32)systime_adjust);
1991
1992         return FM10K_SUCCESS;
1993 }
1994
1995 /**
1996  *  fm10k_notify_offset_pf - Notify switch of change in PTP offset
1997  *  @hw: pointer to hardware structure
1998  *  @offset: 64bit unsigned offset of SYSTIME
1999  *
2000  *  This function sends a message to the switch to indicate a change in the
2001  *  offset of the hardware SYSTIME registers. The switch manager is
2002  *  responsible for transmitting this message to other hosts.
2003  */
2004 STATIC s32 fm10k_notify_offset_pf(struct fm10k_hw *hw, u64 offset)
2005 {
2006         struct fm10k_mbx_info *mbx = &hw->mbx;
2007         u32 msg[4];
2008
2009         DEBUGFUNC("fm10k_notify_offset_pf");
2010
2011         /* ensure that we control the clock */
2012         if (!(hw->flags & FM10K_HW_FLAG_CLOCK_OWNER))
2013                 return FM10K_ERR_DEVICE_NOT_SUPPORTED;
2014
2015         fm10k_tlv_msg_init(msg, FM10K_PF_MSG_ID_MASTER_CLK_OFFSET);
2016         fm10k_tlv_attr_put_u64(msg, FM10K_PF_ATTR_ID_MASTER_CLK_OFFSET, offset);
2017
2018         /* load onto outgoing mailbox */
2019         return mbx->ops.enqueue_tx(hw, mbx, msg);
2020 }
2021
2022 /**
2023  *  fm10k_read_systime_pf - Reads value of systime registers
2024  *  @hw: pointer to the hardware structure
2025  *
2026  *  Function reads the content of 2 registers, combined to represent a 64 bit
2027  *  value measured in nanosecods.  In order to guarantee the value is accurate
2028  *  we check the 32 most significant bits both before and after reading the
2029  *  32 least significant bits to verify they didn't change as we were reading
2030  *  the registers.
2031  **/
2032 static u64 fm10k_read_systime_pf(struct fm10k_hw *hw)
2033 {
2034         u32 systime_l, systime_h, systime_tmp;
2035
2036         systime_h = fm10k_read_reg(hw, FM10K_SYSTIME + 1);
2037
2038         do {
2039                 systime_tmp = systime_h;
2040                 systime_l = fm10k_read_reg(hw, FM10K_SYSTIME);
2041                 systime_h = fm10k_read_reg(hw, FM10K_SYSTIME + 1);
2042         } while (systime_tmp != systime_h);
2043
2044         return ((u64)systime_h << 32) | systime_l;
2045 }
2046
2047 static const struct fm10k_msg_data fm10k_msg_data_pf[] = {
2048         FM10K_PF_MSG_ERR_HANDLER(XCAST_MODES, fm10k_msg_err_pf),
2049         FM10K_PF_MSG_ERR_HANDLER(UPDATE_MAC_FWD_RULE, fm10k_msg_err_pf),
2050         FM10K_PF_MSG_LPORT_MAP_HANDLER(fm10k_msg_lport_map_pf),
2051         FM10K_PF_MSG_ERR_HANDLER(LPORT_CREATE, fm10k_msg_err_pf),
2052         FM10K_PF_MSG_ERR_HANDLER(LPORT_DELETE, fm10k_msg_err_pf),
2053         FM10K_PF_MSG_UPDATE_PVID_HANDLER(fm10k_msg_update_pvid_pf),
2054         FM10K_PF_MSG_1588_CLOCK_OWNER_HANDLER(fm10k_msg_1588_clock_owner_pf),
2055         FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
2056 };
2057
2058 /**
2059  *  fm10k_init_ops_pf - Inits func ptrs and MAC type
2060  *  @hw: pointer to hardware structure
2061  *
2062  *  Initialize the function pointers and assign the MAC type for PF.
2063  *  Does not touch the hardware.
2064  **/
2065 s32 fm10k_init_ops_pf(struct fm10k_hw *hw)
2066 {
2067         struct fm10k_mac_info *mac = &hw->mac;
2068         struct fm10k_iov_info *iov = &hw->iov;
2069
2070         DEBUGFUNC("fm10k_init_ops_pf");
2071
2072         fm10k_init_ops_generic(hw);
2073
2074         mac->ops.reset_hw = &fm10k_reset_hw_pf;
2075         mac->ops.init_hw = &fm10k_init_hw_pf;
2076         mac->ops.start_hw = &fm10k_start_hw_generic;
2077         mac->ops.stop_hw = &fm10k_stop_hw_generic;
2078 #ifndef NO_IS_SLOT_APPROPRIATE_CHECK
2079         mac->ops.is_slot_appropriate = &fm10k_is_slot_appropriate_pf;
2080 #endif
2081         mac->ops.update_vlan = &fm10k_update_vlan_pf;
2082         mac->ops.read_mac_addr = &fm10k_read_mac_addr_pf;
2083         mac->ops.update_uc_addr = &fm10k_update_uc_addr_pf;
2084         mac->ops.update_mc_addr = &fm10k_update_mc_addr_pf;
2085         mac->ops.update_xcast_mode = &fm10k_update_xcast_mode_pf;
2086         mac->ops.update_int_moderator = &fm10k_update_int_moderator_pf;
2087         mac->ops.update_lport_state = &fm10k_update_lport_state_pf;
2088         mac->ops.update_hw_stats = &fm10k_update_hw_stats_pf;
2089         mac->ops.rebind_hw_stats = &fm10k_rebind_hw_stats_pf;
2090         mac->ops.configure_dglort_map = &fm10k_configure_dglort_map_pf;
2091         mac->ops.set_dma_mask = &fm10k_set_dma_mask_pf;
2092         mac->ops.get_fault = &fm10k_get_fault_pf;
2093         mac->ops.get_host_state = &fm10k_get_host_state_pf;
2094         mac->ops.request_lport_map = &fm10k_request_lport_map_pf;
2095         mac->ops.adjust_systime = &fm10k_adjust_systime_pf;
2096         mac->ops.notify_offset = &fm10k_notify_offset_pf;
2097         mac->ops.read_systime = &fm10k_read_systime_pf;
2098
2099         mac->max_msix_vectors = fm10k_get_pcie_msix_count_generic(hw);
2100
2101         iov->ops.assign_resources = &fm10k_iov_assign_resources_pf;
2102         iov->ops.configure_tc = &fm10k_iov_configure_tc_pf;
2103         iov->ops.assign_int_moderator = &fm10k_iov_assign_int_moderator_pf;
2104         iov->ops.assign_default_mac_vlan = fm10k_iov_assign_default_mac_vlan_pf;
2105         iov->ops.reset_resources = &fm10k_iov_reset_resources_pf;
2106         iov->ops.set_lport = &fm10k_iov_set_lport_pf;
2107         iov->ops.reset_lport = &fm10k_iov_reset_lport_pf;
2108         iov->ops.update_stats = &fm10k_iov_update_stats_pf;
2109         iov->ops.notify_offset = &fm10k_iov_notify_offset_pf;
2110
2111         return fm10k_sm_mbx_init(hw, &hw->mbx, fm10k_msg_data_pf);
2112 }