[deliverable/linux.git] / drivers / net / ixgbe / ixgbe_sriov.c

/*******************************************************************************

  Intel 10 Gigabit PCI Express Linux driver
  Copyright(c) 1999 - 2010 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include <linux/types.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/vmalloc.h>
#include <linux/string.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/ipv6.h>
#ifdef NETIF_F_HW_VLAN_TX
#include <linux/if_vlan.h>
#endif

#include "ixgbe.h"

#include "ixgbe_sriov.h"

static int ixgbe_set_vf_multicasts(struct ixgbe_adapter *adapter,
				   int entries, u16 *hash_list, u32 vf)
{
	struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
	struct ixgbe_hw *hw = &adapter->hw;
	int i;
	u32 vector_bit;
	u32 vector_reg;
	u32 mta_reg;

	/* only so many hash values supported */
	entries = min(entries, IXGBE_MAX_VF_MC_ENTRIES);

	/*
	 * salt away the number of multi cast addresses assigned
	 * to this VF for later use to restore when the PF multi cast
	 * list changes
	 */
	vfinfo->num_vf_mc_hashes = entries;

	/*
	 * VFs are limited to using the MTA hash table for their multicast
	 * addresses
	 */
	for (i = 0; i < entries; i++) {
		vfinfo->vf_mc_hashes[i] = hash_list[i];
	}

	for (i = 0; i < vfinfo->num_vf_mc_hashes; i++) {
		vector_reg = (vfinfo->vf_mc_hashes[i] >> 5) & 0x7F;
		vector_bit = vfinfo->vf_mc_hashes[i] & 0x1F;
		mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
		mta_reg |= (1 << vector_bit);
		IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
	}

	return 0;
}

void ixgbe_restore_vf_multicasts(struct ixgbe_adapter *adapter)
{
	struct ixgbe_hw *hw = &adapter->hw;
	struct vf_data_storage *vfinfo;
	int i, j;
	u32 vector_bit;
	u32 vector_reg;
	u32 mta_reg;

	for (i = 0; i < adapter->num_vfs; i++) {
		vfinfo = &adapter->vfinfo[i];
		for (j = 0; j < vfinfo->num_vf_mc_hashes; j++) {
			hw->addr_ctrl.mta_in_use++;
			vector_reg = (vfinfo->vf_mc_hashes[j] >> 5) & 0x7F;
			vector_bit = vfinfo->vf_mc_hashes[j] & 0x1F;
			mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
			mta_reg |= (1 << vector_bit);
			IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
		}
	}
}

static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
			     u32 vf)
{
	return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add);
}

static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
{
	u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
	vmolr |= (IXGBE_VMOLR_ROMPE |
		  IXGBE_VMOLR_BAM);
	if (aupe)
		vmolr |= IXGBE_VMOLR_AUPE;
	else
		vmolr &= ~IXGBE_VMOLR_AUPE;
	IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
}

static void ixgbe_set_vmvir(struct ixgbe_adapter *adapter, u32 vid, u32 vf)
{
	struct ixgbe_hw *hw = &adapter->hw;

	if (vid)
		IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf),
				(vid | IXGBE_VMVIR_VLANA_DEFAULT));
	else
		IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
}

static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
{
	struct ixgbe_hw *hw = &adapter->hw;
	int rar_entry = hw->mac.num_rar_entries - (vf + 1);

	/* reset offloads to defaults */
	if (adapter->vfinfo[vf].pf_vlan) {
		ixgbe_set_vf_vlan(adapter, true,
				  adapter->vfinfo[vf].pf_vlan, vf);
		ixgbe_set_vmvir(adapter,
				(adapter->vfinfo[vf].pf_vlan |
				 (adapter->vfinfo[vf].pf_qos <<
				  VLAN_PRIO_SHIFT)), vf);
		ixgbe_set_vmolr(hw, vf, false);
	} else {
		ixgbe_set_vmvir(adapter, 0, vf);
		ixgbe_set_vmolr(hw, vf, true);
	}

	/* reset multicast table array for vf */
	adapter->vfinfo[vf].num_vf_mc_hashes = 0;

	/* Flush and reset the mta with the new values */
	ixgbe_set_rx_mode(adapter->netdev);

	hw->mac.ops.clear_rar(hw, rar_entry);
}

static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,
			    int vf, unsigned char *mac_addr)
{
	struct ixgbe_hw *hw = &adapter->hw;
	int rar_entry = hw->mac.num_rar_entries - (vf + 1);

	memcpy(adapter->vfinfo[vf].vf_mac_addresses, mac_addr, 6);
	hw->mac.ops.set_rar(hw, rar_entry, mac_addr, vf, IXGBE_RAH_AV);

	return 0;
}

