drivers/net/fm10k/base/fm10k_vf.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_vf.h"
  35
  36 /**
  37  *  fm10k_stop_hw_vf - Stop Tx/Rx units
  38  *  @hw: pointer to hardware structure
  39  *
  40  **/
  41 STATIC s32 fm10k_stop_hw_vf(struct fm10k_hw *hw)
  42 {
  43         u8 *perm_addr = hw->mac.perm_addr;
  44         u32 bal = 0, bah = 0, tdlen;
  45         s32 err;
  46         u16 i;
  47
  48         DEBUGFUNC("fm10k_stop_hw_vf");
  49
  50         /* we need to disable the queues before taking further steps */
  51         err = fm10k_stop_hw_generic(hw);
  52         if (err)
  53                 return err;
  54
  55         /* If permanent address is set then we need to restore it */
  56         if (FM10K_IS_VALID_ETHER_ADDR(perm_addr)) {
  57                 bal = (((u32)perm_addr[3]) << 24) |
  58                       (((u32)perm_addr[4]) << 16) |
  59                       (((u32)perm_addr[5]) << 8);
  60                 bah = (((u32)0xFF)         << 24) |
  61                       (((u32)perm_addr[0]) << 16) |
  62                       (((u32)perm_addr[1]) << 8) |
  63                        ((u32)perm_addr[2]);
  64         }
  65
  66         /* restore default itr_scale for next VF initialization */
  67         tdlen = hw->mac.itr_scale << FM10K_TDLEN_ITR_SCALE_SHIFT;
  68
  69         /* The queues have already been disabled so we just need to
  70          * update their base address registers
  71          */
  72         for (i = 0; i < hw->mac.max_queues; i++) {
  73                 FM10K_WRITE_REG(hw, FM10K_TDBAL(i), bal);
  74                 FM10K_WRITE_REG(hw, FM10K_TDBAH(i), bah);
  75                 FM10K_WRITE_REG(hw, FM10K_RDBAL(i), bal);
  76                 FM10K_WRITE_REG(hw, FM10K_RDBAH(i), bah);
  77                 FM10K_WRITE_REG(hw, FM10K_TDLEN(i), tdlen);
  78         }
  79
  80         return FM10K_SUCCESS;
  81 }
  82
  83 /**
  84  *  fm10k_reset_hw_vf - VF hardware reset
  85  *  @hw: pointer to hardware structure
  86  *
  87  *  This function should return the hardware to a state similar to the
  88  *  one it is in after just being initialized.
  89  **/
  90 STATIC s32 fm10k_reset_hw_vf(struct fm10k_hw *hw)
  91 {
  92         s32 err;
  93
  94         DEBUGFUNC("fm10k_reset_hw_vf");
  95
  96         /* shut down queues we own and reset DMA configuration */
  97         err = fm10k_stop_hw_vf(hw);
  98         if (err)
  99                 return err;
 100
 101         /* Inititate VF reset */
 102         FM10K_WRITE_REG(hw, FM10K_VFCTRL, FM10K_VFCTRL_RST);
 103
 104         /* Flush write and allow 100us for reset to complete */
 105         FM10K_WRITE_FLUSH(hw);
 106         usec_delay(FM10K_RESET_TIMEOUT);
 107
 108         /* Clear reset bit and verify it was cleared */
 109         FM10K_WRITE_REG(hw, FM10K_VFCTRL, 0);
 110         if (FM10K_READ_REG(hw, FM10K_VFCTRL) & FM10K_VFCTRL_RST)
 111                 err = FM10K_ERR_RESET_FAILED;
 112
 113         return err;
 114 }
 115
 116 /**
 117  *  fm10k_init_hw_vf - VF hardware initialization
 118  *  @hw: pointer to hardware structure
 119  *
 120  **/
 121 STATIC s32 fm10k_init_hw_vf(struct fm10k_hw *hw)
 122 {
 123         u32 tqdloc, tqdloc0 = ~FM10K_READ_REG(hw, FM10K_TQDLOC(0));
 124         s32 err;
 125         u16 i;
 126
 127         DEBUGFUNC("fm10k_init_hw_vf");
 128
 129         /* verify we have at least 1 queue */
 130         if (!~FM10K_READ_REG(hw, FM10K_TXQCTL(0)) ||
 131             !~FM10K_READ_REG(hw, FM10K_RXQCTL(0))) {
 132                 err = FM10K_ERR_NO_RESOURCES;
 133                 goto reset_max_queues;
 134         }
 135
 136         /* determine how many queues we have */
 137         for (i = 1; tqdloc0 && (i < FM10K_MAX_QUEUES_POOL); i++) {
 138                 /* verify the Descriptor cache offsets are increasing */
 139                 tqdloc = ~FM10K_READ_REG(hw, FM10K_TQDLOC(i));
 140                 if (!tqdloc || (tqdloc == tqdloc0))
 141                         break;
 142
 143                 /* check to verify the PF doesn't own any of our queues */
 144                 if (!~FM10K_READ_REG(hw, FM10K_TXQCTL(i)) ||
 145                     !~FM10K_READ_REG(hw, FM10K_RXQCTL(i)))
 146                         break;
 147         }
 148
 149         /* shut down queues we own and reset DMA configuration */
 150         err = fm10k_disable_queues_generic(hw, i);
 151         if (err)
 152                 goto reset_max_queues;
 153
 154         /* record maximum queue count */
 155         hw->mac.max_queues = i;
 156
 157         /* fetch default VLAN and ITR scale */
 158         hw->mac.default_vid = (FM10K_READ_REG(hw, FM10K_TXQCTL(0)) &
 159                                FM10K_TXQCTL_VID_MASK) >> FM10K_TXQCTL_VID_SHIFT;
 160         hw->mac.itr_scale = (FM10K_READ_REG(hw, FM10K_TDLEN(0)) &
 161                              FM10K_TDLEN_ITR_SCALE_MASK) >>
 162                             FM10K_TDLEN_ITR_SCALE_SHIFT;
 163
 164         return FM10K_SUCCESS;
 165
 166 reset_max_queues:
 167         hw->mac.max_queues = 0;
 168
 169         return err;
 170 }
 171
 172 /**
 173  *  fm10k_is_slot_appropriate_vf - Indicate appropriate slot for this SKU
 174  *  @hw: pointer to hardware structure
 175  *
 176  *  Looks at the PCIe bus info to confirm whether or not this slot can support
 177  *  the necessary bandwidth for this device. Since the VF has no control over
 178  *  the "slot" it is in, always indicate that the slot is appropriate.
 179  **/
 180 STATIC bool fm10k_is_slot_appropriate_vf(struct fm10k_hw *hw)
 181 {
 182         UNREFERENCED_1PARAMETER(hw);
 183         DEBUGFUNC("fm10k_is_slot_appropriate_vf");
 184
 185         return TRUE;
 186 }
 187
 188 /* This structure defines the attibutes to be parsed below */
 189 const struct fm10k_tlv_attr fm10k_mac_vlan_msg_attr[] = {
 190         FM10K_TLV_ATTR_U32(FM10K_MAC_VLAN_MSG_VLAN),
 191         FM10K_TLV_ATTR_BOOL(FM10K_MAC_VLAN_MSG_SET),
 192         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MAC),
 193         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_DEFAULT_MAC),
 194         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MULTICAST),
 195         FM10K_TLV_ATTR_LAST
 196 };
 197
 198 /**
 199  *  fm10k_update_vlan_vf - Update status of VLAN ID in VLAN filter table
 200  *  @hw: pointer to hardware structure
 201  *  @vid: VLAN ID to add to table
 202  *  @vsi: Reserved, should always be 0
 203  *  @set: Indicates if this is a set or clear operation
 204  *
 205  *  This function adds or removes the corresponding VLAN ID from the VLAN
 206  *  filter table for this VF.
 207  **/
 208 STATIC s32 fm10k_update_vlan_vf(struct fm10k_hw *hw, u32 vid, u8 vsi, bool set)
 209 {
 210         struct fm10k_mbx_info *mbx = &hw->mbx;
 211         u32 msg[4];
 212
 213         /* verify the index is not set */
 214         if (vsi)
 215                 return FM10K_ERR_PARAM;
 216
 217         /* verify upper 4 bits of vid and length are 0 */
 218         if ((vid << 16 | vid) >> 28)
 219                 return FM10K_ERR_PARAM;
 220
 221         /* encode set bit into the VLAN ID */
 222         if (!set)
 223                 vid |= FM10K_VLAN_CLEAR;
 224
 225         /* generate VLAN request */
 226         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 227         fm10k_tlv_attr_put_u32(msg, FM10K_MAC_VLAN_MSG_VLAN, vid);
 228
 229         /* load onto outgoing mailbox */
 230         return mbx->ops.enqueue_tx(hw, mbx, msg);
 231 }
 232
 233 /**
 234  *  fm10k_msg_mac_vlan_vf - Read device MAC address from mailbox message
 235  *  @hw: pointer to the HW structure
 236  *  @results: Attributes for message
 237  *  @mbx: unused mailbox data
 238  *
 239  *  This function should determine the MAC address for the VF
 240  **/
 241 s32 fm10k_msg_mac_vlan_vf(struct fm10k_hw *hw, u32 **results,
 242                           struct fm10k_mbx_info *mbx)
 243 {
 244         u8 perm_addr[ETH_ALEN];
 245         u16 vid;
 246         s32 err;
 247
 248         UNREFERENCED_1PARAMETER(mbx);
 249         DEBUGFUNC("fm10k_msg_mac_vlan_vf");
 250
 251         /* record MAC address requested */
 252         err = fm10k_tlv_attr_get_mac_vlan(
 253                                         results[FM10K_MAC_VLAN_MSG_DEFAULT_MAC],
 254                                         perm_addr, &vid);
 255         if (err)
 256                 return err;
 257
 258         memcpy(hw->mac.perm_addr, perm_addr, ETH_ALEN);
 259         hw->mac.default_vid = vid & (FM10K_VLAN_TABLE_VID_MAX - 1);
 260         hw->mac.vlan_override = !!(vid & FM10K_VLAN_CLEAR);
 261
 262         return FM10K_SUCCESS;
 263 }
 264
 265 /**
 266  *  fm10k_read_mac_addr_vf - Read device MAC address
 267  *  @hw: pointer to the HW structure
 268  *
 269  *  This function should determine the MAC address for the VF
 270  **/
 271 STATIC s32 fm10k_read_mac_addr_vf(struct fm10k_hw *hw)
 272 {
 273         u8 perm_addr[ETH_ALEN];
 274         u32 base_addr;
 275
 276         DEBUGFUNC("fm10k_read_mac_addr_vf");
 277
 278         base_addr = FM10K_READ_REG(hw, FM10K_TDBAL(0));
 279
 280         /* last byte should be 0 */
 281         if (base_addr << 24)
 282                 return  FM10K_ERR_INVALID_MAC_ADDR;
 283
 284         perm_addr[3] = (u8)(base_addr >> 24);
 285         perm_addr[4] = (u8)(base_addr >> 16);
 286         perm_addr[5] = (u8)(base_addr >> 8);
 287
 288         base_addr = FM10K_READ_REG(hw, FM10K_TDBAH(0));
 289
 290         /* first byte should be all 1's */
 291         if ((~base_addr) >> 24)
 292                 return  FM10K_ERR_INVALID_MAC_ADDR;
 293
 294         perm_addr[0] = (u8)(base_addr >> 16);
 295         perm_addr[1] = (u8)(base_addr >> 8);
 296         perm_addr[2] = (u8)(base_addr);
 297
 298         memcpy(hw->mac.perm_addr, perm_addr, ETH_ALEN);
 299         memcpy(hw->mac.addr, perm_addr, ETH_ALEN);
 300
 301         return FM10K_SUCCESS;
 302 }
 303
 304 /**
 305  *  fm10k_update_uc_addr_vf - Update device unicast addresses
 306  *  @hw: pointer to the HW structure
 307  *  @glort: unused
 308  *  @mac: MAC address to add/remove from table
 309  *  @vid: VLAN ID to add/remove from table
 310  *  @add: Indicates if this is an add or remove operation
 311  *  @flags: flags field to indicate add and secure - unused
 312  *
 313  *  This function is used to add or remove unicast MAC addresses for
 314  *  the VF.
 315  **/
 316 STATIC s32 fm10k_update_uc_addr_vf(struct fm10k_hw *hw, u16 glort,
 317                                    const u8 *mac, u16 vid, bool add, u8 flags)
 318 {
 319         struct fm10k_mbx_info *mbx = &hw->mbx;
 320         u32 msg[7];
 321
 322         DEBUGFUNC("fm10k_update_uc_addr_vf");
 323
 324         UNREFERENCED_2PARAMETER(glort, flags);
 325
 326         /* verify VLAN ID is valid */
 327         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
 328                 return FM10K_ERR_PARAM;
 329
 330         /* verify MAC address is valid */
 331         if (!FM10K_IS_VALID_ETHER_ADDR(mac))
 332                 return FM10K_ERR_PARAM;
 333
 334         /* verify we are not locked down on the MAC address */
 335         if (FM10K_IS_VALID_ETHER_ADDR(hw->mac.perm_addr) &&
 336             memcmp(hw->mac.perm_addr, mac, ETH_ALEN))
 337                 return FM10K_ERR_PARAM;
 338
 339         /* add bit to notify us if this is a set or clear operation */
 340         if (!add)
 341                 vid |= FM10K_VLAN_CLEAR;
 342
 343         /* generate VLAN request */
 344         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 345         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MAC, mac, vid);
 346
 347         /* load onto outgoing mailbox */
 348         return mbx->ops.enqueue_tx(hw, mbx, msg);
 349 }
 350
 351 /**
 352  *  fm10k_update_mc_addr_vf - Update device multicast addresses
 353  *  @hw: pointer to the HW structure
 354  *  @glort: unused
 355  *  @mac: MAC address to add/remove from table
 356  *  @vid: VLAN ID to add/remove from table
 357  *  @add: Indicates if this is an add or remove operation
 358  *
 359  *  This function is used to add or remove multicast MAC addresses for
 360  *  the VF.
 361  **/
 362 STATIC s32 fm10k_update_mc_addr_vf(struct fm10k_hw *hw, u16 glort,
 363                                    const u8 *mac, u16 vid, bool add)
 364 {
 365         struct fm10k_mbx_info *mbx = &hw->mbx;
 366         u32 msg[7];
 367
 368         DEBUGFUNC("fm10k_update_uc_addr_vf");
 369
 370         UNREFERENCED_1PARAMETER(glort);
 371
 372         /* verify VLAN ID is valid */
 373         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
 374                 return FM10K_ERR_PARAM;
 375
 376         /* verify multicast address is valid */
 377         if (!FM10K_IS_MULTICAST_ETHER_ADDR(mac))
 378                 return FM10K_ERR_PARAM;
 379
 380         /* add bit to notify us if this is a set or clear operation */
 381         if (!add)
 382                 vid |= FM10K_VLAN_CLEAR;
 383
 384         /* generate VLAN request */
 385         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 386         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MULTICAST,
 387                                     mac, vid);
 388
 389         /* load onto outgoing mailbox */
 390         return mbx->ops.enqueue_tx(hw, mbx, msg);
 391 }
 392
 393 /**
 394  *  fm10k_update_int_moderator_vf - Request update of interrupt moderator list
 395  *  @hw: pointer to hardware structure
 396  *
 397  *  This function will issue a request to the PF to rescan our MSI-X table
 398  *  and to update the interrupt moderator linked list.
 399  **/
 400 STATIC void fm10k_update_int_moderator_vf(struct fm10k_hw *hw)
 401 {
 402         struct fm10k_mbx_info *mbx = &hw->mbx;
 403         u32 msg[1];
 404
 405         /* generate MSI-X request */
 406         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MSIX);
 407
 408         /* load onto outgoing mailbox */
 409         mbx->ops.enqueue_tx(hw, mbx, msg);
 410 }
 411
 412 /* This structure defines the attibutes to be parsed below */
 413 const struct fm10k_tlv_attr fm10k_lport_state_msg_attr[] = {
 414         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_DISABLE),
 415         FM10K_TLV_ATTR_U8(FM10K_LPORT_STATE_MSG_XCAST_MODE),
 416         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_READY),
 417         FM10K_TLV_ATTR_LAST
 418 };
 419
 420 /**
 421  *  fm10k_msg_lport_state_vf - Message handler for lport_state message from PF
 422  *  @hw: Pointer to hardware structure
 423  *  @results: pointer array containing parsed data
 424  *  @mbx: Pointer to mailbox information structure
 425  *
 426  *  This handler is meant to capture the indication from the PF that we
 427  *  are ready to bring up the interface.
 428  **/
 429 s32 fm10k_msg_lport_state_vf(struct fm10k_hw *hw, u32 **results,
 430                              struct fm10k_mbx_info *mbx)
 431 {
 432         UNREFERENCED_1PARAMETER(mbx);
 433         DEBUGFUNC("fm10k_msg_lport_state_vf");
 434
 435         hw->mac.dglort_map = !results[FM10K_LPORT_STATE_MSG_READY] ?
 436                              FM10K_DGLORTMAP_NONE : FM10K_DGLORTMAP_ZERO;
 437
 438         return FM10K_SUCCESS;
 439 }
 440
 441 /**
 442  *  fm10k_update_lport_state_vf - Update device state in lower device
 443  *  @hw: pointer to the HW structure
 444  *  @glort: unused
 445  *  @count: number of logical ports to enable - unused (always 1)
 446  *  @enable: boolean value indicating if this is an enable or disable request
 447  *
 448  *  Notify the lower device of a state change.  If the lower device is
 449  *  enabled we can add filters, if it is disabled all filters for this
 450  *  logical port are flushed.
 451  **/
 452 STATIC s32 fm10k_update_lport_state_vf(struct fm10k_hw *hw, u16 glort,
 453                                        u16 count, bool enable)
 454 {
 455         struct fm10k_mbx_info *mbx = &hw->mbx;
 456         u32 msg[2];
 457
 458         UNREFERENCED_2PARAMETER(glort, count);
 459         DEBUGFUNC("fm10k_update_lport_state_vf");
 460
 461         /* reset glort mask 0 as we have to wait to be enabled */
 462         hw->mac.dglort_map = FM10K_DGLORTMAP_NONE;
 463
 464         /* generate port state request */
 465         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
 466         if (!enable)
 467                 fm10k_tlv_attr_put_bool(msg, FM10K_LPORT_STATE_MSG_DISABLE);
 468
 469         /* load onto outgoing mailbox */
 470         return mbx->ops.enqueue_tx(hw, mbx, msg);
 471 }
 472
 473 /**
 474  *  fm10k_update_xcast_mode_vf - Request update of multicast mode
 475  *  @hw: pointer to hardware structure
 476  *  @glort: unused
 477  *  @mode: integer value indicating mode being requested
 478  *
 479  *  This function will attempt to request a higher mode for the port
 480  *  so that it can enable either multicast, multicast promiscuous, or
 481  *  promiscuous mode of operation.
 482  **/
 483 STATIC s32 fm10k_update_xcast_mode_vf(struct fm10k_hw *hw, u16 glort, u8 mode)
 484 {
 485         struct fm10k_mbx_info *mbx = &hw->mbx;
 486         u32 msg[3];
 487
 488         UNREFERENCED_1PARAMETER(glort);
 489         DEBUGFUNC("fm10k_update_xcast_mode_vf");
 490
 491         if (mode > FM10K_XCAST_MODE_NONE)
 492                 return FM10K_ERR_PARAM;
 493
 494         /* generate message requesting to change xcast mode */
 495         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
 496         fm10k_tlv_attr_put_u8(msg, FM10K_LPORT_STATE_MSG_XCAST_MODE, mode);
 497
 498         /* load onto outgoing mailbox */
 499         return mbx->ops.enqueue_tx(hw, mbx, msg);
 500 }
 501
 502 const struct fm10k_tlv_attr fm10k_1588_msg_attr[] = {
 503         FM10K_TLV_ATTR_U64(FM10K_1588_MSG_CLK_OFFSET),
 504         FM10K_TLV_ATTR_LAST
 505 };
 506
 507 /* currently there is no shared 1588 message handler */
 508
 509 /**
 510  *  fm10k_update_hw_stats_vf - Updates hardware related statistics of VF
 511  *  @hw: pointer to hardware structure
 512  *  @stats: pointer to statistics structure
 513  *
 514  *  This function collects and aggregates per queue hardware statistics.
 515  **/
 516 STATIC void fm10k_update_hw_stats_vf(struct fm10k_hw *hw,
 517                                      struct fm10k_hw_stats *stats)
 518 {
 519         DEBUGFUNC("fm10k_update_hw_stats_vf");
 520
 521         fm10k_update_hw_stats_q(hw, stats->q, 0, hw->mac.max_queues);
 522 }
 523
 524 /**
 525  *  fm10k_rebind_hw_stats_vf - Resets base for hardware statistics of VF
 526  *  @hw: pointer to hardware structure
 527  *  @stats: pointer to the stats structure to update
 528  *
 529  *  This function resets the base for queue hardware statistics.
 530  **/
 531 STATIC void fm10k_rebind_hw_stats_vf(struct fm10k_hw *hw,
 532                                      struct fm10k_hw_stats *stats)
 533 {
 534         DEBUGFUNC("fm10k_rebind_hw_stats_vf");
 535
 536         /* Unbind Queue Statistics */
 537         fm10k_unbind_hw_stats_q(stats->q, 0, hw->mac.max_queues);
 538
 539         /* Reinitialize bases for all stats */
 540         fm10k_update_hw_stats_vf(hw, stats);
 541 }
 542
 543 /**
 544  *  fm10k_configure_dglort_map_vf - Configures GLORT entry and queues
 545  *  @hw: pointer to hardware structure
 546  *  @dglort: pointer to dglort configuration structure
 547  *
 548  *  Reads the configuration structure contained in dglort_cfg and uses
 549  *  that information to then populate a DGLORTMAP/DEC entry and the queues
 550  *  to which it has been assigned.
 551  **/
 552 STATIC s32 fm10k_configure_dglort_map_vf(struct fm10k_hw *hw,
 553                                          struct fm10k_dglort_cfg *dglort)
 554 {
 555         UNREFERENCED_1PARAMETER(hw);
 556         DEBUGFUNC("fm10k_configure_dglort_map_vf");
 557
 558         /* verify the dglort pointer */
 559         if (!dglort)
 560                 return FM10K_ERR_PARAM;
 561
 562         /* stub for now until we determine correct message for this */
 563
 564         return FM10K_SUCCESS;
 565 }
 566
 567 /**
 568  *  fm10k_adjust_systime_vf - Adjust systime frequency
 569  *  @hw: pointer to hardware structure
 570  *  @ppb: adjustment rate in parts per billion
 571  *
 572  *  This function takes an adjustment rate in parts per billion and will
 573  *  verify that this value is 0 as the VF cannot support adjusting the
 574  *  systime clock.
 575  *
 576  *  If the ppb value is non-zero the return is ERR_PARAM else success
 577  **/
 578 STATIC s32 fm10k_adjust_systime_vf(struct fm10k_hw *hw, s32 ppb)
 579 {
 580         UNREFERENCED_1PARAMETER(hw);
 581         DEBUGFUNC("fm10k_adjust_systime_vf");
 582
 583         /* The VF cannot adjust the clock frequency, however it should
 584          * already have a syntonic clock with whichever host interface is
 585          * running as the master for the host interface clock domain so
 586          * there should be not frequency adjustment necessary.
 587          */
 588         return ppb ? FM10K_ERR_PARAM : FM10K_SUCCESS;
 589 }
 590
 591 /**
 592  *  fm10k_read_systime_vf - Reads value of systime registers
 593  *  @hw: pointer to the hardware structure
 594  *
 595  *  Function reads the content of 2 registers, combined to represent a 64 bit
 596  *  value measured in nanoseconds.  In order to guarantee the value is accurate
 597  *  we check the 32 most significant bits both before and after reading the
 598  *  32 least significant bits to verify they didn't change as we were reading
 599  *  the registers.
 600  **/
 601 static u64 fm10k_read_systime_vf(struct fm10k_hw *hw)
 602 {
 603         u32 systime_l, systime_h, systime_tmp;
 604
 605         systime_h = fm10k_read_reg(hw, FM10K_VFSYSTIME + 1);
 606
 607         do {
 608                 systime_tmp = systime_h;
 609                 systime_l = fm10k_read_reg(hw, FM10K_VFSYSTIME);
 610                 systime_h = fm10k_read_reg(hw, FM10K_VFSYSTIME + 1);
 611         } while (systime_tmp != systime_h);
 612
 613         return ((u64)systime_h << 32) | systime_l;
 614 }
 615
 616 static const struct fm10k_msg_data fm10k_msg_data_vf[] = {
 617         FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
 618         FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_msg_mac_vlan_vf),
 619         FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_msg_lport_state_vf),
 620         FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
 621 };
 622
 623 /**
 624  *  fm10k_init_ops_vf - Inits func ptrs and MAC type
 625  *  @hw: pointer to hardware structure
 626  *
 627  *  Initialize the function pointers and assign the MAC type for VF.
 628  *  Does not touch the hardware.
 629  **/
 630 s32 fm10k_init_ops_vf(struct fm10k_hw *hw)
 631 {
 632         struct fm10k_mac_info *mac = &hw->mac;
 633
 634         DEBUGFUNC("fm10k_init_ops_vf");
 635
 636         fm10k_init_ops_generic(hw);
 637
 638         mac->ops.reset_hw = &fm10k_reset_hw_vf;
 639         mac->ops.init_hw = &fm10k_init_hw_vf;
 640         mac->ops.start_hw = &fm10k_start_hw_generic;
 641         mac->ops.stop_hw = &fm10k_stop_hw_vf;
 642         mac->ops.is_slot_appropriate = &fm10k_is_slot_appropriate_vf;
 643         mac->ops.update_vlan = &fm10k_update_vlan_vf;
 644         mac->ops.read_mac_addr = &fm10k_read_mac_addr_vf;
 645         mac->ops.update_uc_addr = &fm10k_update_uc_addr_vf;
 646         mac->ops.update_mc_addr = &fm10k_update_mc_addr_vf;
 647         mac->ops.update_xcast_mode = &fm10k_update_xcast_mode_vf;
 648         mac->ops.update_int_moderator = &fm10k_update_int_moderator_vf;
 649         mac->ops.update_lport_state = &fm10k_update_lport_state_vf;
 650         mac->ops.update_hw_stats = &fm10k_update_hw_stats_vf;
 651         mac->ops.rebind_hw_stats = &fm10k_rebind_hw_stats_vf;
 652         mac->ops.configure_dglort_map = &fm10k_configure_dglort_map_vf;
 653         mac->ops.get_host_state = &fm10k_get_host_state_generic;
 654         mac->ops.adjust_systime = &fm10k_adjust_systime_vf;
 655         mac->ops.read_systime = &fm10k_read_systime_vf;
 656
 657         mac->max_msix_vectors = fm10k_get_pcie_msix_count_generic(hw);
 658
 659         return fm10k_pfvf_mbx_init(hw, &hw->mbx, fm10k_msg_data_vf, 0);
 660 }