Commit 8a0de61c authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'ionic-fw-recovery' 



Shannon Nelson says:

====================
ionic: updates for stable FW recovery

Recent FW work has tightened up timings in its error recovery
handling and uncovered weaknesses in the driver's responses,
so this is a set of updates primarily for better handling of
the firmware's recovery mechanisms.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents ca73b68a 36197d82

drivers/net/ethernet/pensando/ionic/ionic.h

+6 −1
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ struct ionic_lif; 
#define PCI_DEVICE_ID_PENSANDO_IONIC_ETH_PF	0x1002

#define PCI_DEVICE_ID_PENSANDO_IONIC_ETH_VF	0x1003



#define DEVCMD_TIMEOUT  10

#define DEVCMD_TIMEOUT			5

#define IONIC_ADMINQ_TIME_SLICE		msecs_to_jiffies(100)



#define IONIC_PHC_UPDATE_NS	10000000000	    /* 10s in nanoseconds */
@@ -78,6 +78,9 @@ void ionic_adminq_netdev_err_print(struct ionic_lif *lif, u8 opcode, 
				   u8 status, int err);



int ionic_dev_cmd_wait(struct ionic *ionic, unsigned long max_wait);

int ionic_dev_cmd_wait_nomsg(struct ionic *ionic, unsigned long max_wait);

void ionic_dev_cmd_dev_err_print(struct ionic *ionic, u8 opcode, u8 status,

				 int err);

int ionic_set_dma_mask(struct ionic *ionic);

int ionic_setup(struct ionic *ionic);
@@ -89,4 +92,6 @@ int ionic_port_identify(struct ionic *ionic); 
int ionic_port_init(struct ionic *ionic);

int ionic_port_reset(struct ionic *ionic);



const char *ionic_vf_attr_to_str(enum ionic_vf_attr attr);



#endif /* _IONIC_H_ */

drivers/net/ethernet/pensando/ionic/ionic_bus_pci.c

+10 −7
Original line number Diff line number Diff line
@@ -109,8 +109,8 @@ void ionic_bus_unmap_dbpage(struct ionic *ionic, void __iomem *page) 


static void ionic_vf_dealloc_locked(struct ionic *ionic)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_STATSADDR };

	struct ionic_vf *v;

	dma_addr_t dma = 0;

	int i;



	if (!ionic->vfs)
@@ -120,9 +120,8 @@ static void ionic_vf_dealloc_locked(struct ionic *ionic) 
		v = &ionic->vfs[i];



		if (v->stats_pa) {

			(void)ionic_set_vf_config(ionic, i,

						  IONIC_VF_ATTR_STATSADDR,

						  (u8 *)&dma);

			vfc.stats_pa = 0;

			(void)ionic_set_vf_config(ionic, i, &vfc);

			dma_unmap_single(ionic->dev, v->stats_pa,

					 sizeof(v->stats), DMA_FROM_DEVICE);

			v->stats_pa = 0;
@@ -143,6 +142,7 @@ static void ionic_vf_dealloc(struct ionic *ionic) 


static int ionic_vf_alloc(struct ionic *ionic, int num_vfs)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_STATSADDR };

	struct ionic_vf *v;

	int err = 0;

	int i;
@@ -166,9 +166,10 @@ static int ionic_vf_alloc(struct ionic *ionic, int num_vfs) 
		}



		ionic->num_vfs++;



		/* ignore failures from older FW, we just won't get stats */

		(void)ionic_set_vf_config(ionic, i, IONIC_VF_ATTR_STATSADDR,

					  (u8 *)&v->stats_pa);

		vfc.stats_pa = cpu_to_le64(v->stats_pa);

		(void)ionic_set_vf_config(ionic, i, &vfc);

	}



out:
@@ -331,6 +332,9 @@ static int ionic_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 
		goto err_out_deregister_lifs;

	}



	mod_timer(&ionic->watchdog_timer,

		  round_jiffies(jiffies + ionic->watchdog_period));



	return 0;



err_out_deregister_lifs:
@@ -348,7 +352,6 @@ static int ionic_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 
err_out_reset:

	ionic_reset(ionic);