int ixgbe_vf_configuration(struct pci_dev *pdev, unsigned int event_mask)
{
	unsigned char vf_mac_addr[6];
	struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
	unsigned int vfn = (event_mask & 0x3f);

	bool enable = ((event_mask & 0x10000000U) != 0);

	if (enable) {
		random_ether_addr(vf_mac_addr);
		e_info(probe, "IOV: VF %d is enabled MAC %pM\n",
		       vfn, vf_mac_addr);
		/*
		 * Store away the VF "permananet" MAC address, it will ask
		 * for it later.
		 */
		memcpy(adapter->vfinfo[vfn].vf_mac_addresses, vf_mac_addr, 6);
	}

	return 0;
}

static inline void ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
{
	struct ixgbe_hw *hw = &adapter->hw;
	u32 reg;
	u32 reg_offset, vf_shift;

	vf_shift = vf % 32;
	reg_offset = vf / 32;

	/* enable transmit and receive for vf */
	reg = IXGBE_READ_REG(hw, IXGBE_VFTE(reg_offset));
	reg |= (reg | (1 << vf_shift));
	IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), reg);

	reg = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
	reg |= (reg | (1 << vf_shift));
	IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), reg);

	/* Enable counting of spoofed packets in the SSVPC register */
	reg = IXGBE_READ_REG(hw, IXGBE_VMECM(reg_offset));
	reg |= (1 << vf_shift);
	IXGBE_WRITE_REG(hw, IXGBE_VMECM(reg_offset), reg);

	ixgbe_vf_reset_event(adapter, vf);
}

static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
{
	u32 mbx_size = IXGBE_VFMAILBOX_SIZE;
	u32 msgbuf[mbx_size];
	struct ixgbe_hw *hw = &adapter->hw;
	s32 retval;
	int entries;
	u16 *hash_list;
	int add, vid;
	u8 *new_mac;

	retval = ixgbe_read_mbx(hw, msgbuf, mbx_size, vf);

	if (retval)
		pr_err("Error receiving message from VF\n");

	/* this is a message we already processed, do nothing */
	if (msgbuf[0] & (IXGBE_VT_MSGTYPE_ACK | IXGBE_VT_MSGTYPE_NACK))
		return retval;

	/*
	 * until the vf completes a virtual function reset it should not be
	 * allowed to start any configuration.
	 */

	if (msgbuf[0] == IXGBE_VF_RESET) {
		unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
		new_mac = (u8 *)(&msgbuf[1]);
		e_info(probe, "VF Reset msg received from vf %d\n", vf);
		adapter->vfinfo[vf].clear_to_send = false;
		ixgbe_vf_reset_msg(adapter, vf);
		adapter->vfinfo[vf].clear_to_send = true;

		if (is_valid_ether_addr(new_mac) &&
		    !adapter->vfinfo[vf].pf_set_mac)
			ixgbe_set_vf_mac(adapter, vf, vf_mac);
		else
			ixgbe_set_vf_mac(adapter,
				 vf, adapter->vfinfo[vf].vf_mac_addresses);

		/* reply to reset with ack and vf mac address */
		msgbuf[0] = IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK;
		memcpy(new_mac, vf_mac, IXGBE_ETH_LENGTH_OF_ADDRESS);
		/*
		 * Piggyback the multicast filter type so VF can compute the
		 * correct vectors
		 */
		msgbuf[3] = hw->mac.mc_filter_type;
		ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);

		return retval;
	}

	if (!adapter->vfinfo[vf].clear_to_send) {
		msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
		ixgbe_write_mbx(hw, msgbuf, 1, vf);
		return retval;
	}

	switch ((msgbuf[0] & 0xFFFF)) {
	case IXGBE_VF_SET_MAC_ADDR:
		new_mac = ((u8 *)(&msgbuf[1]));
		if (is_valid_ether_addr(new_mac) &&
		    !adapter->vfinfo[vf].pf_set_mac) {
			ixgbe_set_vf_mac(adapter, vf, new_mac);
		} else if (memcmp(adapter->vfinfo[vf].vf_mac_addresses,
				  new_mac, ETH_ALEN)) {
			e_warn(drv, "VF %d attempted to override "
			       "administratively set MAC address\nReload "
			       "the VF driver to resume operations\n", vf);
			retval = -1;
		}
		break;
	case IXGBE_VF_SET_MULTICAST:
		entries = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
		          >> IXGBE_VT_MSGINFO_SHIFT;
		hash_list = (u16 *)&msgbuf[1];
		retval = ixgbe_set_vf_multicasts(adapter, entries,
		                                 hash_list, vf);
		break;
	case IXGBE_VF_SET_LPE:
		WARN_ON((msgbuf[0] & 0xFFFF) == IXGBE_VF_SET_LPE);
		break;
	case IXGBE_VF_SET_VLAN:
		add = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
		      >> IXGBE_VT_MSGINFO_SHIFT;
		vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
		if (adapter->vfinfo[vf].pf_vlan) {
			e_warn(drv, "VF %d attempted to override "
			       "administratively set VLAN configuration\n"
			       "Reload the VF driver to resume operations\n",
			       vf);
			retval = -1;
		} else {
			retval = ixgbe_set_vf_vlan(adapter, add, vid, vf);
		}
		break;
	default:
		e_err(drv, "Unhandled Msg %8.8x\n", msgbuf[0]);
		retval = IXGBE_ERR_MBX;
		break;
	}

	/* notify the VF of the results of what it sent us */
	if (retval)
		msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
	else
		msgbuf[0] |= IXGBE_VT_MSGTYPE_ACK;

	msgbuf[0] |= IXGBE_VT_MSGTYPE_CTS;

	ixgbe_write_mbx(hw, msgbuf, 1, vf);

	return retval;
}

