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