err_out_teardown:

	del_timer_sync(&ionic->watchdog_timer);

	pci_clear_master(pdev);

	/* Don't fail the probe for these errors, keep

	 * the hw interface around for inspection

drivers/net/ethernet/pensando/ionic/ionic_dev.c

+95 −67
Original line number Diff line number Diff line
@@ -33,7 +33,8 @@ static void ionic_watchdog_cb(struct timer_list *t) 
	    !test_bit(IONIC_LIF_F_FW_RESET, lif->state))

		ionic_link_status_check_request(lif, CAN_NOT_SLEEP);



	if (test_bit(IONIC_LIF_F_FILTER_SYNC_NEEDED, lif->state)) {

	if (test_bit(IONIC_LIF_F_FILTER_SYNC_NEEDED, lif->state) &&

	    !test_bit(IONIC_LIF_F_FW_RESET, lif->state)) {

		work = kzalloc(sizeof(*work), GFP_ATOMIC);

		if (!work) {

			netdev_err(lif->netdev, "rxmode change dropped\n");
@@ -46,6 +47,24 @@ static void ionic_watchdog_cb(struct timer_list *t) 
	}

}



static void ionic_watchdog_init(struct ionic *ionic)

{

	struct ionic_dev *idev = &ionic->idev;



	timer_setup(&ionic->watchdog_timer, ionic_watchdog_cb, 0);

	ionic->watchdog_period = IONIC_WATCHDOG_SECS * HZ;



	/* set times to ensure the first check will proceed */

	atomic_long_set(&idev->last_check_time, jiffies - 2 * HZ);

	idev->last_hb_time = jiffies - 2 * ionic->watchdog_period;

	/* init as ready, so no transition if the first check succeeds */

	idev->last_fw_hb = 0;

	idev->fw_hb_ready = true;

	idev->fw_status_ready = true;

	idev->fw_generation = IONIC_FW_STS_F_GENERATION &

			      ioread8(&idev->dev_info_regs->fw_status);

}



void ionic_init_devinfo(struct ionic *ionic)

{

	struct ionic_dev *idev = &ionic->idev;
@@ -109,21 +128,7 @@ int ionic_dev_setup(struct ionic *ionic) 
		return -EFAULT;

	}



	timer_setup(&ionic->watchdog_timer, ionic_watchdog_cb, 0);

	ionic->watchdog_period = IONIC_WATCHDOG_SECS * HZ;



	/* set times to ensure the first check will proceed */

	atomic_long_set(&idev->last_check_time, jiffies - 2 * HZ);

	idev->last_hb_time = jiffies - 2 * ionic->watchdog_period;

	/* init as ready, so no transition if the first check succeeds */

	idev->last_fw_hb = 0;

	idev->fw_hb_ready = true;

	idev->fw_status_ready = true;

	idev->fw_generation = IONIC_FW_STS_F_GENERATION &

			      ioread8(&idev->dev_info_regs->fw_status);



	mod_timer(&ionic->watchdog_timer,

		  round_jiffies(jiffies + ionic->watchdog_period));

	ionic_watchdog_init(ionic);



	idev->db_pages = bar->vaddr;

	idev->phy_db_pages = bar->bus_addr;
@@ -132,10 +137,21 @@ int ionic_dev_setup(struct ionic *ionic) 
}



/* Devcmd Interface */

bool ionic_is_fw_running(struct ionic_dev *idev)

{

	u8 fw_status = ioread8(&idev->dev_info_regs->fw_status);



	/* firmware is useful only if the running bit is set and

	 * fw_status != 0xff (bad PCI read)

	 */

	return (fw_status != 0xff) && (fw_status & IONIC_FW_STS_F_RUNNING);

}



int ionic_heartbeat_check(struct ionic *ionic)

