lib/librte_pmd_igb/igb/e1000_vf.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2001-2011, 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 /*$FreeBSD$*/
  34
  35
  36 #include "e1000_api.h"
  37
  38
  39 static s32       e1000_init_phy_params_vf(struct e1000_hw *hw);
  40 static s32       e1000_init_nvm_params_vf(struct e1000_hw *hw);
  41 static void      e1000_release_vf(struct e1000_hw *hw);
  42 static s32       e1000_acquire_vf(struct e1000_hw *hw);
  43 static s32       e1000_setup_link_vf(struct e1000_hw *hw);
  44 static s32       e1000_get_bus_info_pcie_vf(struct e1000_hw *hw);
  45 static s32       e1000_init_mac_params_vf(struct e1000_hw *hw);
  46 static s32       e1000_check_for_link_vf(struct e1000_hw *hw);
  47 static s32       e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
  48                                               u16 *duplex);
  49 static s32       e1000_init_hw_vf(struct e1000_hw *hw);
  50 static s32       e1000_reset_hw_vf(struct e1000_hw *hw);
  51 static void      e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32);
  52 static void      e1000_rar_set_vf(struct e1000_hw *, u8 *, u32);
  53 static s32       e1000_read_mac_addr_vf(struct e1000_hw *);
  54
  55 /**
  56  *  e1000_init_phy_params_vf - Inits PHY params
  57  *  @hw: pointer to the HW structure
  58  *
  59  *  Doesn't do much - there's no PHY available to the VF.
  60  **/
  61 static s32 e1000_init_phy_params_vf(struct e1000_hw *hw)
  62 {
  63         DEBUGFUNC("e1000_init_phy_params_vf");
  64         hw->phy.type = e1000_phy_vf;
  65         hw->phy.ops.acquire = e1000_acquire_vf;
  66         hw->phy.ops.release = e1000_release_vf;
  67
  68         return E1000_SUCCESS;
  69 }
  70
  71 /**
  72  *  e1000_init_nvm_params_vf - Inits NVM params
  73  *  @hw: pointer to the HW structure
  74  *
  75  *  Doesn't do much - there's no NVM available to the VF.
  76  **/
  77 static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw)
  78 {
  79         DEBUGFUNC("e1000_init_nvm_params_vf");
  80         hw->nvm.type = e1000_nvm_none;
  81         hw->nvm.ops.acquire = e1000_acquire_vf;
  82         hw->nvm.ops.release = e1000_release_vf;
  83
  84         return E1000_SUCCESS;
  85 }
  86
  87 /**
  88  *  e1000_init_mac_params_vf - Inits MAC params
  89  *  @hw: pointer to the HW structure
  90  **/
  91 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw)
  92 {
  93         struct e1000_mac_info *mac = &hw->mac;
  94
  95         DEBUGFUNC("e1000_init_mac_params_vf");
  96
  97         /* Set media type */
  98         /*
  99          * Virtual functions don't care what they're media type is as they
 100          * have no direct access to the PHY, or the media.  That is handled
 101          * by the physical function driver.
 102          */
 103         hw->phy.media_type = e1000_media_type_unknown;
 104
 105         /* No ASF features for the VF driver */
 106         mac->asf_firmware_present = FALSE;
 107         /* ARC subsystem not supported */
 108         mac->arc_subsystem_valid = FALSE;
 109         /* Disable adaptive IFS mode so the generic funcs don't do anything */
 110         mac->adaptive_ifs = FALSE;
 111         /* VF's have no MTA Registers - PF feature only */
 112         mac->mta_reg_count = 128;
 113         /* VF's have no access to RAR entries  */
 114         mac->rar_entry_count = 1;
 115
 116         /* Function pointers */
 117         /* link setup */
 118         mac->ops.setup_link = e1000_setup_link_vf;
 119         /* bus type/speed/width */
 120         mac->ops.get_bus_info = e1000_get_bus_info_pcie_vf;
 121         /* reset */
 122         mac->ops.reset_hw = e1000_reset_hw_vf;
 123         /* hw initialization */
 124         mac->ops.init_hw = e1000_init_hw_vf;
 125         /* check for link */
 126         mac->ops.check_for_link = e1000_check_for_link_vf;
 127         /* link info */
 128         mac->ops.get_link_up_info = e1000_get_link_up_info_vf;
 129         /* multicast address update */
 130         mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf;
 131         /* set mac address */
 132         mac->ops.rar_set = e1000_rar_set_vf;
 133         /* read mac address */
 134         mac->ops.read_mac_addr = e1000_read_mac_addr_vf;
 135
 136
 137         return E1000_SUCCESS;
 138 }
 139
 140 /**
 141  *  e1000_init_function_pointers_vf - Inits function pointers
 142  *  @hw: pointer to the HW structure
 143  **/
 144 void e1000_init_function_pointers_vf(struct e1000_hw *hw)
 145 {
 146         DEBUGFUNC("e1000_init_function_pointers_vf");
 147
 148         hw->mac.ops.init_params = e1000_init_mac_params_vf;
 149         hw->nvm.ops.init_params = e1000_init_nvm_params_vf;
 150         hw->phy.ops.init_params = e1000_init_phy_params_vf;
 151         hw->mbx.ops.init_params = e1000_init_mbx_params_vf;
 152 }
 153
 154 /**
 155  *  e1000_acquire_vf - Acquire rights to access PHY or NVM.
 156  *  @hw: pointer to the HW structure
 157  *
 158  *  There is no PHY or NVM so we want all attempts to acquire these to fail.
 159  *  In addition, the MAC registers to access PHY/NVM don't exist so we don't
 160  *  even want any SW to attempt to use them.
 161  **/
 162 static s32 e1000_acquire_vf(struct e1000_hw *hw)
 163 {
 164         return -E1000_ERR_PHY;
 165 }
 166
 167 /**
 168  *  e1000_release_vf - Release PHY or NVM
 169  *  @hw: pointer to the HW structure
 170  *
 171  *  There is no PHY or NVM so we want all attempts to acquire these to fail.
 172  *  In addition, the MAC registers to access PHY/NVM don't exist so we don't
 173  *  even want any SW to attempt to use them.
 174  **/
 175 static void e1000_release_vf(struct e1000_hw *hw)
 176 {
 177         return;
 178 }
 179
 180 /**
 181  *  e1000_setup_link_vf - Sets up link.
 182  *  @hw: pointer to the HW structure
 183  *
 184  *  Virtual functions cannot change link.
 185  **/
 186 static s32 e1000_setup_link_vf(struct e1000_hw *hw)
 187 {
 188         DEBUGFUNC("e1000_setup_link_vf");
 189
 190         return E1000_SUCCESS;
 191 }
 192
 193 /**
 194  *  e1000_get_bus_info_pcie_vf - Gets the bus info.
 195  *  @hw: pointer to the HW structure
 196  *
 197  *  Virtual functions are not really on their own bus.
 198  **/
 199 static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw)
 200 {
 201         struct e1000_bus_info *bus = &hw->bus;
 202
 203         DEBUGFUNC("e1000_get_bus_info_pcie_vf");
 204
 205         /* Do not set type PCI-E because we don't want disable master to run */
 206         bus->type = e1000_bus_type_reserved;
 207         bus->speed = e1000_bus_speed_2500;
 208
 209         return 0;
 210 }
 211
 212 /**
 213  *  e1000_get_link_up_info_vf - Gets link info.
 214  *  @hw: pointer to the HW structure
 215  *  @speed: pointer to 16 bit value to store link speed.
 216  *  @duplex: pointer to 16 bit value to store duplex.
 217  *
 218  *  Since we cannot read the PHY and get accurate link info, we must rely upon
 219  *  the status register's data which is often stale and inaccurate.
 220  **/
 221 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
 222                                      u16 *duplex)
 223 {
 224         s32 status;
 225
 226         DEBUGFUNC("e1000_get_link_up_info_vf");
 227
 228         status = E1000_READ_REG(hw, E1000_STATUS);
 229         if (status & E1000_STATUS_SPEED_1000) {
 230                 *speed = SPEED_1000;
 231                 DEBUGOUT("1000 Mbs, ");
 232         } else if (status & E1000_STATUS_SPEED_100) {
 233                 *speed = SPEED_100;
 234                 DEBUGOUT("100 Mbs, ");
 235         } else {
 236                 *speed = SPEED_10;
 237                 DEBUGOUT("10 Mbs, ");
 238         }
 239
 240         if (status & E1000_STATUS_FD) {
 241                 *duplex = FULL_DUPLEX;
 242                 DEBUGOUT("Full Duplex\n");
 243         } else {
 244                 *duplex = HALF_DUPLEX;
 245                 DEBUGOUT("Half Duplex\n");
 246         }
 247
 248         return E1000_SUCCESS;
 249 }
 250
 251 /**
 252  *  e1000_reset_hw_vf - Resets the HW
 253  *  @hw: pointer to the HW structure
 254  *
 255  *  VF's provide a function level reset. This is done using bit 26 of ctrl_reg.
 256  *  This is all the reset we can perform on a VF.
 257  **/
 258 static s32 e1000_reset_hw_vf(struct e1000_hw *hw)
 259 {
 260         struct e1000_mbx_info *mbx = &hw->mbx;
 261         u32 timeout = E1000_VF_INIT_TIMEOUT;
 262         s32 ret_val = -E1000_ERR_MAC_INIT;
 263         u32 ctrl, msgbuf[3];
 264         u8 *addr = (u8 *)(&msgbuf[1]);
 265
 266         DEBUGFUNC("e1000_reset_hw_vf");
 267
 268         DEBUGOUT("Issuing a function level reset to MAC\n");
 269         ctrl = E1000_READ_REG(hw, E1000_CTRL);
 270         E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
 271
 272         /* we cannot reset while the RSTI / RSTD bits are asserted */
 273         while (!mbx->ops.check_for_rst(hw, 0) && timeout) {
 274                 timeout--;
 275                 usec_delay(5);
 276         }
 277
 278         if (timeout) {
 279                 /* mailbox timeout can now become active */
 280                 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT;
 281
 282                 msgbuf[0] = E1000_VF_RESET;
 283                 mbx->ops.write_posted(hw, msgbuf, 1, 0);
 284
 285                 msec_delay(10);
 286
 287                 /* set our "perm_addr" based on info provided by PF */
 288                 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
 289                 if (!ret_val) {
 290                         if (msgbuf[0] == (E1000_VF_RESET |
 291                                                 E1000_VT_MSGTYPE_ACK))
 292                                 memcpy(hw->mac.perm_addr, addr, 6);
 293                         else
 294                                 ret_val = -E1000_ERR_MAC_INIT;
 295                 }
 296         }
 297
 298         return ret_val;
 299 }
 300
 301 /**
 302  *  e1000_init_hw_vf - Inits the HW
 303  *  @hw: pointer to the HW structure
 304  *
 305  *  Not much to do here except clear the PF Reset indication if there is one.
 306  **/
 307 static s32 e1000_init_hw_vf(struct e1000_hw *hw)
 308 {
 309         DEBUGFUNC("e1000_init_hw_vf");
 310
 311         /* attempt to set and restore our mac address */
 312         e1000_rar_set_vf(hw, hw->mac.addr, 0);
 313
 314         return E1000_SUCCESS;
 315 }
 316
 317 /**
 318  *  e1000_rar_set_vf - set device MAC address
 319  *  @hw: pointer to the HW structure
 320  *  @addr: pointer to the receive address
 321  *  @index receive address array register
 322  **/
 323 static void e1000_rar_set_vf(struct e1000_hw *hw, u8 * addr, u32 index)
 324 {
 325         struct e1000_mbx_info *mbx = &hw->mbx;
 326         u32 msgbuf[3];
 327         u8 *msg_addr = (u8 *)(&msgbuf[1]);
 328         s32 ret_val;
 329
 330         memset(msgbuf, 0, 12);
 331         msgbuf[0] = E1000_VF_SET_MAC_ADDR;
 332         memcpy(msg_addr, addr, 6);
 333         ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0);
 334
 335         if (!ret_val)
 336                 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
 337
 338         msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS;
 339
 340         /* if nacked the address was rejected, use "perm_addr" */
 341         if (!ret_val &&
 342             (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK)))
 343                 e1000_read_mac_addr_vf(hw);
 344 }
 345
 346 /**
 347  *  e1000_hash_mc_addr_vf - Generate a multicast hash value
 348  *  @hw: pointer to the HW structure
 349  *  @mc_addr: pointer to a multicast address
 350  *
 351  *  Generates a multicast address hash value which is used to determine
 352  *  the multicast filter table array address and new table value.
 353  **/
 354 static u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr)
 355 {
 356         u32 hash_value, hash_mask;
 357         u8 bit_shift = 0;
 358
 359         DEBUGFUNC("e1000_hash_mc_addr_generic");
 360
 361         /* Register count multiplied by bits per register */
 362         hash_mask = (hw->mac.mta_reg_count * 32) - 1;
 363
 364         /*
 365          * The bit_shift is the number of left-shifts
 366          * where 0xFF would still fall within the hash mask.
 367          */
 368         while (hash_mask >> bit_shift != 0xFF)
 369                 bit_shift++;
 370
 371         hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
 372                                   (((u16) mc_addr[5]) << bit_shift)));
 373
 374         return hash_value;
 375 }
 376
 377 /**
 378  *  e1000_update_mc_addr_list_vf - Update Multicast addresses
 379  *  @hw: pointer to the HW structure
 380  *  @mc_addr_list: array of multicast addresses to program
 381  *  @mc_addr_count: number of multicast addresses to program
 382  *
 383  *  Updates the Multicast Table Array.
 384  *  The caller must have a packed mc_addr_list of multicast addresses.
 385  **/
 386 void e1000_update_mc_addr_list_vf(struct e1000_hw *hw,
 387                                   u8 *mc_addr_list, u32 mc_addr_count)
 388 {
 389         struct e1000_mbx_info *mbx = &hw->mbx;
 390         u32 msgbuf[E1000_VFMAILBOX_SIZE];
 391         u16 *hash_list = (u16 *)&msgbuf[1];
 392         u32 hash_value;
 393         u32 i;
 394
 395         DEBUGFUNC("e1000_update_mc_addr_list_vf");
 396
 397         /* Each entry in the list uses 1 16 bit word.  We have 30
 398          * 16 bit words available in our HW msg buffer (minus 1 for the
 399          * msg type).  That's 30 hash values if we pack 'em right.  If
 400          * there are more than 30 MC addresses to add then punt the
 401          * extras for now and then add code to handle more than 30 later.
 402          * It would be unusual for a server to request that many multi-cast
 403          * addresses except for in large enterprise network environments.
 404          */
 405
 406         DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count);
 407
 408         if (mc_addr_count > 30) {
 409                 msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW;
 410                 mc_addr_count = 30;
 411         }
 412
 413         msgbuf[0] = E1000_VF_SET_MULTICAST;
 414         msgbuf[0] |= mc_addr_count << E1000_VT_MSGINFO_SHIFT;
 415
 416         for (i = 0; i < mc_addr_count; i++) {
 417                 hash_value = e1000_hash_mc_addr_vf(hw, mc_addr_list);
 418                 DEBUGOUT1("Hash value = 0x%03X\n", hash_value);
 419                 hash_list[i] = hash_value & 0x0FFF;
 420                 mc_addr_list += ETH_ADDR_LEN;
 421         }
 422
 423         mbx->ops.write_posted(hw, msgbuf, E1000_VFMAILBOX_SIZE, 0);
 424 }
 425
 426 /**
 427  *  e1000_vfta_set_vf - Set/Unset vlan filter table address
 428  *  @hw: pointer to the HW structure
 429  *  @vid: determines the vfta register and bit to set/unset
 430  *  @set: if TRUE then set bit, else clear bit
 431  **/
 432 void e1000_vfta_set_vf(struct e1000_hw *hw, u16 vid, bool set)
 433 {
 434         struct e1000_mbx_info *mbx = &hw->mbx;
 435         u32 msgbuf[2];
 436
 437         msgbuf[0] = E1000_VF_SET_VLAN;
 438         msgbuf[1] = vid;
 439         /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */
 440         if (set)
 441                 msgbuf[0] |= E1000_VF_SET_VLAN_ADD;
 442
 443         mbx->ops.write_posted(hw, msgbuf, 2, 0);
 444 }
 445
 446 /** e1000_rlpml_set_vf - Set the maximum receive packet length
 447  *  @hw: pointer to the HW structure
 448  *  @max_size: value to assign to max frame size
 449  **/
 450 void e1000_rlpml_set_vf(struct e1000_hw *hw, u16 max_size)
 451 {
 452         struct e1000_mbx_info *mbx = &hw->mbx;
 453         u32 msgbuf[2];
 454
 455         msgbuf[0] = E1000_VF_SET_LPE;
 456         msgbuf[1] = max_size;
 457
 458         mbx->ops.write_posted(hw, msgbuf, 2, 0);
 459 }
 460
 461 /**
 462  *  e1000_promisc_set_vf - Set flags for Unicast or Multicast promisc
 463  *  @hw: pointer to the HW structure
 464  *  @uni: boolean indicating unicast promisc status
 465  *  @multi: boolean indicating multicast promisc status
 466  **/
 467 s32 e1000_promisc_set_vf(struct e1000_hw *hw, enum e1000_promisc_type type)
 468 {
 469         struct e1000_mbx_info *mbx = &hw->mbx;
 470         u32 msgbuf = E1000_VF_SET_PROMISC;
 471         s32 ret_val;
 472
 473         switch (type) {
 474         case e1000_promisc_multicast:
 475                 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
 476                 break;
 477         case e1000_promisc_enabled:
 478                 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
 479         case e1000_promisc_unicast:
 480                 msgbuf |= E1000_VF_SET_PROMISC_UNICAST;
 481         case e1000_promisc_disabled:
 482                 break;
 483         default:
 484                 return -E1000_ERR_MAC_INIT;
 485         }
 486
 487          ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0);
 488
 489         if (!ret_val)
 490                 ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0);
 491
 492         if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK))
 493                 ret_val = -E1000_ERR_MAC_INIT;
 494
 495         return ret_val;
 496 }
 497
 498 /**
 499  *  e1000_read_mac_addr_vf - Read device MAC address
 500  *  @hw: pointer to the HW structure
 501  **/
 502 static s32 e1000_read_mac_addr_vf(struct e1000_hw *hw)
 503 {
 504         int i;
 505
 506         for (i = 0; i < ETH_ADDR_LEN; i++)
 507                 hw->mac.addr[i] = hw->mac.perm_addr[i];
 508
 509         return E1000_SUCCESS;
 510 }
 511
 512 /**
 513  *  e1000_check_for_link_vf - Check for link for a virtual interface
 514  *  @hw: pointer to the HW structure
 515  *
 516  *  Checks to see if the underlying PF is still talking to the VF and
 517  *  if it is then it reports the link state to the hardware, otherwise
 518  *  it reports link down and returns an error.
 519  **/
 520 static s32 e1000_check_for_link_vf(struct e1000_hw *hw)
 521 {
 522         struct e1000_mbx_info *mbx = &hw->mbx;
 523         struct e1000_mac_info *mac = &hw->mac;
 524         s32 ret_val = E1000_SUCCESS;
 525         u32 in_msg = 0;
 526
 527         DEBUGFUNC("e1000_check_for_link_vf");
 528
 529         /*
 530          * We only want to run this if there has been a rst asserted.
 531          * in this case that could mean a link change, device reset,
 532          * or a virtual function reset
 533          */
 534
 535         /* If we were hit with a reset or timeout drop the link */
 536         if (!mbx->ops.check_for_rst(hw, 0) || !mbx->timeout)
 537                 mac->get_link_status = TRUE;
 538
 539         if (!mac->get_link_status)
 540                 goto out;
 541
 542         /* if link status is down no point in checking to see if pf is up */
 543         if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU))
 544                 goto out;
 545
 546         /* if the read failed it could just be a mailbox collision, best wait
 547          * until we are called again and don't report an error */
 548         if (mbx->ops.read(hw, &in_msg, 1, 0))
 549                 goto out;
 550
 551         /* if incoming message isn't clear to send we are waiting on response */
 552         if (!(in_msg & E1000_VT_MSGTYPE_CTS)) {
 553                 /* message is not CTS and is NACK we have lost CTS status */
 554                 if (in_msg & E1000_VT_MSGTYPE_NACK)
 555                         ret_val = -E1000_ERR_MAC_INIT;
 556                 goto out;
 557         }
 558
 559         /* at this point we know the PF is talking to us, check and see if
 560          * we are still accepting timeout or if we had a timeout failure.
 561          * if we failed then we will need to reinit */
 562         if (!mbx->timeout) {
 563                 ret_val = -E1000_ERR_MAC_INIT;
 564                 goto out;
 565         }
 566
 567         /* if we passed all the tests above then the link is up and we no
 568          * longer need to check for link */
 569         mac->get_link_status = FALSE;
 570
 571 out:
 572         return ret_val;
 573 }
 574