drivers/net/ethernet/intel/fm10k/fm10k_vf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Intel(R) Ethernet Switch Host Interface Driver
   3  * Copyright(c) 2013 - 2016 Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * The full GNU General Public License is included in this distribution in
  15  * the file called "COPYING".
  16  *
  17  * Contact Information:
  18  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  19  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  20  */
  21
  22 #include "fm10k_vf.h"
  23
  24 /**
  25  *  fm10k_stop_hw_vf - Stop Tx/Rx units
  26  *  @hw: pointer to hardware structure
  27  *
  28  **/
  29 static s32 fm10k_stop_hw_vf(struct fm10k_hw *hw)
  30 {
  31         u8 *perm_addr = hw->mac.perm_addr;
  32         u32 bal = 0, bah = 0, tdlen;
  33         s32 err;
  34         u16 i;
  35
  36         /* we need to disable the queues before taking further steps */
  37         err = fm10k_stop_hw_generic(hw);
  38         if (err && err != FM10K_ERR_REQUESTS_PENDING)
  39                 return err;
  40
  41         /* If permanent address is set then we need to restore it */
  42         if (is_valid_ether_addr(perm_addr)) {
  43                 bal = (((u32)perm_addr[3]) << 24) |
  44                       (((u32)perm_addr[4]) << 16) |
  45                       (((u32)perm_addr[5]) << 8);
  46                 bah = (((u32)0xFF)         << 24) |
  47                       (((u32)perm_addr[0]) << 16) |
  48                       (((u32)perm_addr[1]) << 8) |
  49                        ((u32)perm_addr[2]);
  50         }
  51
  52         /* restore default itr_scale for next VF initialization */
  53         tdlen = hw->mac.itr_scale << FM10K_TDLEN_ITR_SCALE_SHIFT;
  54
  55         /* The queues have already been disabled so we just need to
  56          * update their base address registers
  57          */
  58         for (i = 0; i < hw->mac.max_queues; i++) {
  59                 fm10k_write_reg(hw, FM10K_TDBAL(i), bal);
  60                 fm10k_write_reg(hw, FM10K_TDBAH(i), bah);
  61                 fm10k_write_reg(hw, FM10K_RDBAL(i), bal);
  62                 fm10k_write_reg(hw, FM10K_RDBAH(i), bah);
  63                 /* Restore ITR scale in software-defined mechanism in TDLEN
  64                  * for next VF initialization. See definition of
  65                  * FM10K_TDLEN_ITR_SCALE_SHIFT for more details on the use of
  66                  * TDLEN here.
  67                  */
  68                 fm10k_write_reg(hw, FM10K_TDLEN(i), tdlen);
  69         }
  70
  71         return err;
  72 }
  73
  74 /**
  75  *  fm10k_reset_hw_vf - VF hardware reset
  76  *  @hw: pointer to hardware structure
  77  *
  78  *  This function should return the hardware to a state similar to the
  79  *  one it is in after just being initialized.
  80  **/
  81 static s32 fm10k_reset_hw_vf(struct fm10k_hw *hw)
  82 {
  83         s32 err;
  84
  85         /* shut down queues we own and reset DMA configuration */
  86         err = fm10k_stop_hw_vf(hw);
  87         if (err == FM10K_ERR_REQUESTS_PENDING)
  88                 hw->mac.reset_while_pending++;
  89         else if (err)
  90                 return err;
  91
  92         /* Inititate VF reset */
  93         fm10k_write_reg(hw, FM10K_VFCTRL, FM10K_VFCTRL_RST);
  94
  95         /* Flush write and allow 100us for reset to complete */
  96         fm10k_write_flush(hw);
  97         udelay(FM10K_RESET_TIMEOUT);
  98
  99         /* Clear reset bit and verify it was cleared */
 100         fm10k_write_reg(hw, FM10K_VFCTRL, 0);
 101         if (fm10k_read_reg(hw, FM10K_VFCTRL) & FM10K_VFCTRL_RST)
 102                 return FM10K_ERR_RESET_FAILED;
 103
 104         return 0;
 105 }
 106
 107 /**
 108  *  fm10k_init_hw_vf - VF hardware initialization
 109  *  @hw: pointer to hardware structure
 110  *
 111  **/
 112 static s32 fm10k_init_hw_vf(struct fm10k_hw *hw)
 113 {
 114         u32 tqdloc, tqdloc0 = ~fm10k_read_reg(hw, FM10K_TQDLOC(0));
 115         s32 err;
 116         u16 i;
 117
 118         /* verify we have at least 1 queue */
 119         if (!~fm10k_read_reg(hw, FM10K_TXQCTL(0)) ||
 120             !~fm10k_read_reg(hw, FM10K_RXQCTL(0))) {
 121                 err = FM10K_ERR_NO_RESOURCES;
 122                 goto reset_max_queues;
 123         }
 124
 125         /* determine how many queues we have */
 126         for (i = 1; tqdloc0 && (i < FM10K_MAX_QUEUES_POOL); i++) {
 127                 /* verify the Descriptor cache offsets are increasing */
 128                 tqdloc = ~fm10k_read_reg(hw, FM10K_TQDLOC(i));
 129                 if (!tqdloc || (tqdloc == tqdloc0))
 130                         break;
 131
 132                 /* check to verify the PF doesn't own any of our queues */
 133                 if (!~fm10k_read_reg(hw, FM10K_TXQCTL(i)) ||
 134                     !~fm10k_read_reg(hw, FM10K_RXQCTL(i)))
 135                         break;
 136         }
 137
 138         /* shut down queues we own and reset DMA configuration */
 139         err = fm10k_disable_queues_generic(hw, i);
 140         if (err)
 141                 goto reset_max_queues;
 142
 143         /* record maximum queue count */
 144         hw->mac.max_queues = i;
 145
 146         /* fetch default VLAN and ITR scale */
 147         hw->mac.default_vid = (fm10k_read_reg(hw, FM10K_TXQCTL(0)) &
 148                                FM10K_TXQCTL_VID_MASK) >> FM10K_TXQCTL_VID_SHIFT;
 149         /* Read the ITR scale from TDLEN. See the definition of
 150          * FM10K_TDLEN_ITR_SCALE_SHIFT for more information about how TDLEN is
 151          * used here.
 152          */
 153         hw->mac.itr_scale = (fm10k_read_reg(hw, FM10K_TDLEN(0)) &
 154                              FM10K_TDLEN_ITR_SCALE_MASK) >>
 155                             FM10K_TDLEN_ITR_SCALE_SHIFT;
 156
 157         return 0;
 158
 159 reset_max_queues:
 160         hw->mac.max_queues = 0;
 161
 162         return err;
 163 }
 164
 165 /* This structure defines the attibutes to be parsed below */
 166 const struct fm10k_tlv_attr fm10k_mac_vlan_msg_attr[] = {
 167         FM10K_TLV_ATTR_U32(FM10K_MAC_VLAN_MSG_VLAN),
 168         FM10K_TLV_ATTR_BOOL(FM10K_MAC_VLAN_MSG_SET),
 169         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MAC),
 170         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_DEFAULT_MAC),
 171         FM10K_TLV_ATTR_MAC_ADDR(FM10K_MAC_VLAN_MSG_MULTICAST),
 172         FM10K_TLV_ATTR_LAST
 173 };
 174
 175 /**
 176  *  fm10k_update_vlan_vf - Update status of VLAN ID in VLAN filter table
 177  *  @hw: pointer to hardware structure
 178  *  @vid: VLAN ID to add to table
 179  *  @vsi: Reserved, should always be 0
 180  *  @set: Indicates if this is a set or clear operation
 181  *
 182  *  This function adds or removes the corresponding VLAN ID from the VLAN
 183  *  filter table for this VF.
 184  **/
 185 static s32 fm10k_update_vlan_vf(struct fm10k_hw *hw, u32 vid, u8 vsi, bool set)
 186 {
 187         struct fm10k_mbx_info *mbx = &hw->mbx;
 188         u32 msg[4];
 189
 190         /* verify the index is not set */
 191         if (vsi)
 192                 return FM10K_ERR_PARAM;
 193
 194         /* clever trick to verify reserved bits in both vid and length */
 195         if ((vid << 16 | vid) >> 28)
 196                 return FM10K_ERR_PARAM;
 197
 198         /* encode set bit into the VLAN ID */
 199         if (!set)
 200                 vid |= FM10K_VLAN_CLEAR;
 201
 202         /* generate VLAN request */
 203         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 204         fm10k_tlv_attr_put_u32(msg, FM10K_MAC_VLAN_MSG_VLAN, vid);
 205
 206         /* load onto outgoing mailbox */
 207         return mbx->ops.enqueue_tx(hw, mbx, msg);
 208 }
 209
 210 /**
 211  *  fm10k_msg_mac_vlan_vf - Read device MAC address from mailbox message
 212  *  @hw: pointer to the HW structure
 213  *  @results: Attributes for message
 214  *  @mbx: unused mailbox data
 215  *
 216  *  This function should determine the MAC address for the VF
 217  **/
 218 s32 fm10k_msg_mac_vlan_vf(struct fm10k_hw *hw, u32 **results,
 219                           struct fm10k_mbx_info *mbx)
 220 {
 221         u8 perm_addr[ETH_ALEN];
 222         u16 vid;
 223         s32 err;
 224
 225         /* record MAC address requested */
 226         err = fm10k_tlv_attr_get_mac_vlan(
 227                                         results[FM10K_MAC_VLAN_MSG_DEFAULT_MAC],
 228                                         perm_addr, &vid);
 229         if (err)
 230                 return err;
 231
 232         ether_addr_copy(hw->mac.perm_addr, perm_addr);
 233         hw->mac.default_vid = vid & (FM10K_VLAN_TABLE_VID_MAX - 1);
 234         hw->mac.vlan_override = !!(vid & FM10K_VLAN_OVERRIDE);
 235
 236         return 0;
 237 }
 238
 239 /**
 240  *  fm10k_read_mac_addr_vf - Read device MAC address
 241  *  @hw: pointer to the HW structure
 242  *
 243  *  This function should determine the MAC address for the VF
 244  **/
 245 static s32 fm10k_read_mac_addr_vf(struct fm10k_hw *hw)
 246 {
 247         u8 perm_addr[ETH_ALEN];
 248         u32 base_addr;
 249
 250         base_addr = fm10k_read_reg(hw, FM10K_TDBAL(0));
 251
 252         /* last byte should be 0 */
 253         if (base_addr << 24)
 254                 return  FM10K_ERR_INVALID_MAC_ADDR;
 255
 256         perm_addr[3] = (u8)(base_addr >> 24);
 257         perm_addr[4] = (u8)(base_addr >> 16);
 258         perm_addr[5] = (u8)(base_addr >> 8);
 259
 260         base_addr = fm10k_read_reg(hw, FM10K_TDBAH(0));
 261
 262         /* first byte should be all 1's */
 263         if ((~base_addr) >> 24)
 264                 return  FM10K_ERR_INVALID_MAC_ADDR;
 265
 266         perm_addr[0] = (u8)(base_addr >> 16);
 267         perm_addr[1] = (u8)(base_addr >> 8);
 268         perm_addr[2] = (u8)(base_addr);
 269
 270         ether_addr_copy(hw->mac.perm_addr, perm_addr);
 271         ether_addr_copy(hw->mac.addr, perm_addr);
 272
 273         return 0;
 274 }
 275
 276 /**
 277  *  fm10k_update_uc_addr_vf - Update device unicast addresses
 278  *  @hw: pointer to the HW structure
 279  *  @glort: unused
 280  *  @mac: MAC address to add/remove from table
 281  *  @vid: VLAN ID to add/remove from table
 282  *  @add: Indicates if this is an add or remove operation
 283  *  @flags: flags field to indicate add and secure - unused
 284  *
 285  *  This function is used to add or remove unicast MAC addresses for
 286  *  the VF.
 287  **/
 288 static s32 fm10k_update_uc_addr_vf(struct fm10k_hw *hw, u16 glort,
 289                                    const u8 *mac, u16 vid, bool add, u8 flags)
 290 {
 291         struct fm10k_mbx_info *mbx = &hw->mbx;
 292         u32 msg[7];
 293
 294         /* verify VLAN ID is valid */
 295         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
 296                 return FM10K_ERR_PARAM;
 297
 298         /* verify MAC address is valid */
 299         if (!is_valid_ether_addr(mac))
 300                 return FM10K_ERR_PARAM;
 301
 302         /* verify we are not locked down on the MAC address */
 303         if (is_valid_ether_addr(hw->mac.perm_addr) &&
 304             !ether_addr_equal(hw->mac.perm_addr, mac))
 305                 return FM10K_ERR_PARAM;
 306
 307         /* add bit to notify us if this is a set or clear operation */
 308         if (!add)
 309                 vid |= FM10K_VLAN_CLEAR;
 310
 311         /* generate VLAN request */
 312         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 313         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MAC, mac, vid);
 314
 315         /* load onto outgoing mailbox */
 316         return mbx->ops.enqueue_tx(hw, mbx, msg);
 317 }
 318
 319 /**
 320  *  fm10k_update_mc_addr_vf - Update device multicast addresses
 321  *  @hw: pointer to the HW structure
 322  *  @glort: unused
 323  *  @mac: MAC address to add/remove from table
 324  *  @vid: VLAN ID to add/remove from table
 325  *  @add: Indicates if this is an add or remove operation
 326  *
 327  *  This function is used to add or remove multicast MAC addresses for
 328  *  the VF.
 329  **/
 330 static s32 fm10k_update_mc_addr_vf(struct fm10k_hw *hw, u16 glort,
 331                                    const u8 *mac, u16 vid, bool add)
 332 {
 333         struct fm10k_mbx_info *mbx = &hw->mbx;
 334         u32 msg[7];
 335
 336         /* verify VLAN ID is valid */
 337         if (vid >= FM10K_VLAN_TABLE_VID_MAX)
 338                 return FM10K_ERR_PARAM;
 339
 340         /* verify multicast address is valid */
 341         if (!is_multicast_ether_addr(mac))
 342                 return FM10K_ERR_PARAM;
 343
 344         /* add bit to notify us if this is a set or clear operation */
 345         if (!add)
 346                 vid |= FM10K_VLAN_CLEAR;
 347
 348         /* generate VLAN request */
 349         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MAC_VLAN);
 350         fm10k_tlv_attr_put_mac_vlan(msg, FM10K_MAC_VLAN_MSG_MULTICAST,
 351                                     mac, vid);
 352
 353         /* load onto outgoing mailbox */
 354         return mbx->ops.enqueue_tx(hw, mbx, msg);
 355 }
 356
 357 /**
 358  *  fm10k_update_int_moderator_vf - Request update of interrupt moderator list
 359  *  @hw: pointer to hardware structure
 360  *
 361  *  This function will issue a request to the PF to rescan our MSI-X table
 362  *  and to update the interrupt moderator linked list.
 363  **/
 364 static void fm10k_update_int_moderator_vf(struct fm10k_hw *hw)
 365 {
 366         struct fm10k_mbx_info *mbx = &hw->mbx;
 367         u32 msg[1];
 368
 369         /* generate MSI-X request */
 370         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_MSIX);
 371
 372         /* load onto outgoing mailbox */
 373         mbx->ops.enqueue_tx(hw, mbx, msg);
 374 }
 375
 376 /* This structure defines the attibutes to be parsed below */
 377 const struct fm10k_tlv_attr fm10k_lport_state_msg_attr[] = {
 378         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_DISABLE),
 379         FM10K_TLV_ATTR_U8(FM10K_LPORT_STATE_MSG_XCAST_MODE),
 380         FM10K_TLV_ATTR_BOOL(FM10K_LPORT_STATE_MSG_READY),
 381         FM10K_TLV_ATTR_LAST
 382 };
 383
 384 /**
 385  *  fm10k_msg_lport_state_vf - Message handler for lport_state message from PF
 386  *  @hw: Pointer to hardware structure
 387  *  @results: pointer array containing parsed data
 388  *  @mbx: Pointer to mailbox information structure
 389  *
 390  *  This handler is meant to capture the indication from the PF that we
 391  *  are ready to bring up the interface.
 392  **/
 393 s32 fm10k_msg_lport_state_vf(struct fm10k_hw *hw, u32 **results,
 394                              struct fm10k_mbx_info *mbx)
 395 {
 396         hw->mac.dglort_map = !results[FM10K_LPORT_STATE_MSG_READY] ?
 397                              FM10K_DGLORTMAP_NONE : FM10K_DGLORTMAP_ZERO;
 398
 399         return 0;
 400 }
 401
 402 /**
 403  *  fm10k_update_lport_state_vf - Update device state in lower device
 404  *  @hw: pointer to the HW structure
 405  *  @glort: unused
 406  *  @count: number of logical ports to enable - unused (always 1)
 407  *  @enable: boolean value indicating if this is an enable or disable request
 408  *
 409  *  Notify the lower device of a state change.  If the lower device is
 410  *  enabled we can add filters, if it is disabled all filters for this
 411  *  logical port are flushed.
 412  **/
 413 static s32 fm10k_update_lport_state_vf(struct fm10k_hw *hw, u16 glort,
 414                                        u16 count, bool enable)
 415 {
 416         struct fm10k_mbx_info *mbx = &hw->mbx;
 417         u32 msg[2];
 418
 419         /* reset glort mask 0 as we have to wait to be enabled */
 420         hw->mac.dglort_map = FM10K_DGLORTMAP_NONE;
 421
 422         /* generate port state request */
 423         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
 424         if (!enable)
 425                 fm10k_tlv_attr_put_bool(msg, FM10K_LPORT_STATE_MSG_DISABLE);
 426
 427         /* load onto outgoing mailbox */
 428         return mbx->ops.enqueue_tx(hw, mbx, msg);
 429 }
 430
 431 /**
 432  *  fm10k_update_xcast_mode_vf - Request update of multicast mode
 433  *  @hw: pointer to hardware structure
 434  *  @glort: unused
 435  *  @mode: integer value indicating mode being requested
 436  *
 437  *  This function will attempt to request a higher mode for the port
 438  *  so that it can enable either multicast, multicast promiscuous, or
 439  *  promiscuous mode of operation.
 440  **/
 441 static s32 fm10k_update_xcast_mode_vf(struct fm10k_hw *hw, u16 glort, u8 mode)
 442 {
 443         struct fm10k_mbx_info *mbx = &hw->mbx;
 444         u32 msg[3];
 445
 446         if (mode > FM10K_XCAST_MODE_NONE)
 447                 return FM10K_ERR_PARAM;
 448
 449         /* generate message requesting to change xcast mode */
 450         fm10k_tlv_msg_init(msg, FM10K_VF_MSG_ID_LPORT_STATE);
 451         fm10k_tlv_attr_put_u8(msg, FM10K_LPORT_STATE_MSG_XCAST_MODE, mode);
 452
 453         /* load onto outgoing mailbox */
 454         return mbx->ops.enqueue_tx(hw, mbx, msg);
 455 }
 456
 457 /**
 458  *  fm10k_update_hw_stats_vf - Updates hardware related statistics of VF
 459  *  @hw: pointer to hardware structure
 460  *  @stats: pointer to statistics structure
 461  *
 462  *  This function collects and aggregates per queue hardware statistics.
 463  **/
 464 static void fm10k_update_hw_stats_vf(struct fm10k_hw *hw,
 465                                      struct fm10k_hw_stats *stats)
 466 {
 467         fm10k_update_hw_stats_q(hw, stats->q, 0, hw->mac.max_queues);
 468 }
 469
 470 /**
 471  *  fm10k_rebind_hw_stats_vf - Resets base for hardware statistics of VF
 472  *  @hw: pointer to hardware structure
 473  *  @stats: pointer to the stats structure to update
 474  *
 475  *  This function resets the base for queue hardware statistics.
 476  **/
 477 static void fm10k_rebind_hw_stats_vf(struct fm10k_hw *hw,
 478                                      struct fm10k_hw_stats *stats)
 479 {
 480         /* Unbind Queue Statistics */
 481         fm10k_unbind_hw_stats_q(stats->q, 0, hw->mac.max_queues);
 482
 483         /* Reinitialize bases for all stats */
 484         fm10k_update_hw_stats_vf(hw, stats);
 485 }
 486
 487 /**
 488  *  fm10k_configure_dglort_map_vf - Configures GLORT entry and queues
 489  *  @hw: pointer to hardware structure
 490  *  @dglort: pointer to dglort configuration structure
 491  *
 492  *  Reads the configuration structure contained in dglort_cfg and uses
 493  *  that information to then populate a DGLORTMAP/DEC entry and the queues
 494  *  to which it has been assigned.
 495  **/
 496 static s32 fm10k_configure_dglort_map_vf(struct fm10k_hw *hw,
 497                                          struct fm10k_dglort_cfg *dglort)
 498 {
 499         /* verify the dglort pointer */
 500         if (!dglort)
 501                 return FM10K_ERR_PARAM;
 502
 503         /* stub for now until we determine correct message for this */
 504
 505         return 0;
 506 }
 507
 508 static const struct fm10k_msg_data fm10k_msg_data_vf[] = {
 509         FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),
 510         FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_msg_mac_vlan_vf),
 511         FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_msg_lport_state_vf),
 512         FM10K_TLV_MSG_ERROR_HANDLER(fm10k_tlv_msg_error),
 513 };
 514
 515 static const struct fm10k_mac_ops mac_ops_vf = {
 516         .get_bus_info           = fm10k_get_bus_info_generic,
 517         .reset_hw               = fm10k_reset_hw_vf,
 518         .init_hw                = fm10k_init_hw_vf,
 519         .start_hw               = fm10k_start_hw_generic,
 520         .stop_hw                = fm10k_stop_hw_vf,
 521         .update_vlan            = fm10k_update_vlan_vf,
 522         .read_mac_addr          = fm10k_read_mac_addr_vf,
 523         .update_uc_addr         = fm10k_update_uc_addr_vf,
 524         .update_mc_addr         = fm10k_update_mc_addr_vf,
 525         .update_xcast_mode      = fm10k_update_xcast_mode_vf,
 526         .update_int_moderator   = fm10k_update_int_moderator_vf,
 527         .update_lport_state     = fm10k_update_lport_state_vf,
 528         .update_hw_stats        = fm10k_update_hw_stats_vf,
 529         .rebind_hw_stats        = fm10k_rebind_hw_stats_vf,
 530         .configure_dglort_map   = fm10k_configure_dglort_map_vf,
 531         .get_host_state         = fm10k_get_host_state_generic,
 532 };
 533
 534 static s32 fm10k_get_invariants_vf(struct fm10k_hw *hw)
 535 {
 536         fm10k_get_invariants_generic(hw);
 537
 538         return fm10k_pfvf_mbx_init(hw, &hw->mbx, fm10k_msg_data_vf, 0);
 539 }
 540
 541 const struct fm10k_info fm10k_vf_info = {
 542         .mac            = fm10k_mac_vf,
 543         .get_invariants = fm10k_get_invariants_vf,
 544         .mac_ops        = &mac_ops_vf,
 545 };