{

	struct ionic_dev *idev = &ionic->idev;

	unsigned long check_time, last_check_time;

	struct ionic_dev *idev = &ionic->idev;

	struct ionic_lif *lif = ionic->lif;

	bool fw_status_ready = true;

	bool fw_hb_ready;

	u8 fw_generation;
@@ -155,13 +171,10 @@ int ionic_heartbeat_check(struct ionic *ionic) 
		goto do_check_time;

	}



	/* firmware is useful only if the running bit is set and

	 * fw_status != 0xff (bad PCI read)

	 * If fw_status is not ready don't bother with the generation.

	 */

	fw_status = ioread8(&idev->dev_info_regs->fw_status);



	if (fw_status == 0xff || !(fw_status & IONIC_FW_STS_F_RUNNING)) {

	/* If fw_status is not ready don't bother with the generation */

	if (!ionic_is_fw_running(idev)) {

		fw_status_ready = false;

	} else {

		fw_generation = fw_status & IONIC_FW_STS_F_GENERATION;
@@ -176,31 +189,41 @@ int ionic_heartbeat_check(struct ionic *ionic) 
			 * the down, the next watchdog will see the fw is up

			 * and the generation value stable, so will trigger

			 * the fw-up activity.

			 *

			 * If we had already moved to FW_RESET from a RESET event,

			 * it is possible that we never saw the fw_status go to 0,

			 * so we fake the current idev->fw_status_ready here to

			 * force the transition and get FW up again.

			 */

			fw_status_ready = false;

			if (test_bit(IONIC_LIF_F_FW_RESET, lif->state))

				idev->fw_status_ready = false;	/* go to running */

			else

				fw_status_ready = false;	/* go to down */

		}

	}



	/* is this a transition? */

	if (fw_status_ready != idev->fw_status_ready) {

		struct ionic_lif *lif = ionic->lif;

		bool trigger = false;



		idev->fw_status_ready = fw_status_ready;



		if (!fw_status_ready) {

			dev_info(ionic->dev, "FW stopped %u\n", fw_status);

			if (lif && !test_bit(IONIC_LIF_F_FW_RESET, lif->state))

		if (!fw_status_ready && lif &&

		    !test_bit(IONIC_LIF_F_FW_RESET, lif->state) &&

		    !test_and_set_bit(IONIC_LIF_F_FW_STOPPING, lif->state)) {

			dev_info(ionic->dev, "FW stopped 0x%02x\n", fw_status);

			trigger = true;

		} else {

			dev_info(ionic->dev, "FW running %u\n", fw_status);

			if (lif && test_bit(IONIC_LIF_F_FW_RESET, lif->state))



		} else if (fw_status_ready && lif &&

			   test_bit(IONIC_LIF_F_FW_RESET, lif->state) &&

			   !test_bit(IONIC_LIF_F_FW_STOPPING, lif->state)) {

			dev_info(ionic->dev, "FW running 0x%02x\n", fw_status);

			trigger = true;

		}



		if (trigger) {

			struct ionic_deferred_work *work;



			idev->fw_status_ready = fw_status_ready;



			work = kzalloc(sizeof(*work), GFP_ATOMIC);

			if (work) {

				work->type = IONIC_DW_TYPE_LIF_RESET;
@@ -210,12 +233,14 @@ int ionic_heartbeat_check(struct ionic *ionic) 
		}

	}



	if (!fw_status_ready)

	if (!idev->fw_status_ready)

		return -ENXIO;



	/* wait at least one watchdog period since the last heartbeat */

	/* Because of some variability in the actual FW heartbeat, we

	 * wait longer than the DEVCMD_TIMEOUT before checking again.

	 */

	last_check_time = idev->last_hb_time;

	if (time_before(check_time, last_check_time + ionic->watchdog_period))

	if (time_before(check_time, last_check_time + DEVCMD_TIMEOUT * 2 * HZ))

		return 0;



	fw_hb = ioread32(&idev->dev_info_regs->fw_heartbeat);
@@ -392,60 +417,63 @@ void ionic_dev_cmd_port_pause(struct ionic_dev *idev, u8 pause_type) 
}



/* VF commands */

int ionic_set_vf_config(struct ionic *ionic, int vf, u8 attr, u8 *data)

int ionic_set_vf_config(struct ionic *ionic, int vf,

			struct ionic_vf_setattr_cmd *vfc)

{

	union ionic_dev_cmd cmd = {

		.vf_setattr.opcode = IONIC_CMD_VF_SETATTR,

		.vf_setattr.attr = attr,

		.vf_setattr.attr = vfc->attr,

		.vf_setattr.vf_index = cpu_to_le16(vf),

	};

	int err;



	memcpy(cmd.vf_setattr.pad, vfc->pad, sizeof(vfc->pad));



	mutex_lock(&ionic->dev_cmd_lock);

	ionic_dev_cmd_go(&ionic->idev, &cmd);

	err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);

	mutex_unlock(&ionic->dev_cmd_lock);



	return err;

}