static void ixgbe_rcv_ack_from_vf(struct ixgbe_adapter *adapter, u32 vf)
{
	struct ixgbe_hw *hw = &adapter->hw;
	u32 msg = IXGBE_VT_MSGTYPE_NACK;

	/* if device isn't clear to send it shouldn't be reading either */
	if (!adapter->vfinfo[vf].clear_to_send)
		ixgbe_write_mbx(hw, &msg, 1, vf);
}

void ixgbe_msg_task(struct ixgbe_adapter *adapter)
{
	struct ixgbe_hw *hw = &adapter->hw;
	u32 vf;

	for (vf = 0; vf < adapter->num_vfs; vf++) {
		/* process any reset requests */
		if (!ixgbe_check_for_rst(hw, vf))
			ixgbe_vf_reset_event(adapter, vf);

		/* process any messages pending */
		if (!ixgbe_check_for_msg(hw, vf))
			ixgbe_rcv_msg_from_vf(adapter, vf);

		/* process any acks */
		if (!ixgbe_check_for_ack(hw, vf))
			ixgbe_rcv_ack_from_vf(adapter, vf);
	}
}

void ixgbe_disable_tx_rx(struct ixgbe_adapter *adapter)
{
	struct ixgbe_hw *hw = &adapter->hw;

	/* disable transmit and receive for all vfs */
	IXGBE_WRITE_REG(hw, IXGBE_VFTE(0), 0);
	IXGBE_WRITE_REG(hw, IXGBE_VFTE(1), 0);

	IXGBE_WRITE_REG(hw, IXGBE_VFRE(0), 0);
	IXGBE_WRITE_REG(hw, IXGBE_VFRE(1), 0);
}

void ixgbe_ping_all_vfs(struct ixgbe_adapter *adapter)
{
	struct ixgbe_hw *hw = &adapter->hw;
	u32 ping;
	int i;

	for (i = 0 ; i < adapter->num_vfs; i++) {
		ping = IXGBE_PF_CONTROL_MSG;
		if (adapter->vfinfo[i].clear_to_send)
			ping |= IXGBE_VT_MSGTYPE_CTS;
		ixgbe_write_mbx(hw, &ping, 1, i);
	}
}

int ixgbe_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	if (!is_valid_ether_addr(mac) || (vf >= adapter->num_vfs))
		return -EINVAL;
	adapter->vfinfo[vf].pf_set_mac = true;
	dev_info(&adapter->pdev->dev, "setting MAC %pM on VF %d\n", mac, vf);
	dev_info(&adapter->pdev->dev, "Reload the VF driver to make this"
				      " change effective.");
	if (test_bit(__IXGBE_DOWN, &adapter->state)) {
		dev_warn(&adapter->pdev->dev, "The VF MAC address has been set,"
			 " but the PF device is not up.\n");
		dev_warn(&adapter->pdev->dev, "Bring the PF device up before"
			 " attempting to use the VF device.\n");
	}
	return ixgbe_set_vf_mac(adapter, vf, mac);
}

