Commit 502eccec authored by Pavan Kumar Linga's avatar Pavan Kumar Linga Committed by Tony Nguyen
Browse files

idpf: move queue resources to idpf_q_vec_rsrc structure 



Move both TX and RX queue resources to the newly introduced
idpf_q_vec_rsrc structure.

Reviewed-by: default avatarAnton Nadezhdin <anton.nadezhdin@intel.com>
Signed-off-by: default avatarPavan Kumar Linga <pavan.kumar.linga@intel.com>
Signed-off-by: default avatarJoshua Hay <joshua.a.hay@intel.com>
Signed-off-by: default avatarTony Nguyen <anthony.l.nguyen@intel.com>
parent d1061502

drivers/net/ethernet/intel/idpf/idpf.h

+38 −33
Original line number Diff line number Diff line
@@ -291,14 +291,35 @@ struct idpf_fsteer_fltr { 


/**

 * struct idpf_q_vec_rsrc - handle for queue and vector resources

 * @dev: device pointer for DMA mapping

 * @q_vectors: array of queue vectors

 * @q_vector_idxs: starting index of queue vectors

 * @num_q_vectors: number of IRQ vectors allocated

 * @noirq_v_idx: ID of the NOIRQ vector

 * @noirq_dyn_ctl_ena: value to write to the above to enable it

 * @noirq_dyn_ctl: register to enable/disable the vector for NOIRQ queues

 * @txq_grps: array of TX queue groups

 * @txq_desc_count: TX queue descriptor count

 * @complq_desc_count: completion queue descriptor count

 * @txq_model: split queue or single queue queuing model

 * @num_txq: number of allocated TX queues

 * @num_complq: number of allocated completion queues

 * @num_txq_grp: number of TX queue groups

 * @num_rxq_grp: number of RX queues in a group

 * @rxq_model: splitq queue or single queue queuing model

 * @rxq_grps: total number of RX groups. Number of groups * number of RX per

 *	      group will yield total number of RX queues.

 * @num_rxq: number of allocated RX queues

 * @num_bufq: number of allocated buffer queues

 * @rxq_desc_count: RX queue descriptor count. *MUST* have enough descriptors

 *		    to complete all buffer descriptors for all buffer queues in

 *		    the worst case.

 * @bufq_desc_count: buffer queue descriptor count

 * @num_bufqs_per_qgrp: buffer queues per RX queue in a given grouping

 * @base_rxd: true if the driver should use base descriptors instead of flex

 */

struct idpf_q_vec_rsrc {

	struct device		*dev;

	struct idpf_q_vector	*q_vectors;

	u16			*q_vector_idxs;

	u16			num_q_vectors;
@@ -306,36 +327,36 @@ struct idpf_q_vec_rsrc { 
	u32			noirq_dyn_ctl_ena;

	void __iomem		*noirq_dyn_ctl;



	struct idpf_txq_group	*txq_grps;

	u32			txq_desc_count;

	u32			complq_desc_count;

	u32			txq_model;

	u16			num_txq;

	u16			num_complq;

	u16			num_txq_grp;



	u16			num_rxq_grp;

	u32			rxq_model;

	struct idpf_rxq_group	*rxq_grps;

	u16			num_rxq;

	u16			num_bufq;

	u32			rxq_desc_count;

	u32			bufq_desc_count[IDPF_MAX_BUFQS_PER_RXQ_GRP];

	u8			num_bufqs_per_qgrp;

	bool			base_rxd;

};



/**

 * struct idpf_vport - Handle for netdevices and queue resources

 * @dflt_qv_rsrc: contains default queue and vector resources

 * @num_txq: Number of allocated TX queues

 * @num_complq: Number of allocated completion queues

 * @txq_desc_count: TX queue descriptor count

 * @complq_desc_count: Completion queue descriptor count

 * @compln_clean_budget: Work budget for completion clean

 * @num_txq_grp: Number of TX queue groups

 * @txq_grps: Array of TX queue groups

 * @txq_model: Split queue or single queue queuing model

 * @txqs: Used only in hotpath to get to the right queue very fast

 * @crc_enable: Enable CRC insertion offload

 * @xdpsq_share: whether XDPSQ sharing is enabled

 * @num_xdp_txq: number of XDPSQs

 * @xdp_txq_offset: index of the first XDPSQ (== number of regular SQs)

 * @xdp_prog: installed XDP program

 * @num_rxq: Number of allocated RX queues

 * @num_bufq: Number of allocated buffer queues

 * @rxq_desc_count: RX queue descriptor count. *MUST* have enough descriptors

 *		    to complete all buffer descriptors for all buffer queues in

 *		    the worst case.

 * @num_bufqs_per_qgrp: Buffer queues per RX queue in a given grouping

 * @bufq_desc_count: Buffer queue descriptor count

 * @num_rxq_grp: Number of RX queues in a group

 * @rxq_grps: Total number of RX groups. Number of groups * number of RX per

 *	      group will yield total number of RX queues.

 * @rxq_model: Splitq queue or single queue queuing model

 * @rx_ptype_lkup: Lookup table for ptypes on RX

 * @vdev_info: IDC vport device info pointer

 * @adapter: back pointer to associated adapter
@@ -346,7 +367,6 @@ struct idpf_q_vec_rsrc { 
 * @vport_id: Device given vport identifier

 * @idx: Software index in adapter vports struct

 * @default_vport: Use this vport if one isn't specified

 * @base_rxd: True if the driver should use base descriptors instead of flex

 * @max_mtu: device given max possible MTU

 * @default_mac_addr: device will give a default MAC to use

 * @rx_itr_profile: RX profiles for Dynamic Interrupt Moderation
@@ -361,13 +381,7 @@ struct idpf_q_vec_rsrc { 
struct idpf_vport {

	struct idpf_q_vec_rsrc dflt_qv_rsrc;

	u16 num_txq;

	u16 num_complq;

	u32 txq_desc_count;

	u32 complq_desc_count;

	u32 compln_clean_budget;

	u16 num_txq_grp;

	struct idpf_txq_group *txq_grps;

	u32 txq_model;

	struct idpf_tx_queue **txqs;

	bool crc_enable;
@@ -376,14 +390,6 @@ struct idpf_vport { 
	u16 xdp_txq_offset;

	struct bpf_prog *xdp_prog;



	u16 num_rxq;

	u16 num_bufq;

	u32 rxq_desc_count;

	u8 num_bufqs_per_qgrp;

	u32 bufq_desc_count[IDPF_MAX_BUFQS_PER_RXQ_GRP];

	u16 num_rxq_grp;

	struct idpf_rxq_group *rxq_grps;

	u32 rxq_model;

	struct libeth_rx_pt *rx_ptype_lkup;



	struct iidc_rdma_vport_dev_info *vdev_info;
@@ -395,7 +401,6 @@ struct idpf_vport { 
	u32 vport_id;

	u16 idx;

	bool default_vport;

	bool base_rxd;



	u16 max_mtu;

	u8 default_mac_addr[ETH_ALEN];

drivers/net/ethernet/intel/idpf/idpf_ethtool.c

+45 −32
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ static u32 idpf_get_rx_ring_count(struct net_device *netdev) 


	idpf_vport_ctrl_lock(netdev);

	vport = idpf_netdev_to_vport(netdev);

	num_rxq = vport->num_rxq;

	num_rxq = vport->dflt_qv_rsrc.num_rxq;

	idpf_vport_ctrl_unlock(netdev);



	return num_rxq;
@@ -644,8 +644,8 @@ static void idpf_get_ringparam(struct net_device *netdev, 


	ring->rx_max_pending = IDPF_MAX_RXQ_DESC;

	ring->tx_max_pending = IDPF_MAX_TXQ_DESC;

	ring->rx_pending = vport->rxq_desc_count;

	ring->tx_pending = vport->txq_desc_count;

	ring->rx_pending = vport->dflt_qv_rsrc.rxq_desc_count;

	ring->tx_pending = vport->dflt_qv_rsrc.txq_desc_count;



	kring->tcp_data_split = idpf_vport_get_hsplit(vport);
@@ -669,6 +669,7 @@ static int idpf_set_ringparam(struct net_device *netdev, 
{

	struct idpf_vport_user_config_data *config_data;

	u32 new_rx_count, new_tx_count;

	struct idpf_q_vec_rsrc *rsrc;

	struct idpf_vport *vport;

	int i, err = 0;

	u16 idx;
@@ -704,8 +705,9 @@ static int idpf_set_ringparam(struct net_device *netdev, 
		netdev_info(netdev, "Requested Tx descriptor count rounded up to %u\n",

			    new_tx_count);



	if (new_tx_count == vport->txq_desc_count &&

	    new_rx_count == vport->rxq_desc_count &&

	rsrc = &vport->dflt_qv_rsrc;

	if (new_tx_count == rsrc->txq_desc_count &&

	    new_rx_count == rsrc->rxq_desc_count &&

	    kring->tcp_data_split == idpf_vport_get_hsplit(vport))

		goto unlock_mutex;
@@ -724,10 +726,10 @@ static int idpf_set_ringparam(struct net_device *netdev, 
	/* Since we adjusted the RX completion queue count, the RX buffer queue

	 * descriptor count needs to be adjusted as well

	 */

	for (i = 0; i < vport->num_bufqs_per_qgrp; i++)

		vport->bufq_desc_count[i] =

	for (i = 0; i < rsrc->num_bufqs_per_qgrp; i++)

		rsrc->bufq_desc_count[i] =

			IDPF_RX_BUFQ_DESC_COUNT(new_rx_count,

						vport->num_bufqs_per_qgrp);

						rsrc->num_bufqs_per_qgrp);



	err = idpf_initiate_soft_reset(vport, IDPF_SR_Q_DESC_CHANGE);
@@ -1104,6 +1106,7 @@ static void idpf_add_port_stats(struct idpf_vport *vport, u64 **data) 
static void idpf_collect_queue_stats(struct idpf_vport *vport)

{

	struct idpf_port_stats *pstats = &vport->port_stats;

	struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;

	int i, j;



	/* zero out port stats since they're actually tracked in per
@@ -1120,11 +1123,11 @@ static void idpf_collect_queue_stats(struct idpf_vport *vport) 
	u64_stats_set(&pstats->tx_dma_map_errs, 0);

	u64_stats_update_end(&pstats->stats_sync);



	for (i = 0; i < vport->num_rxq_grp; i++) {

		struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i];

	for (i = 0; i < rsrc->num_rxq_grp; i++) {

		struct idpf_rxq_group *rxq_grp = &rsrc->rxq_grps[i];

		u16 num_rxq;



		if (idpf_is_queue_model_split(vport->rxq_model))

		if (idpf_is_queue_model_split(rsrc->rxq_model))

			num_rxq = rxq_grp->splitq.num_rxq_sets;

		else

			num_rxq = rxq_grp->singleq.num_rxq;
@@ -1135,7 +1138,7 @@ static void idpf_collect_queue_stats(struct idpf_vport *vport) 
			struct idpf_rx_queue *rxq;

			unsigned int start;



			if (idpf_is_queue_model_split(vport->rxq_model))

			if (idpf_is_queue_model_split(rsrc->rxq_model))

				rxq = &rxq_grp->splitq.rxq_sets[j]->rxq;

			else

				rxq = rxq_grp->singleq.rxqs[j];
@@ -1162,8 +1165,8 @@ static void idpf_collect_queue_stats(struct idpf_vport *vport) 
		}

	}



	for (i = 0; i < vport->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &vport->txq_grps[i];

	for (i = 0; i < rsrc->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &rsrc->txq_grps[i];



		for (j = 0; j < txq_grp->num_txq; j++) {

			u64 linearize, qbusy, skb_drops, dma_map_errs;
@@ -1208,6 +1211,7 @@ static void idpf_get_ethtool_stats(struct net_device *netdev, 
{

	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_vport_config *vport_config;

	struct idpf_q_vec_rsrc *rsrc;

	struct idpf_vport *vport;

	unsigned int total = 0;

	unsigned int i, j;
@@ -1228,8 +1232,9 @@ static void idpf_get_ethtool_stats(struct net_device *netdev, 
	idpf_collect_queue_stats(vport);

	idpf_add_port_stats(vport, &data);



	for (i = 0; i < vport->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &vport->txq_grps[i];

	rsrc = &vport->dflt_qv_rsrc;

	for (i = 0; i < rsrc->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &rsrc->txq_grps[i];



		qtype = VIRTCHNL2_QUEUE_TYPE_TX;
@@ -1253,10 +1258,10 @@ static void idpf_get_ethtool_stats(struct net_device *netdev, 
		idpf_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_TX);

	total = 0;



	is_splitq = idpf_is_queue_model_split(vport->rxq_model);

	is_splitq = idpf_is_queue_model_split(rsrc->rxq_model);



	for (i = 0; i < vport->num_rxq_grp; i++) {

		struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i];

	for (i = 0; i < rsrc->num_rxq_grp; i++) {

		struct idpf_rxq_group *rxq_grp = &rsrc->rxq_grps[i];

		u16 num_rxq;



		qtype = VIRTCHNL2_QUEUE_TYPE_RX;
@@ -1298,15 +1303,16 @@ static void idpf_get_ethtool_stats(struct net_device *netdev, 
struct idpf_q_vector *idpf_find_rxq_vec(const struct idpf_vport *vport,

					u32 q_num)

{

	const struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;

	int q_grp, q_idx;



	if (!idpf_is_queue_model_split(vport->rxq_model))

		return vport->rxq_grps->singleq.rxqs[q_num]->q_vector;

	if (!idpf_is_queue_model_split(rsrc->rxq_model))

		return rsrc->rxq_grps->singleq.rxqs[q_num]->q_vector;



	q_grp = q_num / IDPF_DFLT_SPLITQ_RXQ_PER_GROUP;

	q_idx = q_num % IDPF_DFLT_SPLITQ_RXQ_PER_GROUP;



	return vport->rxq_grps[q_grp].splitq.rxq_sets[q_idx]->rxq.q_vector;

	return rsrc->rxq_grps[q_grp].splitq.rxq_sets[q_idx]->rxq.q_vector;

}



/**
@@ -1319,14 +1325,15 @@ struct idpf_q_vector *idpf_find_rxq_vec(const struct idpf_vport *vport, 
struct idpf_q_vector *idpf_find_txq_vec(const struct idpf_vport *vport,

					u32 q_num)

{

	const struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;

	int q_grp;



	if (!idpf_is_queue_model_split(vport->txq_model))

	if (!idpf_is_queue_model_split(rsrc->txq_model))

		return vport->txqs[q_num]->q_vector;



	q_grp = q_num / IDPF_DFLT_SPLITQ_TXQ_PER_GROUP;



	return vport->txq_grps[q_grp].complq->q_vector;

	return rsrc->txq_grps[q_grp].complq->q_vector;

}



/**
@@ -1363,7 +1370,8 @@ static int idpf_get_q_coalesce(struct net_device *netdev, 
			       u32 q_num)

{

	const struct idpf_netdev_priv *np = netdev_priv(netdev);

	const struct idpf_vport *vport;

	struct idpf_q_vec_rsrc *rsrc;

	struct idpf_vport *vport;

	int err = 0;



	idpf_vport_ctrl_lock(netdev);
@@ -1372,16 +1380,17 @@ static int idpf_get_q_coalesce(struct net_device *netdev, 
	if (!test_bit(IDPF_VPORT_UP, np->state))

		goto unlock_mutex;



	if (q_num >= vport->num_rxq && q_num >= vport->num_txq) {

	rsrc = &vport->dflt_qv_rsrc;

	if (q_num >= rsrc->num_rxq && q_num >= rsrc->num_txq) {

		err = -EINVAL;

		goto unlock_mutex;

	}



	if (q_num < vport->num_rxq)

	if (q_num < rsrc->num_rxq)

		__idpf_get_q_coalesce(ec, idpf_find_rxq_vec(vport, q_num),

				      VIRTCHNL2_QUEUE_TYPE_RX);



	if (q_num < vport->num_txq)

	if (q_num < rsrc->num_txq)

		__idpf_get_q_coalesce(ec, idpf_find_txq_vec(vport, q_num),

				      VIRTCHNL2_QUEUE_TYPE_TX);
@@ -1549,6 +1558,7 @@ static int idpf_set_coalesce(struct net_device *netdev, 
	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_vport_user_config_data *user_config;

	struct idpf_q_coalesce *q_coal;

	struct idpf_q_vec_rsrc *rsrc;

	struct idpf_vport *vport;

	int i, err = 0;
@@ -1560,14 +1570,15 @@ static int idpf_set_coalesce(struct net_device *netdev, 
	if (!test_bit(IDPF_VPORT_UP, np->state))

		goto unlock_mutex;



	for (i = 0; i < vport->num_txq; i++) {

	rsrc = &vport->dflt_qv_rsrc;

	for (i = 0; i < rsrc->num_txq; i++) {

		q_coal = &user_config->q_coalesce[i];

		err = idpf_set_q_coalesce(vport, q_coal, ec, i, false);

		if (err)

			goto unlock_mutex;

	}



	for (i = 0; i < vport->num_rxq; i++) {

	for (i = 0; i < rsrc->num_rxq; i++) {

		q_coal = &user_config->q_coalesce[i];

		err = idpf_set_q_coalesce(vport, q_coal, ec, i, true);

		if (err)
@@ -1748,6 +1759,7 @@ static void idpf_get_ts_stats(struct net_device *netdev, 
			      struct ethtool_ts_stats *ts_stats)

{

	struct idpf_netdev_priv *np = netdev_priv(netdev);

	struct idpf_q_vec_rsrc *rsrc;

	struct idpf_vport *vport;

	unsigned int start;
@@ -1763,8 +1775,9 @@ static void idpf_get_ts_stats(struct net_device *netdev, 
	if (!test_bit(IDPF_VPORT_UP, np->state))

		goto exit;



	for (u16 i = 0; i < vport->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &vport->txq_grps[i];

	rsrc = &vport->dflt_qv_rsrc;

	for (u16 i = 0; i < rsrc->num_txq_grp; i++) {

		struct idpf_txq_group *txq_grp = &rsrc->txq_grps[i];



		for (u16 j = 0; j < txq_grp->num_txq; j++) {

			struct idpf_tx_queue *txq = txq_grp->txqs[j];

drivers/net/ethernet/intel/idpf/idpf_lib.c

+38 −32
Original line number Diff line number Diff line
@@ -991,7 +991,7 @@ static void idpf_vport_stop(struct idpf_vport *vport, bool rtnl) 


	idpf_send_disable_vport_msg(vport);

	idpf_send_disable_queues_msg(vport);

	idpf_send_map_unmap_queue_vector_msg(vport, false);

	idpf_send_map_unmap_queue_vector_msg(vport, rsrc, false);

	/* Normally we ask for queues in create_vport, but if the number of

	 * initially requested queues have changed, for example via ethtool

	 * set channels, we do delete queues and then add the queues back
@@ -1004,8 +1004,8 @@ static void idpf_vport_stop(struct idpf_vport *vport, bool rtnl) 


	vport->link_up = false;

	idpf_vport_intr_deinit(vport, rsrc);

	idpf_xdp_rxq_info_deinit_all(vport);

	idpf_vport_queues_rel(vport);

	idpf_xdp_rxq_info_deinit_all(rsrc);

	idpf_vport_queues_rel(vport, rsrc);

	idpf_vport_intr_rel(rsrc);

	clear_bit(IDPF_VPORT_UP, np->state);
@@ -1159,7 +1159,7 @@ static void idpf_vport_dealloc(struct idpf_vport *vport) 
 */

static bool idpf_is_hsplit_supported(const struct idpf_vport *vport)

{

	return idpf_is_queue_model_split(vport->rxq_model) &&

	return idpf_is_queue_model_split(vport->dflt_qv_rsrc.rxq_model) &&

	       idpf_is_cap_ena_all(vport->adapter, IDPF_HSPLIT_CAPS,

				   IDPF_CAP_HSPLIT);

}
@@ -1277,6 +1277,7 @@ static struct idpf_vport *idpf_vport_alloc(struct idpf_adapter *adapter, 
			       idpf_get_default_vports(adapter);



	rsrc = &vport->dflt_qv_rsrc;

	rsrc->dev = &adapter->pdev->dev;

	rsrc->q_vector_idxs = kcalloc(num_max_q, sizeof(u16), GFP_KERNEL);

	if (!rsrc->q_vector_idxs)

		goto free_vport;
@@ -1427,9 +1428,10 @@ static void idpf_restore_features(struct idpf_vport *vport) 
 */

static int idpf_set_real_num_queues(struct idpf_vport *vport)

{

	int err, txq = vport->num_txq - vport->num_xdp_txq;

	int err, txq = vport->dflt_qv_rsrc.num_txq - vport->num_xdp_txq;



	err = netif_set_real_num_rx_queues(vport->netdev, vport->num_rxq);

	err = netif_set_real_num_rx_queues(vport->netdev,

					   vport->dflt_qv_rsrc.num_rxq);

	if (err)

		return err;
@@ -1454,17 +1456,17 @@ static void idpf_up_complete(struct idpf_vport *vport) 


/**

 * idpf_rx_init_buf_tail - Write initial buffer ring tail value

 * @vport: virtual port struct

 * @rsrc: pointer to queue and vector resources

 */

static void idpf_rx_init_buf_tail(struct idpf_vport *vport)

static void idpf_rx_init_buf_tail(struct idpf_q_vec_rsrc *rsrc)

{

	int i, j;



	for (i = 0; i < vport->num_rxq_grp; i++) {

		struct idpf_rxq_group *grp = &vport->rxq_grps[i];

	for (i = 0; i < rsrc->num_rxq_grp; i++) {

		struct idpf_rxq_group *grp = &rsrc->rxq_grps[i];



		if (idpf_is_queue_model_split(vport->rxq_model)) {

			for (j = 0; j < vport->num_bufqs_per_qgrp; j++) {

		if (idpf_is_queue_model_split(rsrc->rxq_model)) {

			for (j = 0; j < rsrc->num_bufqs_per_qgrp; j++) {

				const struct idpf_buf_queue *q =

					&grp->splitq.bufq_sets[j].bufq;
@@ -1511,14 +1513,14 @@ static int idpf_vport_open(struct idpf_vport *vport, bool rtnl) 
		goto err_rtnl_unlock;

	}



	err = idpf_vport_queues_alloc(vport);

	err = idpf_vport_queues_alloc(vport, rsrc);

	if (err)

		goto intr_rel;



	vport_config = adapter->vport_config[vport->idx];

	chunks = &vport_config->qid_reg_info;



	err = idpf_vport_queue_ids_init(vport, chunks);

	err = idpf_vport_queue_ids_init(vport, rsrc, chunks);

	if (err) {

		dev_err(&adapter->pdev->dev, "Failed to initialize queue ids for vport %u: %d\n",

			vport->vport_id, err);
@@ -1532,23 +1534,23 @@ static int idpf_vport_open(struct idpf_vport *vport, bool rtnl) 
		goto queues_rel;

	}



	err = idpf_queue_reg_init(vport, chunks);

	err = idpf_queue_reg_init(vport, rsrc, chunks);

	if (err) {

		dev_err(&adapter->pdev->dev, "Failed to initialize queue registers for vport %u: %d\n",

			vport->vport_id, err);

		goto intr_deinit;

	}



	err = idpf_rx_bufs_init_all(vport);

	err = idpf_rx_bufs_init_all(vport, rsrc);

	if (err) {

		dev_err(&adapter->pdev->dev, "Failed to initialize RX buffers for vport %u: %d\n",

			vport->vport_id, err);

		goto intr_deinit;

	}



	idpf_rx_init_buf_tail(vport);

	idpf_rx_init_buf_tail(rsrc);



	err = idpf_xdp_rxq_info_init_all(vport);

	err = idpf_xdp_rxq_info_init_all(rsrc);

	if (err) {

		netdev_err(vport->netdev,

			   "Failed to initialize XDP RxQ info for vport %u: %pe\n",
@@ -1558,14 +1560,14 @@ static int idpf_vport_open(struct idpf_vport *vport, bool rtnl) 


	idpf_vport_intr_ena(vport, rsrc);



	err = idpf_send_config_queues_msg(vport);

	err = idpf_send_config_queues_msg(vport, rsrc);

	if (err) {

		dev_err(&adapter->pdev->dev, "Failed to configure queues for vport %u, %d\n",

			vport->vport_id, err);

		goto rxq_deinit;

	}



	err = idpf_send_map_unmap_queue_vector_msg(vport, true);

	err = idpf_send_map_unmap_queue_vector_msg(vport, rsrc, true);

	if (err) {

		dev_err(&adapter->pdev->dev, "Failed to map queue vectors for vport %u: %d\n",

			vport->vport_id, err);
@@ -1608,13 +1610,13 @@ static int idpf_vport_open(struct idpf_vport *vport, bool rtnl) 
disable_queues:

	idpf_send_disable_queues_msg(vport);

unmap_queue_vectors:

	idpf_send_map_unmap_queue_vector_msg(vport, false);

	idpf_send_map_unmap_queue_vector_msg(vport, rsrc, false);

rxq_deinit:

	idpf_xdp_rxq_info_deinit_all(vport);

	idpf_xdp_rxq_info_deinit_all(rsrc);

intr_deinit:

	idpf_vport_intr_deinit(vport, rsrc);

queues_rel:

	idpf_vport_queues_rel(vport);

	idpf_vport_queues_rel(vport, rsrc);

intr_rel:

	idpf_vport_intr_rel(rsrc);
@@ -2003,8 +2005,10 @@ int idpf_initiate_soft_reset(struct idpf_vport *vport, 
{

	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);

	bool vport_is_up = test_bit(IDPF_VPORT_UP, np->state);

	struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;

	struct idpf_adapter *adapter = vport->adapter;

	struct idpf_vport_config *vport_config;

	struct idpf_q_vec_rsrc *new_rsrc;

	struct idpf_vport *new_vport;

	int err, tmp_err = 0;
@@ -2031,16 +2035,18 @@ int idpf_initiate_soft_reset(struct idpf_vport *vport, 
	 */

	memcpy(new_vport, vport, offsetof(struct idpf_vport, link_up));



	new_rsrc = &new_vport->dflt_qv_rsrc;



	/* Adjust resource parameters prior to reallocating resources */

	switch (reset_cause) {

	case IDPF_SR_Q_CHANGE:

		err = idpf_vport_adjust_qs(new_vport);

		err = idpf_vport_adjust_qs(new_vport, new_rsrc);

		if (err)

			goto free_vport;

		break;

	case IDPF_SR_Q_DESC_CHANGE:

		/* Update queue parameters before allocating resources */

		idpf_vport_calc_num_q_desc(new_vport);

		idpf_vport_calc_num_q_desc(new_vport, new_rsrc);

		break;

	case IDPF_SR_MTU_CHANGE:

		idpf_idc_vdev_mtu_event(vport->vdev_info,
@@ -2069,10 +2075,10 @@ int idpf_initiate_soft_reset(struct idpf_vport *vport, 
	 * to add code to add_queues to change the vport config within

	 * vport itself as it will be wiped with a memcpy later.

	 */

	err = idpf_send_add_queues_msg(vport, new_vport->num_txq,

				       new_vport->num_complq,

				       new_vport->num_rxq,

				       new_vport->num_bufq);

	err = idpf_send_add_queues_msg(vport, new_rsrc->num_txq,

				       new_rsrc->num_complq,

				       new_rsrc->num_rxq,

				       new_rsrc->num_bufq);

	if (err)

		goto err_reset;
@@ -2098,9 +2104,9 @@ int idpf_initiate_soft_reset(struct idpf_vport *vport, 
	goto free_vport;



err_reset:

	tmp_err = idpf_send_add_queues_msg(vport, vport->num_txq,

					   vport->num_complq, vport->num_rxq,

					   vport->num_bufq);

	tmp_err = idpf_send_add_queues_msg(vport, rsrc->num_txq,

					   rsrc->num_complq, rsrc->num_rxq,

					   rsrc->num_bufq);



err_open:

	if (!tmp_err && vport_is_up)

drivers/net/ethernet/intel/idpf/idpf_ptp.c

+10 −7
Original line number Diff line number Diff line
@@ -384,15 +384,17 @@ static int idpf_ptp_update_cached_phctime(struct idpf_adapter *adapter) 
	WRITE_ONCE(adapter->ptp->cached_phc_jiffies, jiffies);



	idpf_for_each_vport(adapter, vport) {

		struct idpf_q_vec_rsrc *rsrc;

		bool split;



		if (!vport || !vport->rxq_grps)

		if (!vport || !vport->dflt_qv_rsrc.rxq_grps)

			continue;



		split = idpf_is_queue_model_split(vport->rxq_model);

		rsrc = &vport->dflt_qv_rsrc;

		split = idpf_is_queue_model_split(rsrc->rxq_model);



		for (u16 i = 0; i < vport->num_rxq_grp; i++) {

			struct idpf_rxq_group *grp = &vport->rxq_grps[i];

		for (u16 i = 0; i < rsrc->num_rxq_grp; i++) {

			struct idpf_rxq_group *grp = &rsrc->rxq_grps[i];



			idpf_ptp_update_phctime_rxq_grp(grp, split, systime);

		}
@@ -681,9 +683,10 @@ int idpf_ptp_request_ts(struct idpf_tx_queue *tx_q, struct sk_buff *skb, 
 */

static void idpf_ptp_set_rx_tstamp(struct idpf_vport *vport, int rx_filter)

{

	struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;

	bool enable = true, splitq;



	splitq = idpf_is_queue_model_split(vport->rxq_model);

	splitq = idpf_is_queue_model_split(rsrc->rxq_model);



	if (rx_filter == HWTSTAMP_FILTER_NONE) {

		enable = false;
@@ -692,8 +695,8 @@ static void idpf_ptp_set_rx_tstamp(struct idpf_vport *vport, int rx_filter) 
		vport->tstamp_config.rx_filter = HWTSTAMP_FILTER_ALL;

	}



	for (u16 i = 0; i < vport->num_rxq_grp; i++) {

		struct idpf_rxq_group *grp = &vport->rxq_grps[i];

	for (u16 i = 0; i < rsrc->num_rxq_grp; i++) {

		struct idpf_rxq_group *grp = &rsrc->rxq_grps[i];

		struct idpf_rx_queue *rx_queue;

		u16 j, num_rxq;

drivers/net/ethernet/intel/idpf/idpf_txrx.c

+204 −176

File changed.

Preview size limit exceeded, changes collapsed.