int ionic_dev_cmd_vf_getattr(struct ionic *ionic, int vf, u8 attr,

			     struct ionic_vf_getattr_comp *comp)

{

	union ionic_dev_cmd cmd = {

		.vf_getattr.opcode = IONIC_CMD_VF_GETATTR,

		.vf_getattr.attr = attr,

		.vf_getattr.vf_index = cpu_to_le16(vf),

	};

	int err;



	if (vf >= ionic->num_vfs)

		return -EINVAL;



	switch (attr) {

	case IONIC_VF_ATTR_SPOOFCHK:

		cmd.vf_setattr.spoofchk = *data;

		dev_dbg(ionic->dev, "%s: vf %d spoof %d\n",

			__func__, vf, *data);

		break;

	case IONIC_VF_ATTR_TRUST:

		cmd.vf_setattr.trust = *data;

		dev_dbg(ionic->dev, "%s: vf %d trust %d\n",

			__func__, vf, *data);

		break;

	case IONIC_VF_ATTR_LINKSTATE:

		cmd.vf_setattr.linkstate = *data;

		dev_dbg(ionic->dev, "%s: vf %d linkstate %d\n",

			__func__, vf, *data);

		break;

	case IONIC_VF_ATTR_MAC:

		ether_addr_copy(cmd.vf_setattr.macaddr, data);

		dev_dbg(ionic->dev, "%s: vf %d macaddr %pM\n",

			__func__, vf, data);

		break;

	case IONIC_VF_ATTR_VLAN:

		cmd.vf_setattr.vlanid = cpu_to_le16(*(u16 *)data);

		dev_dbg(ionic->dev, "%s: vf %d vlan %d\n",

			__func__, vf, *(u16 *)data);

		break;

	case IONIC_VF_ATTR_RATE:

		cmd.vf_setattr.maxrate = cpu_to_le32(*(u32 *)data);

		dev_dbg(ionic->dev, "%s: vf %d maxrate %d\n",

			__func__, vf, *(u32 *)data);

		break;

	case IONIC_VF_ATTR_STATSADDR:

		cmd.vf_setattr.stats_pa = cpu_to_le64(*(u64 *)data);

		dev_dbg(ionic->dev, "%s: vf %d stats_pa 0x%08llx\n",

			__func__, vf, *(u64 *)data);

		break;

	default:

		return -EINVAL;

	}



	mutex_lock(&ionic->dev_cmd_lock);

	ionic_dev_cmd_go(&ionic->idev, &cmd);

	err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);

	err = ionic_dev_cmd_wait_nomsg(ionic, DEVCMD_TIMEOUT);

	memcpy_fromio(comp, &ionic->idev.dev_cmd_regs->comp.vf_getattr,

		      sizeof(*comp));

	mutex_unlock(&ionic->dev_cmd_lock);



	if (err && comp->status != IONIC_RC_ENOSUPP)

		ionic_dev_cmd_dev_err_print(ionic, cmd.vf_getattr.opcode,

					    comp->status, err);



	return err;

}

drivers/net/ethernet/pensando/ionic/ionic_dev.h

+5 −1
Original line number Diff line number Diff line
@@ -318,7 +318,10 @@ void ionic_dev_cmd_port_autoneg(struct ionic_dev *idev, u8 an_enable); 
void ionic_dev_cmd_port_fec(struct ionic_dev *idev, u8 fec_type);

void ionic_dev_cmd_port_pause(struct ionic_dev *idev, u8 pause_type);



int ionic_set_vf_config(struct ionic *ionic, int vf, u8 attr, u8 *data);

int ionic_set_vf_config(struct ionic *ionic, int vf,

			struct ionic_vf_setattr_cmd *vfc);

int ionic_dev_cmd_vf_getattr(struct ionic *ionic, int vf, u8 attr,

			     struct ionic_vf_getattr_comp *comp);

void ionic_dev_cmd_queue_identify(struct ionic_dev *idev,

				  u16 lif_type, u8 qtype, u8 qver);

void ionic_dev_cmd_lif_identify(struct ionic_dev *idev, u8 type, u8 ver);
@@ -353,5 +356,6 @@ void ionic_q_rewind(struct ionic_queue *q, struct ionic_desc_info *start); 
void ionic_q_service(struct ionic_queue *q, struct ionic_cq_info *cq_info,

		     unsigned int stop_index);

