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