int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
{
	int err = 0;
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	struct ixgbe_hw *hw = &adapter->hw;

	if ((vf >= adapter->num_vfs) || (vlan > 4095) || (qos > 7))
		return -EINVAL;
	if (vlan || qos) {
		err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
		if (err)
			goto out;
		ixgbe_set_vmvir(adapter, vlan | (qos << VLAN_PRIO_SHIFT), vf);
		ixgbe_set_vmolr(hw, vf, false);
		hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
		adapter->vfinfo[vf].pf_vlan = vlan;
		adapter->vfinfo[vf].pf_qos = qos;
		dev_info(&adapter->pdev->dev,
			 "Setting VLAN %d, QOS 0x%x on VF %d\n", vlan, qos, vf);
		if (test_bit(__IXGBE_DOWN, &adapter->state)) {
			dev_warn(&adapter->pdev->dev,
				 "The VF VLAN has been set,"
				 " but the PF device is not up.\n");
			dev_warn(&adapter->pdev->dev,
				 "Bring the PF device up before"
				 " attempting to use the VF device.\n");
		}
	} else {
		err = ixgbe_set_vf_vlan(adapter, false,
					adapter->vfinfo[vf].pf_vlan, vf);
		ixgbe_set_vmvir(adapter, vlan, vf);
		ixgbe_set_vmolr(hw, vf, true);
		hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
		adapter->vfinfo[vf].pf_vlan = 0;
		adapter->vfinfo[vf].pf_qos = 0;
       }
out:
       return err;
}

int ixgbe_ndo_set_vf_bw(struct net_device *netdev, int vf, int tx_rate)
{
	return -EOPNOTSUPP;
}

int ixgbe_ndo_get_vf_config(struct net_device *netdev,
			    int vf, struct ifla_vf_info *ivi)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	if (vf >= adapter->num_vfs)
		return -EINVAL;
	ivi->vf = vf;
	memcpy(&ivi->mac, adapter->vfinfo[vf].vf_mac_addresses, ETH_ALEN);
	ivi->tx_rate = 0;
	ivi->vlan = adapter->vfinfo[vf].pf_vlan;
	ivi->qos = adapter->vfinfo[vf].pf_qos;
	return 0;
}
Commit	Line	Data
17367270 GR	1	/*******************************************************************************
	2
	3	Intel 10 Gigabit PCI Express Linux driver
3a338cbb	4	Copyright(c) 1999 - 2010 Intel Corporation.
17367270 GR	5
	6	This program is free software; you can redistribute it and/or modify it
	7	under the terms and conditions of the GNU General Public License,
	8	version 2, as published by the Free Software Foundation.
	9
	10	This program is distributed in the hope it will be useful, but WITHOUT
	11	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	more details.
	14
	15	You should have received a copy of the GNU General Public License along with
	16	this program; if not, write to the Free Software Foundation, Inc.,
	17	51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	18
	19	The full GNU General Public License is included in this distribution in
	20	the file called "COPYING".
	21
	22	Contact Information:
	23	e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
	24	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	25
	26	*******************************************************************************/
	27
17367270 GR	28	#include <linux/types.h>
	29	#include <linux/module.h>
	30	#include <linux/pci.h>
	31	#include <linux/netdevice.h>
	32	#include <linux/vmalloc.h>
	33	#include <linux/string.h>
	34	#include <linux/in.h>
	35	#include <linux/ip.h>
	36	#include <linux/tcp.h>
	37	#include <linux/ipv6.h>
	38	#ifdef NETIF_F_HW_VLAN_TX
	39	#include <linux/if_vlan.h>
	40	#endif
	41
	42	#include "ixgbe.h"
	43
	44	#include "ixgbe_sriov.h"
	45