int ionic_heartbeat_check(struct ionic *ionic);

bool ionic_is_fw_running(struct ionic_dev *idev);



#endif /* _IONIC_DEV_H_ */

drivers/net/ethernet/pensando/ionic/ionic_lif.c

+139 −50
Original line number Diff line number Diff line
@@ -1112,13 +1112,18 @@ static bool ionic_notifyq_service(struct ionic_cq *cq, 
		ionic_link_status_check_request(lif, CAN_NOT_SLEEP);

		break;

	case IONIC_EVENT_RESET:

		if (lif->ionic->idev.fw_status_ready &&

		    !test_bit(IONIC_LIF_F_FW_RESET, lif->state) &&

		    !test_and_set_bit(IONIC_LIF_F_FW_STOPPING, lif->state)) {

			work = kzalloc(sizeof(*work), GFP_ATOMIC);

			if (!work) {

				netdev_err(lif->netdev, "Reset event dropped\n");

				clear_bit(IONIC_LIF_F_FW_STOPPING, lif->state);

			} else {

				work->type = IONIC_DW_TYPE_LIF_RESET;

				ionic_lif_deferred_enqueue(&lif->deferred, work);

			}

		}

		break;

	default:

		netdev_warn(netdev, "Notifyq event ecode=%d eid=%lld\n",
@@ -1782,7 +1787,7 @@ static void ionic_lif_quiesce(struct ionic_lif *lif) 


	err = ionic_adminq_post_wait(lif, &ctx);

	if (err)

		netdev_err(lif->netdev, "lif quiesce failed %d\n", err);

		netdev_dbg(lif->netdev, "lif quiesce failed %d\n", err);

}



static void ionic_txrx_disable(struct ionic_lif *lif)
@@ -2152,6 +2157,76 @@ static int ionic_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd 
	}

}



static int ionic_update_cached_vf_config(struct ionic *ionic, int vf)

{

	struct ionic_vf_getattr_comp comp = { 0 };

	int err;

	u8 attr;



	attr = IONIC_VF_ATTR_VLAN;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err)

		ionic->vfs[vf].vlanid = comp.vlanid;



	attr = IONIC_VF_ATTR_SPOOFCHK;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err)

		ionic->vfs[vf].spoofchk = comp.spoofchk;



	attr = IONIC_VF_ATTR_LINKSTATE;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err) {

		switch (comp.linkstate) {

		case IONIC_VF_LINK_STATUS_UP:

			ionic->vfs[vf].linkstate = IFLA_VF_LINK_STATE_ENABLE;

			break;

		case IONIC_VF_LINK_STATUS_DOWN:

			ionic->vfs[vf].linkstate = IFLA_VF_LINK_STATE_DISABLE;

			break;

		case IONIC_VF_LINK_STATUS_AUTO:

			ionic->vfs[vf].linkstate = IFLA_VF_LINK_STATE_AUTO;

			break;

		default:

			dev_warn(ionic->dev, "Unexpected link state %u\n", comp.linkstate);

			break;

		}

	}



	attr = IONIC_VF_ATTR_RATE;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err)

		ionic->vfs[vf].maxrate = comp.maxrate;



	attr = IONIC_VF_ATTR_TRUST;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err)

		ionic->vfs[vf].trusted = comp.trust;



	attr = IONIC_VF_ATTR_MAC;

	err = ionic_dev_cmd_vf_getattr(ionic, vf, attr, &comp);

	if (err && comp.status != IONIC_RC_ENOSUPP)

		goto err_out;

	if (!err)

		ether_addr_copy(ionic->vfs[vf].macaddr, comp.macaddr);



err_out:

	if (err)

		dev_err(ionic->dev, "Failed to get %s for VF %d\n",

			ionic_vf_attr_to_str(attr), vf);



	return err;

}



static int ionic_get_vf_config(struct net_device *netdev,

			       int vf, struct ifla_vf_info *ivf)

