1 /******************************************************************************
2 SPDX-License-Identifier: BSD-3-Clause
4 Copyright (c) 2001-2020, Intel Corporation
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
10 1. Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
13 2. Redistributions in binary form must reproduce the above copyright
14 notice, this list of conditions and the following disclaimer in the
15 documentation and/or other materials provided with the distribution.
17 3. Neither the name of the Intel Corporation nor the names of its
18 contributors may be used to endorse or promote products derived from
19 this software without specific prior written permission.
21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE.
33 ******************************************************************************/
37 #include "e1000_api.h"
40 static s32 e1000_init_phy_params_vf(struct e1000_hw *hw);
41 static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw);
42 static void e1000_release_vf(struct e1000_hw *hw);
43 static s32 e1000_acquire_vf(struct e1000_hw *hw);
44 static s32 e1000_setup_link_vf(struct e1000_hw *hw);
45 static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw);
46 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw);
47 static s32 e1000_check_for_link_vf(struct e1000_hw *hw);
48 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
50 static s32 e1000_init_hw_vf(struct e1000_hw *hw);
51 static s32 e1000_reset_hw_vf(struct e1000_hw *hw);
52 static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32);
53 static int e1000_rar_set_vf(struct e1000_hw *, u8 *, u32);
54 static s32 e1000_read_mac_addr_vf(struct e1000_hw *);
57 * e1000_init_phy_params_vf - Inits PHY params
58 * @hw: pointer to the HW structure
60 * Doesn't do much - there's no PHY available to the VF.
62 static s32 e1000_init_phy_params_vf(struct e1000_hw *hw)
64 DEBUGFUNC("e1000_init_phy_params_vf");
65 hw->phy.type = e1000_phy_vf;
66 hw->phy.ops.acquire = e1000_acquire_vf;
67 hw->phy.ops.release = e1000_release_vf;
73 * e1000_init_nvm_params_vf - Inits NVM params
74 * @hw: pointer to the HW structure
76 * Doesn't do much - there's no NVM available to the VF.
78 static s32 e1000_init_nvm_params_vf(struct e1000_hw *hw)
80 DEBUGFUNC("e1000_init_nvm_params_vf");
81 hw->nvm.type = e1000_nvm_none;
82 hw->nvm.ops.acquire = e1000_acquire_vf;
83 hw->nvm.ops.release = e1000_release_vf;
89 * e1000_init_mac_params_vf - Inits MAC params
90 * @hw: pointer to the HW structure
92 static s32 e1000_init_mac_params_vf(struct e1000_hw *hw)
94 struct e1000_mac_info *mac = &hw->mac;
96 DEBUGFUNC("e1000_init_mac_params_vf");
100 * Virtual functions don't care what they're media type is as they
101 * have no direct access to the PHY, or the media. That is handled
102 * by the physical function driver.
104 hw->phy.media_type = e1000_media_type_unknown;
106 /* No ASF features for the VF driver */
107 mac->asf_firmware_present = false;
108 /* ARC subsystem not supported */
109 mac->arc_subsystem_valid = false;
110 /* Disable adaptive IFS mode so the generic funcs don't do anything */
111 mac->adaptive_ifs = false;
112 /* VF's have no MTA Registers - PF feature only */
113 mac->mta_reg_count = 128;
114 /* VF's have no access to RAR entries */
115 mac->rar_entry_count = 1;
117 /* Function pointers */
119 mac->ops.setup_link = e1000_setup_link_vf;
120 /* bus type/speed/width */
121 mac->ops.get_bus_info = e1000_get_bus_info_pcie_vf;
123 mac->ops.reset_hw = e1000_reset_hw_vf;
124 /* hw initialization */
125 mac->ops.init_hw = e1000_init_hw_vf;
127 mac->ops.check_for_link = e1000_check_for_link_vf;
129 mac->ops.get_link_up_info = e1000_get_link_up_info_vf;
130 /* multicast address update */
131 mac->ops.update_mc_addr_list = e1000_update_mc_addr_list_vf;
132 /* set mac address */
133 mac->ops.rar_set = e1000_rar_set_vf;
134 /* read mac address */
135 mac->ops.read_mac_addr = e1000_read_mac_addr_vf;
138 return E1000_SUCCESS;
142 * e1000_init_function_pointers_vf - Inits function pointers
143 * @hw: pointer to the HW structure
145 void e1000_init_function_pointers_vf(struct e1000_hw *hw)
147 DEBUGFUNC("e1000_init_function_pointers_vf");
149 hw->mac.ops.init_params = e1000_init_mac_params_vf;
150 hw->nvm.ops.init_params = e1000_init_nvm_params_vf;
151 hw->phy.ops.init_params = e1000_init_phy_params_vf;
152 hw->mbx.ops.init_params = e1000_init_mbx_params_vf;
156 * e1000_acquire_vf - Acquire rights to access PHY or NVM.
157 * @hw: pointer to the HW structure
159 * There is no PHY or NVM so we want all attempts to acquire these to fail.
160 * In addition, the MAC registers to access PHY/NVM don't exist so we don't
161 * even want any SW to attempt to use them.
163 static s32 e1000_acquire_vf(struct e1000_hw E1000_UNUSEDARG *hw)
165 return -E1000_ERR_PHY;
169 * e1000_release_vf - Release PHY or NVM
170 * @hw: pointer to the HW structure
172 * There is no PHY or NVM so we want all attempts to acquire these to fail.
173 * In addition, the MAC registers to access PHY/NVM don't exist so we don't
174 * even want any SW to attempt to use them.
176 static void e1000_release_vf(struct e1000_hw E1000_UNUSEDARG *hw)
182 * e1000_setup_link_vf - Sets up link.
183 * @hw: pointer to the HW structure
185 * Virtual functions cannot change link.
187 static s32 e1000_setup_link_vf(struct e1000_hw E1000_UNUSEDARG *hw)
189 DEBUGFUNC("e1000_setup_link_vf");
191 return E1000_SUCCESS;
195 * e1000_get_bus_info_pcie_vf - Gets the bus info.
196 * @hw: pointer to the HW structure
198 * Virtual functions are not really on their own bus.
200 static s32 e1000_get_bus_info_pcie_vf(struct e1000_hw *hw)
202 struct e1000_bus_info *bus = &hw->bus;
204 DEBUGFUNC("e1000_get_bus_info_pcie_vf");
206 /* Do not set type PCI-E because we don't want disable master to run */
207 bus->type = e1000_bus_type_reserved;
208 bus->speed = e1000_bus_speed_2500;
214 * e1000_get_link_up_info_vf - Gets link info.
215 * @hw: pointer to the HW structure
216 * @speed: pointer to 16 bit value to store link speed.
217 * @duplex: pointer to 16 bit value to store duplex.
219 * Since we cannot read the PHY and get accurate link info, we must rely upon
220 * the status register's data which is often stale and inaccurate.
222 static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
227 DEBUGFUNC("e1000_get_link_up_info_vf");
229 status = E1000_READ_REG(hw, E1000_STATUS);
230 if (status & E1000_STATUS_SPEED_1000) {
232 DEBUGOUT("1000 Mbs, ");
233 } else if (status & E1000_STATUS_SPEED_100) {
235 DEBUGOUT("100 Mbs, ");
238 DEBUGOUT("10 Mbs, ");
241 if (status & E1000_STATUS_FD) {
242 *duplex = FULL_DUPLEX;
243 DEBUGOUT("Full Duplex\n");
245 *duplex = HALF_DUPLEX;
246 DEBUGOUT("Half Duplex\n");
249 return E1000_SUCCESS;
253 * e1000_reset_hw_vf - Resets the HW
254 * @hw: pointer to the HW structure
256 * VF's provide a function level reset. This is done using bit 26 of ctrl_reg.
257 * This is all the reset we can perform on a VF.
259 static s32 e1000_reset_hw_vf(struct e1000_hw *hw)
261 struct e1000_mbx_info *mbx = &hw->mbx;
262 u32 timeout = E1000_VF_INIT_TIMEOUT;
263 s32 ret_val = -E1000_ERR_MAC_INIT;
265 u8 *addr = (u8 *)(&msgbuf[1]);
267 DEBUGFUNC("e1000_reset_hw_vf");
269 DEBUGOUT("Issuing a function level reset to MAC\n");
270 ctrl = E1000_READ_REG(hw, E1000_CTRL);
271 E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
273 /* we cannot reset while the RSTI / RSTD bits are asserted */
274 while (!mbx->ops.check_for_rst(hw, 0) && timeout) {
280 /* mailbox timeout can now become active */
281 mbx->timeout = E1000_VF_MBX_INIT_TIMEOUT;
283 msgbuf[0] = E1000_VF_RESET;
284 mbx->ops.write_posted(hw, msgbuf, 1, 0);
288 /* set our "perm_addr" based on info provided by PF */
289 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
291 if (msgbuf[0] == (E1000_VF_RESET |
292 E1000_VT_MSGTYPE_ACK))
293 memcpy(hw->mac.perm_addr, addr, 6);
295 ret_val = -E1000_ERR_MAC_INIT;
303 * e1000_init_hw_vf - Inits the HW
304 * @hw: pointer to the HW structure
306 * Not much to do here except clear the PF Reset indication if there is one.
308 static s32 e1000_init_hw_vf(struct e1000_hw *hw)
310 DEBUGFUNC("e1000_init_hw_vf");
312 /* attempt to set and restore our mac address */
313 e1000_rar_set_vf(hw, hw->mac.addr, 0);
315 return E1000_SUCCESS;
319 * e1000_rar_set_vf - set device MAC address
320 * @hw: pointer to the HW structure
321 * @addr: pointer to the receive address
322 * @index receive address array register
324 static int e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr,
325 u32 E1000_UNUSEDARG index)
327 struct e1000_mbx_info *mbx = &hw->mbx;
329 u8 *msg_addr = (u8 *)(&msgbuf[1]);
332 memset(msgbuf, 0, 12);
333 msgbuf[0] = E1000_VF_SET_MAC_ADDR;
334 memcpy(msg_addr, addr, 6);
335 ret_val = mbx->ops.write_posted(hw, msgbuf, 3, 0);
338 ret_val = mbx->ops.read_posted(hw, msgbuf, 3, 0);
340 msgbuf[0] &= ~E1000_VT_MSGTYPE_CTS;
342 /* if nacked the address was rejected, use "perm_addr" */
344 (msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK)))
345 e1000_read_mac_addr_vf(hw);
347 return E1000_SUCCESS;
351 * e1000_hash_mc_addr_vf - Generate a multicast hash value
352 * @hw: pointer to the HW structure
353 * @mc_addr: pointer to a multicast address
355 * Generates a multicast address hash value which is used to determine
356 * the multicast filter table array address and new table value.
358 static u32 e1000_hash_mc_addr_vf(struct e1000_hw *hw, u8 *mc_addr)
360 u32 hash_value, hash_mask;
363 DEBUGFUNC("e1000_hash_mc_addr_generic");
365 /* Register count multiplied by bits per register */
366 hash_mask = (hw->mac.mta_reg_count * 32) - 1;
369 * The bit_shift is the number of left-shifts
370 * where 0xFF would still fall within the hash mask.
372 while (hash_mask >> bit_shift != 0xFF)
375 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
376 (((u16) mc_addr[5]) << bit_shift)));
381 static void e1000_write_msg_read_ack(struct e1000_hw *hw,
384 struct e1000_mbx_info *mbx = &hw->mbx;
385 u32 retmsg[E1000_VFMAILBOX_SIZE];
386 s32 retval = mbx->ops.write_posted(hw, msg, size, 0);
389 mbx->ops.read_posted(hw, retmsg, E1000_VFMAILBOX_SIZE, 0);
393 * e1000_update_mc_addr_list_vf - Update Multicast addresses
394 * @hw: pointer to the HW structure
395 * @mc_addr_list: array of multicast addresses to program
396 * @mc_addr_count: number of multicast addresses to program
398 * Updates the Multicast Table Array.
399 * The caller must have a packed mc_addr_list of multicast addresses.
401 void e1000_update_mc_addr_list_vf(struct e1000_hw *hw,
402 u8 *mc_addr_list, u32 mc_addr_count)
404 u32 msgbuf[E1000_VFMAILBOX_SIZE];
405 u16 *hash_list = (u16 *)&msgbuf[1];
409 DEBUGFUNC("e1000_update_mc_addr_list_vf");
411 /* Each entry in the list uses 1 16 bit word. We have 30
412 * 16 bit words available in our HW msg buffer (minus 1 for the
413 * msg type). That's 30 hash values if we pack 'em right. If
414 * there are more than 30 MC addresses to add then punt the
415 * extras for now and then add code to handle more than 30 later.
416 * It would be unusual for a server to request that many multi-cast
417 * addresses except for in large enterprise network environments.
420 DEBUGOUT1("MC Addr Count = %d\n", mc_addr_count);
422 msgbuf[0] = E1000_VF_SET_MULTICAST;
424 if (mc_addr_count > 30) {
425 msgbuf[0] |= E1000_VF_SET_MULTICAST_OVERFLOW;
429 msgbuf[0] |= mc_addr_count << E1000_VT_MSGINFO_SHIFT;
431 for (i = 0; i < mc_addr_count; i++) {
432 hash_value = e1000_hash_mc_addr_vf(hw, mc_addr_list);
433 DEBUGOUT1("Hash value = 0x%03X\n", hash_value);
434 hash_list[i] = hash_value & 0x0FFF;
435 mc_addr_list += ETHER_ADDR_LEN;
438 e1000_write_msg_read_ack(hw, msgbuf, E1000_VFMAILBOX_SIZE);
442 * e1000_vfta_set_vf - Set/Unset vlan filter table address
443 * @hw: pointer to the HW structure
444 * @vid: determines the vfta register and bit to set/unset
445 * @set: if true then set bit, else clear bit
447 void e1000_vfta_set_vf(struct e1000_hw *hw, u16 vid, bool set)
451 msgbuf[0] = E1000_VF_SET_VLAN;
453 /* Setting the 8 bit field MSG INFO to true indicates "add" */
455 msgbuf[0] |= E1000_VF_SET_VLAN_ADD;
457 e1000_write_msg_read_ack(hw, msgbuf, 2);
460 /** e1000_rlpml_set_vf - Set the maximum receive packet length
461 * @hw: pointer to the HW structure
462 * @max_size: value to assign to max frame size
464 void e1000_rlpml_set_vf(struct e1000_hw *hw, u16 max_size)
468 msgbuf[0] = E1000_VF_SET_LPE;
469 msgbuf[1] = max_size;
471 e1000_write_msg_read_ack(hw, msgbuf, 2);
475 * e1000_promisc_set_vf - Set flags for Unicast or Multicast promisc
476 * @hw: pointer to the HW structure
477 * @uni: boolean indicating unicast promisc status
478 * @multi: boolean indicating multicast promisc status
480 s32 e1000_promisc_set_vf(struct e1000_hw *hw, enum e1000_promisc_type type)
482 struct e1000_mbx_info *mbx = &hw->mbx;
483 u32 msgbuf = E1000_VF_SET_PROMISC;
487 case e1000_promisc_multicast:
488 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
490 case e1000_promisc_enabled:
491 msgbuf |= E1000_VF_SET_PROMISC_MULTICAST;
493 case e1000_promisc_unicast:
494 msgbuf |= E1000_VF_SET_PROMISC_UNICAST;
496 case e1000_promisc_disabled:
499 return -E1000_ERR_MAC_INIT;
502 ret_val = mbx->ops.write_posted(hw, &msgbuf, 1, 0);
505 ret_val = mbx->ops.read_posted(hw, &msgbuf, 1, 0);
507 if (!ret_val && !(msgbuf & E1000_VT_MSGTYPE_ACK))
508 ret_val = -E1000_ERR_MAC_INIT;
514 * e1000_read_mac_addr_vf - Read device MAC address
515 * @hw: pointer to the HW structure
517 static s32 e1000_read_mac_addr_vf(struct e1000_hw *hw)
521 for (i = 0; i < ETHER_ADDR_LEN; i++)
522 hw->mac.addr[i] = hw->mac.perm_addr[i];
524 return E1000_SUCCESS;
528 * e1000_check_for_link_vf - Check for link for a virtual interface
529 * @hw: pointer to the HW structure
531 * Checks to see if the underlying PF is still talking to the VF and
532 * if it is then it reports the link state to the hardware, otherwise
533 * it reports link down and returns an error.
535 static s32 e1000_check_for_link_vf(struct e1000_hw *hw)
537 struct e1000_mbx_info *mbx = &hw->mbx;
538 struct e1000_mac_info *mac = &hw->mac;
539 s32 ret_val = E1000_SUCCESS;
542 DEBUGFUNC("e1000_check_for_link_vf");
545 * We only want to run this if there has been a rst asserted.
546 * in this case that could mean a link change, device reset,
547 * or a virtual function reset
550 /* If we were hit with a reset or timeout drop the link */
551 if (!mbx->ops.check_for_rst(hw, 0) || !mbx->timeout)
552 mac->get_link_status = true;
554 if (!mac->get_link_status)
557 /* if link status is down no point in checking to see if pf is up */
558 if (!(E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU))
561 /* if the read failed it could just be a mailbox collision, best wait
562 * until we are called again and don't report an error */
563 if (mbx->ops.read(hw, &in_msg, 1, 0))
566 /* if incoming message isn't clear to send we are waiting on response */
567 if (!(in_msg & E1000_VT_MSGTYPE_CTS)) {
568 /* message is not CTS and is NACK we have lost CTS status */
569 if (in_msg & E1000_VT_MSGTYPE_NACK)
570 ret_val = -E1000_ERR_MAC_INIT;
574 /* at this point we know the PF is talking to us, check and see if
575 * we are still accepting timeout or if we had a timeout failure.
576 * if we failed then we will need to reinit */
578 ret_val = -E1000_ERR_MAC_INIT;
582 /* if we passed all the tests above then the link is up and we no
583 * longer need to check for link */
584 mac->get_link_status = false;