5d5b7c39 ET	46	static int ixgbe_set_vf_multicasts(struct ixgbe_adapter *adapter,
5d5b7c39 ET	47	int entries, u16 *hash_list, u32 vf)
17367270 GR	48	{
17367270 GR	49	struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
8a07a22d	50	struct ixgbe_hw *hw = &adapter->hw;
17367270	51	int i;
8a07a22d GR	52	u32 vector_bit;
	53	u32 vector_reg;
	54	u32 mta_reg;
17367270 GR	55
	56	/* only so many hash values supported */
	57	entries = min(entries, IXGBE_MAX_VF_MC_ENTRIES);
	58
	59	/*
	60	* salt away the number of multi cast addresses assigned
	61	* to this VF for later use to restore when the PF multi cast
	62	* list changes
	63	*/
	64	vfinfo->num_vf_mc_hashes = entries;
	65
	66	/*
	67	* VFs are limited to using the MTA hash table for their multicast
	68	* addresses
	69	*/
	70	for (i = 0; i < entries; i++) {
e81a1ba8	71	vfinfo->vf_mc_hashes[i] = hash_list[i];
17367270 GR	72	}
17367270 GR	73
8a07a22d GR	74	for (i = 0; i < vfinfo->num_vf_mc_hashes; i++) {
	75	vector_reg = (vfinfo->vf_mc_hashes[i] >> 5) & 0x7F;
	76	vector_bit = vfinfo->vf_mc_hashes[i] & 0x1F;
	77	mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
	78	mta_reg \|= (1 << vector_bit);
	79	IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
	80	}
17367270 GR	81
	82	return 0;
	83	}
	84
	85	void ixgbe_restore_vf_multicasts(struct ixgbe_adapter *adapter)
	86	{
	87	struct ixgbe_hw *hw = &adapter->hw;
	88	struct vf_data_storage *vfinfo;
	89	int i, j;
	90	u32 vector_bit;
	91	u32 vector_reg;
	92	u32 mta_reg;
	93
	94	for (i = 0; i < adapter->num_vfs; i++) {
	95	vfinfo = &adapter->vfinfo[i];
	96	for (j = 0; j < vfinfo->num_vf_mc_hashes; j++) {
	97	hw->addr_ctrl.mta_in_use++;
	98	vector_reg = (vfinfo->vf_mc_hashes[j] >> 5) & 0x7F;
	99	vector_bit = vfinfo->vf_mc_hashes[j] & 0x1F;
	100	mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
	101	mta_reg \|= (1 << vector_bit);
	102	IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
	103	}
	104	}
	105	}
	106
5d5b7c39 ET	107	static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
5d5b7c39 ET	108	u32 vf)
17367270	109	{
17367270 GR	110	return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add);
	111	}
	112
5d5b7c39	113	static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
17367270 GR	114	{
17367270 GR	115	u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
f0412776	116	vmolr \|= (IXGBE_VMOLR_ROMPE \|
17367270	117	IXGBE_VMOLR_BAM);
f0412776 GR	118	if (aupe)
	119	vmolr \|= IXGBE_VMOLR_AUPE;
	120	else
	121	vmolr &= ~IXGBE_VMOLR_AUPE;
17367270 GR	122	IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
	123	}
	124
7f01648a GR	125	static void ixgbe_set_vmvir(struct ixgbe_adapter *adapter, u32 vid, u32 vf)
	126	{
	127	struct ixgbe_hw *hw = &adapter->hw;
	128
	129	if (vid)
	130	IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf),
	131	(vid \| IXGBE_VMVIR_VLANA_DEFAULT));
	132	else
	133	IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
	134	}
	135
5d5b7c39	136	static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
17367270 GR	137	{
17367270 GR	138	struct ixgbe_hw *hw = &adapter->hw;
2850062a	139	int rar_entry = hw->mac.num_rar_entries - (vf + 1);
17367270 GR	140
17367270 GR	141	/* reset offloads to defaults */
7f01648a GR	142	if (adapter->vfinfo[vf].pf_vlan) {
	143	ixgbe_set_vf_vlan(adapter, true,
	144	adapter->vfinfo[vf].pf_vlan, vf);
	145	ixgbe_set_vmvir(adapter,
	146	(adapter->vfinfo[vf].pf_vlan \|
	147	(adapter->vfinfo[vf].pf_qos <<
	148	VLAN_PRIO_SHIFT)), vf);
	149	ixgbe_set_vmolr(hw, vf, false);
	150	} else {
	151	ixgbe_set_vmvir(adapter, 0, vf);
	152	ixgbe_set_vmolr(hw, vf, true);
	153	}
17367270 GR	154
	155	/* reset multicast table array for vf */
	156	adapter->vfinfo[vf].num_vf_mc_hashes = 0;
	157
	158	/* Flush and reset the mta with the new values */
	159	ixgbe_set_rx_mode(adapter->netdev);
	160
2850062a	161	hw->mac.ops.clear_rar(hw, rar_entry);
17367270 GR	162	}
17367270 GR	163
5d5b7c39 ET	164	static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,
5d5b7c39 ET	165	int vf, unsigned char *mac_addr)
17367270 GR	166	{
17367270 GR	167	struct ixgbe_hw *hw = &adapter->hw;
2850062a	168	int rar_entry = hw->mac.num_rar_entries - (vf + 1);
17367270 GR	169
17367270 GR	170	memcpy(adapter->vfinfo[vf].vf_mac_addresses, mac_addr, 6);
2850062a	171	hw->mac.ops.set_rar(hw, rar_entry, mac_addr, vf, IXGBE_RAH_AV);
17367270 GR	172
	173	return 0;
	174	}
	175
	176	int ixgbe_vf_configuration(struct pci_dev *pdev, unsigned int event_mask)
	177	{
	178	unsigned char vf_mac_addr[6];
c60fbb00	179	struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
17367270 GR	180	unsigned int vfn = (event_mask & 0x3f);
	181
	182	bool enable = ((event_mask & 0x10000000U) != 0);
	183
	184	if (enable) {
	185	random_ether_addr(vf_mac_addr);
396e799c ET	186	e_info(probe, "IOV: VF %d is enabled MAC %pM\n",
396e799c ET	187	vfn, vf_mac_addr);
17367270 GR	188	/*
	189	* Store away the VF "permananet" MAC address, it will ask
	190	* for it later.
	191	*/
	192	memcpy(adapter->vfinfo[vfn].vf_mac_addresses, vf_mac_addr, 6);
	193	}
	194
	195	return 0;
	196	}
	197