{
@@ -2168,14 +2243,18 @@ static int ionic_get_vf_config(struct net_device *netdev, 
		ret = -EINVAL;

	} else {

		ivf->vf = vf;

		ivf->vlan         = le16_to_cpu(ionic->vfs[vf].vlanid);

		ivf->qos = 0;



		ret = ionic_update_cached_vf_config(ionic, vf);

		if (!ret) {

			ivf->vlan         = le16_to_cpu(ionic->vfs[vf].vlanid);

			ivf->spoofchk     = ionic->vfs[vf].spoofchk;

			ivf->linkstate    = ionic->vfs[vf].linkstate;

			ivf->max_tx_rate  = le32_to_cpu(ionic->vfs[vf].maxrate);

			ivf->trusted      = ionic->vfs[vf].trusted;

			ether_addr_copy(ivf->mac, ionic->vfs[vf].macaddr);

		}

	}



	up_read(&ionic->vf_op_lock);

	return ret;
@@ -2220,6 +2299,7 @@ static int ionic_get_vf_stats(struct net_device *netdev, int vf, 


static int ionic_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_MAC };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	int ret;
@@ -2235,7 +2315,11 @@ static int ionic_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf, IONIC_VF_ATTR_MAC, mac);

		ether_addr_copy(vfc.macaddr, mac);

		dev_dbg(ionic->dev, "%s: vf %d macaddr %pM\n",

			__func__, vf, vfc.macaddr);



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			ether_addr_copy(ionic->vfs[vf].macaddr, mac);

	}
@@ -2247,6 +2331,7 @@ static int ionic_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 
static int ionic_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan,

			     u8 qos, __be16 proto)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_VLAN };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	int ret;
@@ -2269,8 +2354,11 @@ static int ionic_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf,

					  IONIC_VF_ATTR_VLAN, (u8 *)&vlan);

		vfc.vlanid = cpu_to_le16(vlan);

		dev_dbg(ionic->dev, "%s: vf %d vlan %d\n",

			__func__, vf, le16_to_cpu(vfc.vlanid));



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			ionic->vfs[vf].vlanid = cpu_to_le16(vlan);

	}
@@ -2282,6 +2370,7 @@ static int ionic_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, 
static int ionic_set_vf_rate(struct net_device *netdev, int vf,

			     int tx_min, int tx_max)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_RATE };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	int ret;
@@ -2298,8 +2387,11 @@ static int ionic_set_vf_rate(struct net_device *netdev, int vf, 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf,

					  IONIC_VF_ATTR_RATE, (u8 *)&tx_max);

		vfc.maxrate = cpu_to_le32(tx_max);

		dev_dbg(ionic->dev, "%s: vf %d maxrate %d\n",

			__func__, vf, le32_to_cpu(vfc.maxrate));



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			lif->ionic->vfs[vf].maxrate = cpu_to_le32(tx_max);

	}
@@ -2310,9 +2402,9 @@ static int ionic_set_vf_rate(struct net_device *netdev, int vf, 


static int ionic_set_vf_spoofchk(struct net_device *netdev, int vf, bool set)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_SPOOFCHK };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	u8 data = set;  /* convert to u8 for config */

	int ret;



	if (!netif_device_present(netdev))
@@ -2323,10 +2415,13 @@ static int ionic_set_vf_spoofchk(struct net_device *netdev, int vf, bool set) 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf,

					  IONIC_VF_ATTR_SPOOFCHK, &data);

		vfc.spoofchk = set;

		dev_dbg(ionic->dev, "%s: vf %d spoof %d\n",

			__func__, vf, vfc.spoofchk);



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			ionic->vfs[vf].spoofchk = data;

			ionic->vfs[vf].spoofchk = set;

	}



	up_write(&ionic->vf_op_lock);
@@ -2335,9 +2430,9 @@ static int ionic_set_vf_spoofchk(struct net_device *netdev, int vf, bool set) 


static int ionic_set_vf_trust(struct net_device *netdev, int vf, bool set)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_TRUST };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	u8 data = set;  /* convert to u8 for config */

	int ret;



	if (!netif_device_present(netdev))
@@ -2348,10 +2443,13 @@ static int ionic_set_vf_trust(struct net_device *netdev, int vf, bool set) 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf,

					  IONIC_VF_ATTR_TRUST, &data);

		vfc.trust = set;

		dev_dbg(ionic->dev, "%s: vf %d trust %d\n",

			__func__, vf, vfc.trust);



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			ionic->vfs[vf].trusted = data;

			ionic->vfs[vf].trusted = set;

	}



	up_write(&ionic->vf_op_lock);
@@ -2360,20 +2458,21 @@ static int ionic_set_vf_trust(struct net_device *netdev, int vf, bool set) 


static int ionic_set_vf_link_state(struct net_device *netdev, int vf, int set)

{

	struct ionic_vf_setattr_cmd vfc = { .attr = IONIC_VF_ATTR_LINKSTATE };

	struct ionic_lif *lif = netdev_priv(netdev);

	struct ionic *ionic = lif->ionic;

	u8 data;

	u8 vfls;

	int ret;



	switch (set) {

	case IFLA_VF_LINK_STATE_ENABLE:

		data = IONIC_VF_LINK_STATUS_UP;

		vfls = IONIC_VF_LINK_STATUS_UP;

		break;

	case IFLA_VF_LINK_STATE_DISABLE:

		data = IONIC_VF_LINK_STATUS_DOWN;

		vfls = IONIC_VF_LINK_STATUS_DOWN;

		break;

	case IFLA_VF_LINK_STATE_AUTO:

		data = IONIC_VF_LINK_STATUS_AUTO;

		vfls = IONIC_VF_LINK_STATUS_AUTO;

		break;

	default:

		return -EINVAL;
@@ -2387,8 +2486,11 @@ static int ionic_set_vf_link_state(struct net_device *netdev, int vf, int set) 
	if (vf >= pci_num_vf(ionic->pdev) || !ionic->vfs) {

		ret = -EINVAL;

	} else {

		ret = ionic_set_vf_config(ionic, vf,

					  IONIC_VF_ATTR_LINKSTATE, &data);

		vfc.linkstate = vfls;

		dev_dbg(ionic->dev, "%s: vf %d linkstate %d\n",

			__func__, vf, vfc.linkstate);



		ret = ionic_set_vf_config(ionic, vf, &vfc);

		if (!ret)

			ionic->vfs[vf].linkstate = set;

	}
@@ -2835,6 +2937,7 @@ static void ionic_lif_handle_fw_down(struct ionic_lif *lif) 


	mutex_unlock(&lif->queue_lock);



	clear_bit(IONIC_LIF_F_FW_STOPPING, lif->state);

	dev_info(ionic->dev, "FW Down: LIFs stopped\n");

}
@@ -2934,8 +3037,6 @@ void ionic_lif_free(struct ionic_lif *lif) 
	/* unmap doorbell page */

	ionic_bus_unmap_dbpage(lif->ionic, lif->kern_dbpage);

	lif->kern_dbpage = NULL;

	kfree(lif->dbid_inuse);

	lif->dbid_inuse = NULL;



	mutex_destroy(&lif->config_lock);

	mutex_destroy(&lif->queue_lock);
@@ -3135,22 +3236,12 @@ int ionic_lif_init(struct ionic_lif *lif) 
		return -EINVAL;

	}



	lif->dbid_inuse = bitmap_zalloc(lif->dbid_count, GFP_KERNEL);

	if (!lif->dbid_inuse) {

		dev_err(dev, "Failed alloc doorbell id bitmap, aborting\n");

		return -ENOMEM;

	}



	/* first doorbell id reserved for kernel (dbid aka pid == zero) */

	set_bit(0, lif->dbid_inuse);

	lif->kern_pid = 0;



	dbpage_num = ionic_db_page_num(lif, lif->kern_pid);

	lif->kern_dbpage = ionic_bus_map_dbpage(lif->ionic, dbpage_num);

	if (!lif->kern_dbpage) {

		dev_err(dev, "Cannot map dbpage, aborting\n");

		err = -ENOMEM;

		goto err_out_free_dbid;

		return -ENOMEM;

	}



	err = ionic_lif_adminq_init(lif);
@@ -3186,15 +3277,13 @@ int ionic_lif_init(struct ionic_lif *lif) 
	return 0;



err_out_notifyq_deinit:

	napi_disable(&lif->adminqcq->napi);

	ionic_lif_qcq_deinit(lif, lif->notifyqcq);

err_out_adminq_deinit:

	ionic_lif_qcq_deinit(lif, lif->adminqcq);

	ionic_lif_reset(lif);

	ionic_bus_unmap_dbpage(lif->ionic, lif->kern_dbpage);

	lif->kern_dbpage = NULL;

err_out_free_dbid:

	kfree(lif->dbid_inuse);

	lif->dbid_inuse = NULL;



	return err;

}