5d5b7c39	198	static inline void ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
17367270 GR	199	{
	200	struct ixgbe_hw *hw = &adapter->hw;
	201	u32 reg;
	202	u32 reg_offset, vf_shift;
	203
	204	vf_shift = vf % 32;
	205	reg_offset = vf / 32;
	206
	207	/* enable transmit and receive for vf */
	208	reg = IXGBE_READ_REG(hw, IXGBE_VFTE(reg_offset));
	209	reg \|= (reg \| (1 << vf_shift));
	210	IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), reg);
	211
	212	reg = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
	213	reg \|= (reg \| (1 << vf_shift));
	214	IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), reg);
	215
a985b6c3 GR	216	/* Enable counting of spoofed packets in the SSVPC register */
	217	reg = IXGBE_READ_REG(hw, IXGBE_VMECM(reg_offset));
	218	reg \|= (1 << vf_shift);
	219	IXGBE_WRITE_REG(hw, IXGBE_VMECM(reg_offset), reg);
	220
17367270 GR	221	ixgbe_vf_reset_event(adapter, vf);
	222	}
	223
	224	static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
	225	{
	226	u32 mbx_size = IXGBE_VFMAILBOX_SIZE;
	227	u32 msgbuf[mbx_size];
	228	struct ixgbe_hw *hw = &adapter->hw;
	229	s32 retval;
	230	int entries;
	231	u16 *hash_list;
	232	int add, vid;
d3306c29	233	u8 *new_mac;
17367270 GR	234
	235	retval = ixgbe_read_mbx(hw, msgbuf, mbx_size, vf);
	236
	237	if (retval)
849c4542	238	pr_err("Error receiving message from VF\n");
17367270 GR	239
	240	/* this is a message we already processed, do nothing */
	241	if (msgbuf[0] & (IXGBE_VT_MSGTYPE_ACK \| IXGBE_VT_MSGTYPE_NACK))
	242	return retval;
	243
	244	/*
	245	* until the vf completes a virtual function reset it should not be
	246	* allowed to start any configuration.
	247	*/
	248
	249	if (msgbuf[0] == IXGBE_VF_RESET) {
	250	unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
d3306c29	251	new_mac = (u8 *)(&msgbuf[1]);
396e799c	252	e_info(probe, "VF Reset msg received from vf %d\n", vf);
17367270 GR	253	adapter->vfinfo[vf].clear_to_send = false;
	254	ixgbe_vf_reset_msg(adapter, vf);
	255	adapter->vfinfo[vf].clear_to_send = true;
	256
d3306c29 GR	257	if (is_valid_ether_addr(new_mac) &&
	258	!adapter->vfinfo[vf].pf_set_mac)
	259	ixgbe_set_vf_mac(adapter, vf, vf_mac);
	260	else
	261	ixgbe_set_vf_mac(adapter,
	262	vf, adapter->vfinfo[vf].vf_mac_addresses);
	263
17367270 GR	264	/* reply to reset with ack and vf mac address */
17367270 GR	265	msgbuf[0] = IXGBE_VF_RESET \| IXGBE_VT_MSGTYPE_ACK;
d3306c29	266	memcpy(new_mac, vf_mac, IXGBE_ETH_LENGTH_OF_ADDRESS);
17367270 GR	267	/*
	268	* Piggyback the multicast filter type so VF can compute the
	269	* correct vectors
	270	*/
	271	msgbuf[3] = hw->mac.mc_filter_type;
	272	ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);
	273
	274	return retval;
	275	}
	276
	277	if (!adapter->vfinfo[vf].clear_to_send) {
	278	msgbuf[0] \|= IXGBE_VT_MSGTYPE_NACK;
	279	ixgbe_write_mbx(hw, msgbuf, 1, vf);
	280	return retval;
	281	}
	282
	283	switch ((msgbuf[0] & 0xFFFF)) {
	284	case IXGBE_VF_SET_MAC_ADDR:
d3306c29 GR	285	new_mac = ((u8 *)(&msgbuf[1]));
	286	if (is_valid_ether_addr(new_mac) &&
	287	!adapter->vfinfo[vf].pf_set_mac) {
	288	ixgbe_set_vf_mac(adapter, vf, new_mac);
	289	} else if (memcmp(adapter->vfinfo[vf].vf_mac_addresses,
	290	new_mac, ETH_ALEN)) {
	291	e_warn(drv, "VF %d attempted to override "
	292	"administratively set MAC address\nReload "
	293	"the VF driver to resume operations\n", vf);
	294	retval = -1;
17367270 GR	295	}
	296	break;
	297	case IXGBE_VF_SET_MULTICAST:
	298	entries = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
	299	>> IXGBE_VT_MSGINFO_SHIFT;
	300	hash_list = (u16 *)&msgbuf[1];
	301	retval = ixgbe_set_vf_multicasts(adapter, entries,
	302	hash_list, vf);
	303	break;
	304	case IXGBE_VF_SET_LPE:
	305	WARN_ON((msgbuf[0] & 0xFFFF) == IXGBE_VF_SET_LPE);
	306	break;
	307	case IXGBE_VF_SET_VLAN:
	308	add = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
	309	>> IXGBE_VT_MSGINFO_SHIFT;
	310	vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
d3306c29 GR	311	if (adapter->vfinfo[vf].pf_vlan) {
	312	e_warn(drv, "VF %d attempted to override "
	313	"administratively set VLAN configuration\n"
	314	"Reload the VF driver to resume operations\n",
	315	vf);
	316	retval = -1;
	317	} else {
	318	retval = ixgbe_set_vf_vlan(adapter, add, vid, vf);
	319	}
17367270 GR	320	break;
17367270 GR	321	default:
396e799c	322	e_err(drv, "Unhandled Msg %8.8x\n", msgbuf[0]);
17367270 GR	323	retval = IXGBE_ERR_MBX;
	324	break;
	325	}
	326
	327	/* notify the VF of the results of what it sent us */
	328	if (retval)
	329	msgbuf[0] \|= IXGBE_VT_MSGTYPE_NACK;
	330	else
	331	msgbuf[0] \|= IXGBE_VT_MSGTYPE_ACK;
	332
	333	msgbuf[0] \|= IXGBE_VT_MSGTYPE_CTS;
	334
	335	ixgbe_write_mbx(hw, msgbuf, 1, vf);
	336
	337	return retval;
	338	}
	339
	340	static void ixgbe_rcv_ack_from_vf(struct ixgbe_adapter *adapter, u32 vf)
	341	{
	342	struct ixgbe_hw *hw = &adapter->hw;
	343	u32 msg = IXGBE_VT_MSGTYPE_NACK;
	344
	345	/* if device isn't clear to send it shouldn't be reading either */
	346	if (!adapter->vfinfo[vf].clear_to_send)
	347	ixgbe_write_mbx(hw, &msg, 1, vf);
	348	}
	349
	350	void ixgbe_msg_task(struct ixgbe_adapter *adapter)
	351	{
	352	struct ixgbe_hw *hw = &adapter->hw;
	353	u32 vf;
	354
	355	for (vf = 0; vf < adapter->num_vfs; vf++) {
	356	/* process any reset requests */
	357	if (!ixgbe_check_for_rst(hw, vf))
	358	ixgbe_vf_reset_event(adapter, vf);
	359
	360	/* process any messages pending */
	361	if (!ixgbe_check_for_msg(hw, vf))
	362	ixgbe_rcv_msg_from_vf(adapter, vf);
	363
	364	/* process any acks */
	365	if (!ixgbe_check_for_ack(hw, vf))
	366	ixgbe_rcv_ack_from_vf(adapter, vf);
	367	}
	368	}
	369
767081ad GR	370	void ixgbe_disable_tx_rx(struct ixgbe_adapter *adapter)
	371	{
	372	struct ixgbe_hw *hw = &adapter->hw;
	373
	374	/* disable transmit and receive for all vfs */
	375	IXGBE_WRITE_REG(hw, IXGBE_VFTE(0), 0);
	376	IXGBE_WRITE_REG(hw, IXGBE_VFTE(1), 0);
	377
	378	IXGBE_WRITE_REG(hw, IXGBE_VFRE(0), 0);
	379	IXGBE_WRITE_REG(hw, IXGBE_VFRE(1), 0);
	380	}
	381
	382	void ixgbe_ping_all_vfs(struct ixgbe_adapter *adapter)
	383	{
	384	struct ixgbe_hw *hw = &adapter->hw;
	385	u32 ping;
	386	int i;
	387
	388	for (i = 0 ; i < adapter->num_vfs; i++) {
	389	ping = IXGBE_PF_CONTROL_MSG;
	390	if (adapter->vfinfo[i].clear_to_send)
	391	ping \|= IXGBE_VT_MSGTYPE_CTS;
	392	ixgbe_write_mbx(hw, &ping, 1, i);
	393	}
	394	}
	395
7f01648a GR	396	int ixgbe_ndo_set_vf_mac(struct net_device netdev, int vf, u8 mac)
	397	{
	398	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	399	if (!is_valid_ether_addr(mac) \|\| (vf >= adapter->num_vfs))
	400	return -EINVAL;
	401	adapter->vfinfo[vf].pf_set_mac = true;
	402	dev_info(&adapter->pdev->dev, "setting MAC %pM on VF %d\n", mac, vf);
	403	dev_info(&adapter->pdev->dev, "Reload the VF driver to make this"
	404	" change effective.");
	405	if (test_bit(__IXGBE_DOWN, &adapter->state)) {
	406	dev_warn(&adapter->pdev->dev, "The VF MAC address has been set,"
	407	" but the PF device is not up.\n");
	408	dev_warn(&adapter->pdev->dev, "Bring the PF device up before"
	409	" attempting to use the VF device.\n");
	410	}
	411	return ixgbe_set_vf_mac(adapter, vf, mac);
	412	}
	413
	414	int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
	415	{
	416	int err = 0;
	417	struct ixgbe_adapter *adapter = netdev_priv(netdev);
a985b6c3	418	struct ixgbe_hw *hw = &adapter->hw;
7f01648a GR	419
	420	if ((vf >= adapter->num_vfs) \|\| (vlan > 4095) \|\| (qos > 7))
	421	return -EINVAL;
	422	if (vlan \|\| qos) {
	423	err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
	424	if (err)
	425	goto out;
	426	ixgbe_set_vmvir(adapter, vlan \| (qos << VLAN_PRIO_SHIFT), vf);
a985b6c3 GR	427	ixgbe_set_vmolr(hw, vf, false);
a985b6c3 GR	428	hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
7f01648a GR	429	adapter->vfinfo[vf].pf_vlan = vlan;
	430	adapter->vfinfo[vf].pf_qos = qos;
	431	dev_info(&adapter->pdev->dev,
	432	"Setting VLAN %d, QOS 0x%x on VF %d\n", vlan, qos, vf);
	433	if (test_bit(__IXGBE_DOWN, &adapter->state)) {
	434	dev_warn(&adapter->pdev->dev,
	435	"The VF VLAN has been set,"
	436	" but the PF device is not up.\n");
	437	dev_warn(&adapter->pdev->dev,
	438	"Bring the PF device up before"
	439	" attempting to use the VF device.\n");
	440	}
	441	} else {
	442	err = ixgbe_set_vf_vlan(adapter, false,
	443	adapter->vfinfo[vf].pf_vlan, vf);
	444	ixgbe_set_vmvir(adapter, vlan, vf);
a985b6c3 GR	445	ixgbe_set_vmolr(hw, vf, true);
a985b6c3 GR	446	hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
7f01648a GR	447	adapter->vfinfo[vf].pf_vlan = 0;
	448	adapter->vfinfo[vf].pf_qos = 0;
	449	}
	450	out:
	451	return err;
	452	}
	453
	454	int ixgbe_ndo_set_vf_bw(struct net_device *netdev, int vf, int tx_rate)
	455	{
	456	return -EOPNOTSUPP;
	457	}
	458
	459	int ixgbe_ndo_get_vf_config(struct net_device *netdev,
	460	int vf, struct ifla_vf_info *ivi)
	461	{
	462	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	463	if (vf >= adapter->num_vfs)
	464	return -EINVAL;
	465	ivi->vf = vf;
	466	memcpy(&ivi->mac, adapter->vfinfo[vf].vf_mac_addresses, ETH_ALEN);
	467	ivi->tx_rate = 0;
	468	ivi->vlan = adapter->vfinfo[vf].pf_vlan;
	469	ivi->qos = adapter->vfinfo[vf].pf_qos;
	470	return 0;
	471	}