1// SPDX-License-Identifier: GPL-2.0-only
   2/* Copyright (C) 2023 Intel Corporation */
   3
   4#include "idpf.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   5
   6/**
   7 * idpf_recv_event_msg - Receive virtchnl event message
   8 * @vport: virtual port structure
   9 * @ctlq_msg: message to copy from
  10 *
  11 * Receive virtchnl event message
  12 */
  13static void idpf_recv_event_msg(struct idpf_vport *vport,
  14				struct idpf_ctlq_msg *ctlq_msg)
  15{
  16	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
  17	struct virtchnl2_event *v2e;
  18	bool link_status;
  19	u32 event;
  20
 
 
 
 
 
 
 
  21	v2e = (struct virtchnl2_event *)ctlq_msg->ctx.indirect.payload->va;
  22	event = le32_to_cpu(v2e->event);
  23
  24	switch (event) {
  25	case VIRTCHNL2_EVENT_LINK_CHANGE:
  26		vport->link_speed_mbps = le32_to_cpu(v2e->link_speed);
  27		link_status = v2e->link_status;
  28
  29		if (vport->link_up == link_status)
  30			break;
  31
  32		vport->link_up = link_status;
  33		if (np->state == __IDPF_VPORT_UP) {
  34			if (vport->link_up) {
  35				netif_carrier_on(vport->netdev);
  36				netif_tx_start_all_queues(vport->netdev);
  37			} else {
  38				netif_tx_stop_all_queues(vport->netdev);
  39				netif_carrier_off(vport->netdev);
  40			}
  41		}
  42		break;
  43	default:
  44		dev_err(&vport->adapter->pdev->dev,
  45			"Unknown event %d from PF\n", event);
  46		break;
  47	}
  48}
  49
  50/**
  51 * idpf_mb_clean - Reclaim the send mailbox queue entries
  52 * @adapter: Driver specific private structure
  53 *
  54 * Reclaim the send mailbox queue entries to be used to send further messages
  55 *
  56 * Returns 0 on success, negative on failure
  57 */
  58static int idpf_mb_clean(struct idpf_adapter *adapter)
  59{
  60	u16 i, num_q_msg = IDPF_DFLT_MBX_Q_LEN;
  61	struct idpf_ctlq_msg **q_msg;
  62	struct idpf_dma_mem *dma_mem;
  63	int err;
  64
  65	q_msg = kcalloc(num_q_msg, sizeof(struct idpf_ctlq_msg *), GFP_ATOMIC);
  66	if (!q_msg)
  67		return -ENOMEM;
  68
  69	err = idpf_ctlq_clean_sq(adapter->hw.asq, &num_q_msg, q_msg);
  70	if (err)
  71		goto err_kfree;
  72
  73	for (i = 0; i < num_q_msg; i++) {
  74		if (!q_msg[i])
  75			continue;
  76		dma_mem = q_msg[i]->ctx.indirect.payload;
  77		if (dma_mem)
  78			dma_free_coherent(&adapter->pdev->dev, dma_mem->size,
  79					  dma_mem->va, dma_mem->pa);
  80		kfree(q_msg[i]);
  81		kfree(dma_mem);
  82	}
  83
  84err_kfree:
  85	kfree(q_msg);
  86
  87	return err;
  88}
  89
  90/**
  91 * idpf_send_mb_msg - Send message over mailbox
  92 * @adapter: Driver specific private structure
  93 * @op: virtchnl opcode
  94 * @msg_size: size of the payload
  95 * @msg: pointer to buffer holding the payload
 
  96 *
  97 * Will prepare the control queue message and initiates the send api
  98 *
  99 * Returns 0 on success, negative on failure
 100 */
 101int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op,
 102		     u16 msg_size, u8 *msg)
 103{
 104	struct idpf_ctlq_msg *ctlq_msg;
 105	struct idpf_dma_mem *dma_mem;
 106	int err;
 107
 108	/* If we are here and a reset is detected nothing much can be
 109	 * done. This thread should silently abort and expected to
 110	 * be corrected with a new run either by user or driver
 111	 * flows after reset
 112	 */
 113	if (idpf_is_reset_detected(adapter))
 114		return 0;
 115
 116	err = idpf_mb_clean(adapter);
 117	if (err)
 118		return err;
 119
 120	ctlq_msg = kzalloc(sizeof(*ctlq_msg), GFP_ATOMIC);
 121	if (!ctlq_msg)
 122		return -ENOMEM;
 123
 124	dma_mem = kzalloc(sizeof(*dma_mem), GFP_ATOMIC);
 125	if (!dma_mem) {
 126		err = -ENOMEM;
 127		goto dma_mem_error;
 128	}
 129
 130	ctlq_msg->opcode = idpf_mbq_opc_send_msg_to_cp;
 131	ctlq_msg->func_id = 0;
 132	ctlq_msg->data_len = msg_size;
 133	ctlq_msg->cookie.mbx.chnl_opcode = op;
 134	ctlq_msg->cookie.mbx.chnl_retval = 0;
 135	dma_mem->size = IDPF_CTLQ_MAX_BUF_LEN;
 136	dma_mem->va = dma_alloc_coherent(&adapter->pdev->dev, dma_mem->size,
 137					 &dma_mem->pa, GFP_ATOMIC);
 138	if (!dma_mem->va) {
 139		err = -ENOMEM;
 140		goto dma_alloc_error;
 141	}
 142	memcpy(dma_mem->va, msg, msg_size);
 
 
 
 143	ctlq_msg->ctx.indirect.payload = dma_mem;
 
 144
 145	err = idpf_ctlq_send(&adapter->hw, adapter->hw.asq, 1, ctlq_msg);
 146	if (err)
 147		goto send_error;
 148
 149	return 0;
 150
 151send_error:
 152	dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va,
 153			  dma_mem->pa);
 154dma_alloc_error:
 155	kfree(dma_mem);
 156dma_mem_error:
 157	kfree(ctlq_msg);
 158
 159	return err;
 160}
 161
 
 
 
 
 
 
 
 162/**
 163 * idpf_find_vport - Find vport pointer from control queue message
 164 * @adapter: driver specific private structure
 165 * @vport: address of vport pointer to copy the vport from adapters vport list
 166 * @ctlq_msg: control queue message
 167 *
 168 * Return 0 on success, error value on failure. Also this function does check
 169 * for the opcodes which expect to receive payload and return error value if
 170 * it is not the case.
 171 */
 172static int idpf_find_vport(struct idpf_adapter *adapter,
 173			   struct idpf_vport **vport,
 174			   struct idpf_ctlq_msg *ctlq_msg)
 175{
 176	bool no_op = false, vid_found = false;
 177	int i, err = 0;
 178	char *vc_msg;
 179	u32 v_id;
 180
 181	vc_msg = kcalloc(IDPF_CTLQ_MAX_BUF_LEN, sizeof(char), GFP_KERNEL);
 182	if (!vc_msg)
 183		return -ENOMEM;
 184
 185	if (ctlq_msg->data_len) {
 186		size_t payload_size = ctlq_msg->ctx.indirect.payload->size;
 
 
 
 
 187
 188		if (!payload_size) {
 189			dev_err(&adapter->pdev->dev, "Failed to receive payload buffer\n");
 190			kfree(vc_msg);
 
 
 
 
 
 
 191
 192			return -EINVAL;
 193		}
 
 194
 195		memcpy(vc_msg, ctlq_msg->ctx.indirect.payload->va,
 196		       min_t(size_t, payload_size, IDPF_CTLQ_MAX_BUF_LEN));
 197	}
 
 
 
 
 198
 199	switch (ctlq_msg->cookie.mbx.chnl_opcode) {
 200	case VIRTCHNL2_OP_VERSION:
 201	case VIRTCHNL2_OP_GET_CAPS:
 202	case VIRTCHNL2_OP_CREATE_VPORT:
 203	case VIRTCHNL2_OP_SET_SRIOV_VFS:
 204	case VIRTCHNL2_OP_ALLOC_VECTORS:
 205	case VIRTCHNL2_OP_DEALLOC_VECTORS:
 206	case VIRTCHNL2_OP_GET_PTYPE_INFO:
 207		goto free_vc_msg;
 208	case VIRTCHNL2_OP_ENABLE_VPORT:
 209	case VIRTCHNL2_OP_DISABLE_VPORT:
 210	case VIRTCHNL2_OP_DESTROY_VPORT:
 211		v_id = le32_to_cpu(((struct virtchnl2_vport *)vc_msg)->vport_id);
 212		break;
 213	case VIRTCHNL2_OP_CONFIG_TX_QUEUES:
 214		v_id = le32_to_cpu(((struct virtchnl2_config_tx_queues *)vc_msg)->vport_id);
 215		break;
 216	case VIRTCHNL2_OP_CONFIG_RX_QUEUES:
 217		v_id = le32_to_cpu(((struct virtchnl2_config_rx_queues *)vc_msg)->vport_id);
 218		break;
 219	case VIRTCHNL2_OP_ENABLE_QUEUES:
 220	case VIRTCHNL2_OP_DISABLE_QUEUES:
 221	case VIRTCHNL2_OP_DEL_QUEUES:
 222		v_id = le32_to_cpu(((struct virtchnl2_del_ena_dis_queues *)vc_msg)->vport_id);
 223		break;
 224	case VIRTCHNL2_OP_ADD_QUEUES:
 225		v_id = le32_to_cpu(((struct virtchnl2_add_queues *)vc_msg)->vport_id);
 226		break;
 227	case VIRTCHNL2_OP_MAP_QUEUE_VECTOR:
 228	case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR:
 229		v_id = le32_to_cpu(((struct virtchnl2_queue_vector_maps *)vc_msg)->vport_id);
 230		break;
 231	case VIRTCHNL2_OP_GET_STATS:
 232		v_id = le32_to_cpu(((struct virtchnl2_vport_stats *)vc_msg)->vport_id);
 233		break;
 234	case VIRTCHNL2_OP_GET_RSS_LUT:
 235	case VIRTCHNL2_OP_SET_RSS_LUT:
 236		v_id = le32_to_cpu(((struct virtchnl2_rss_lut *)vc_msg)->vport_id);
 237		break;
 238	case VIRTCHNL2_OP_GET_RSS_KEY:
 239	case VIRTCHNL2_OP_SET_RSS_KEY:
 240		v_id = le32_to_cpu(((struct virtchnl2_rss_key *)vc_msg)->vport_id);
 241		break;
 242	case VIRTCHNL2_OP_EVENT:
 243		v_id = le32_to_cpu(((struct virtchnl2_event *)vc_msg)->vport_id);
 244		break;
 245	case VIRTCHNL2_OP_LOOPBACK:
 246		v_id = le32_to_cpu(((struct virtchnl2_loopback *)vc_msg)->vport_id);
 247		break;
 248	case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE:
 249		v_id = le32_to_cpu(((struct virtchnl2_promisc_info *)vc_msg)->vport_id);
 250		break;
 251	case VIRTCHNL2_OP_ADD_MAC_ADDR:
 252	case VIRTCHNL2_OP_DEL_MAC_ADDR:
 253		v_id = le32_to_cpu(((struct virtchnl2_mac_addr_list *)vc_msg)->vport_id);
 254		break;
 255	default:
 256		no_op = true;
 257		break;
 258	}
 259
 260	if (no_op)
 261		goto free_vc_msg;
 262
 263	for (i = 0; i < idpf_get_max_vports(adapter); i++) {
 264		if (adapter->vport_ids[i] == v_id) {
 265			vid_found = true;
 266			break;
 267		}
 268	}
 269
 270	if (vid_found)
 271		*vport = adapter->vports[i];
 272	else
 273		err = -EINVAL;
 274
 275free_vc_msg:
 276	kfree(vc_msg);
 277
 278	return err;
 279}
 280
 281/**
 282 * idpf_copy_data_to_vc_buf - Copy the virtchnl response data into the buffer.
 283 * @adapter: driver specific private structure
 284 * @vport: virtual port structure
 285 * @ctlq_msg: msg to copy from
 286 * @err_enum: err bit to set on error
 287 *
 288 * Copies the payload from ctlq_msg into virtchnl buffer. Returns 0 on success,
 289 * negative on failure.
 290 */
 291static int idpf_copy_data_to_vc_buf(struct idpf_adapter *adapter,
 292				    struct idpf_vport *vport,
 293				    struct idpf_ctlq_msg *ctlq_msg,
 294				    enum idpf_vport_vc_state err_enum)
 295{
 296	if (ctlq_msg->cookie.mbx.chnl_retval) {
 297		if (vport)
 298			set_bit(err_enum, vport->vc_state);
 299		else
 300			set_bit(err_enum, adapter->vc_state);
 301
 302		return -EINVAL;
 303	}
 
 304
 305	if (vport)
 306		memcpy(vport->vc_msg, ctlq_msg->ctx.indirect.payload->va,
 307		       min_t(int, ctlq_msg->ctx.indirect.payload->size,
 308			     IDPF_CTLQ_MAX_BUF_LEN));
 309	else
 310		memcpy(adapter->vc_msg, ctlq_msg->ctx.indirect.payload->va,
 311		       min_t(int, ctlq_msg->ctx.indirect.payload->size,
 312			     IDPF_CTLQ_MAX_BUF_LEN));
 313
 314	return 0;
 
 
 
 
 
 315}
 316
 317/**
 318 * idpf_recv_vchnl_op - helper function with common logic when handling the
 319 * reception of VIRTCHNL OPs.
 320 * @adapter: driver specific private structure
 321 * @vport: virtual port structure
 322 * @ctlq_msg: msg to copy from
 323 * @state: state bit used on timeout check
 324 * @err_state: err bit to set on error
 325 */
 326static void idpf_recv_vchnl_op(struct idpf_adapter *adapter,
 327			       struct idpf_vport *vport,
 328			       struct idpf_ctlq_msg *ctlq_msg,
 329			       enum idpf_vport_vc_state state,
 330			       enum idpf_vport_vc_state err_state)
 331{
 332	wait_queue_head_t *vchnl_wq;
 333	int err;
 334
 335	if (vport)
 336		vchnl_wq = &vport->vchnl_wq;
 337	else
 338		vchnl_wq = &adapter->vchnl_wq;
 339
 340	err = idpf_copy_data_to_vc_buf(adapter, vport, ctlq_msg, err_state);
 341	if (wq_has_sleeper(vchnl_wq)) {
 342		if (vport)
 343			set_bit(state, vport->vc_state);
 344		else
 345			set_bit(state, adapter->vc_state);
 346
 347		wake_up(vchnl_wq);
 348	} else {
 349		if (!err) {
 350			dev_warn(&adapter->pdev->dev, "opcode %d received without waiting thread\n",
 351				 ctlq_msg->cookie.mbx.chnl_opcode);
 352		} else {
 353			/* Clear the errors since there is no sleeper to pass
 354			 * them on
 355			 */
 356			if (vport)
 357				clear_bit(err_state, vport->vc_state);
 358			else
 359				clear_bit(err_state, adapter->vc_state);
 360		}
 361	}
 362}
 363
 364/**
 365 * idpf_recv_mb_msg - Receive message over mailbox
 366 * @adapter: Driver specific private structure
 367 * @op: virtchannel operation code
 368 * @msg: Received message holding buffer
 369 * @msg_size: message size
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 370 *
 371 * Will receive control queue message and posts the receive buffer. Returns 0
 372 * on success and negative on failure.
 
 373 */
 374int idpf_recv_mb_msg(struct idpf_adapter *adapter, u32 op,
 375		     void *msg, int msg_size)
 376{
 377	struct idpf_vport *vport = NULL;
 378	struct idpf_ctlq_msg ctlq_msg;
 379	struct idpf_dma_mem *dma_mem;
 380	bool work_done = false;
 381	int num_retry = 2000;
 382	u16 num_q_msg;
 383	int err;
 384
 385	while (1) {
 386		struct idpf_vport_config *vport_config;
 387		int payload_size = 0;
 
 388
 389		/* Try to get one message */
 390		num_q_msg = 1;
 391		dma_mem = NULL;
 392		err = idpf_ctlq_recv(adapter->hw.arq, &num_q_msg, &ctlq_msg);
 393		/* If no message then decide if we have to retry based on
 394		 * opcode
 
 
 
 
 
 
 395		 */
 396		if (err || !num_q_msg) {
 397			/* Increasing num_retry to consider the delayed
 398			 * responses because of large number of VF's mailbox
 399			 * messages. If the mailbox message is received from
 400			 * the other side, we come out of the sleep cycle
 401			 * immediately else we wait for more time.
 402			 */
 403			if (!op || !num_retry--)
 404				break;
 405			if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
 406				err = -EIO;
 407				break;
 408			}
 409			msleep(20);
 410			continue;
 411		}
 412
 413		/* If we are here a message is received. Check if we are looking
 414		 * for a specific message based on opcode. If it is different
 415		 * ignore and post buffers
 416		 */
 417		if (op && ctlq_msg.cookie.mbx.chnl_opcode != op)
 418			goto post_buffs;
 
 
 
 
 
 
 
 
 
 
 
 
 
 419
 420		err = idpf_find_vport(adapter, &vport, &ctlq_msg);
 421		if (err)
 422			goto post_buffs;
 423
 424		if (ctlq_msg.data_len)
 425			payload_size = ctlq_msg.ctx.indirect.payload->size;
 426
 427		/* All conditions are met. Either a message requested is
 428		 * received or we received a message to be processed
 429		 */
 430		switch (ctlq_msg.cookie.mbx.chnl_opcode) {
 431		case VIRTCHNL2_OP_VERSION:
 432		case VIRTCHNL2_OP_GET_CAPS:
 433			if (ctlq_msg.cookie.mbx.chnl_retval) {
 434				dev_err(&adapter->pdev->dev, "Failure initializing, vc op: %u retval: %u\n",
 435					ctlq_msg.cookie.mbx.chnl_opcode,
 436					ctlq_msg.cookie.mbx.chnl_retval);
 437				err = -EBADMSG;
 438			} else if (msg) {
 439				memcpy(msg, ctlq_msg.ctx.indirect.payload->va,
 440				       min_t(int, payload_size, msg_size));
 441			}
 442			work_done = true;
 443			break;
 444		case VIRTCHNL2_OP_CREATE_VPORT:
 445			idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 446					   IDPF_VC_CREATE_VPORT,
 447					   IDPF_VC_CREATE_VPORT_ERR);
 448			break;
 449		case VIRTCHNL2_OP_ENABLE_VPORT:
 450			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 451					   IDPF_VC_ENA_VPORT,
 452					   IDPF_VC_ENA_VPORT_ERR);
 453			break;
 454		case VIRTCHNL2_OP_DISABLE_VPORT:
 455			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 456					   IDPF_VC_DIS_VPORT,
 457					   IDPF_VC_DIS_VPORT_ERR);
 458			break;
 459		case VIRTCHNL2_OP_DESTROY_VPORT:
 460			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 461					   IDPF_VC_DESTROY_VPORT,
 462					   IDPF_VC_DESTROY_VPORT_ERR);
 463			break;
 464		case VIRTCHNL2_OP_CONFIG_TX_QUEUES:
 465			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 466					   IDPF_VC_CONFIG_TXQ,
 467					   IDPF_VC_CONFIG_TXQ_ERR);
 468			break;
 469		case VIRTCHNL2_OP_CONFIG_RX_QUEUES:
 470			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 471					   IDPF_VC_CONFIG_RXQ,
 472					   IDPF_VC_CONFIG_RXQ_ERR);
 473			break;
 474		case VIRTCHNL2_OP_ENABLE_QUEUES:
 475			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 476					   IDPF_VC_ENA_QUEUES,
 477					   IDPF_VC_ENA_QUEUES_ERR);
 478			break;
 479		case VIRTCHNL2_OP_DISABLE_QUEUES:
 480			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 481					   IDPF_VC_DIS_QUEUES,
 482					   IDPF_VC_DIS_QUEUES_ERR);
 483			break;
 484		case VIRTCHNL2_OP_ADD_QUEUES:
 485			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 486					   IDPF_VC_ADD_QUEUES,
 487					   IDPF_VC_ADD_QUEUES_ERR);
 488			break;
 489		case VIRTCHNL2_OP_DEL_QUEUES:
 490			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 491					   IDPF_VC_DEL_QUEUES,
 492					   IDPF_VC_DEL_QUEUES_ERR);
 493			break;
 494		case VIRTCHNL2_OP_MAP_QUEUE_VECTOR:
 495			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 496					   IDPF_VC_MAP_IRQ,
 497					   IDPF_VC_MAP_IRQ_ERR);
 498			break;
 499		case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR:
 500			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 501					   IDPF_VC_UNMAP_IRQ,
 502					   IDPF_VC_UNMAP_IRQ_ERR);
 503			break;
 504		case VIRTCHNL2_OP_GET_STATS:
 505			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 506					   IDPF_VC_GET_STATS,
 507					   IDPF_VC_GET_STATS_ERR);
 508			break;
 509		case VIRTCHNL2_OP_GET_RSS_LUT:
 510			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 511					   IDPF_VC_GET_RSS_LUT,
 512					   IDPF_VC_GET_RSS_LUT_ERR);
 513			break;
 514		case VIRTCHNL2_OP_SET_RSS_LUT:
 515			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 516					   IDPF_VC_SET_RSS_LUT,
 517					   IDPF_VC_SET_RSS_LUT_ERR);
 518			break;
 519		case VIRTCHNL2_OP_GET_RSS_KEY:
 520			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 521					   IDPF_VC_GET_RSS_KEY,
 522					   IDPF_VC_GET_RSS_KEY_ERR);
 523			break;
 524		case VIRTCHNL2_OP_SET_RSS_KEY:
 525			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 526					   IDPF_VC_SET_RSS_KEY,
 527					   IDPF_VC_SET_RSS_KEY_ERR);
 528			break;
 529		case VIRTCHNL2_OP_SET_SRIOV_VFS:
 530			idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 531					   IDPF_VC_SET_SRIOV_VFS,
 532					   IDPF_VC_SET_SRIOV_VFS_ERR);
 533			break;
 534		case VIRTCHNL2_OP_ALLOC_VECTORS:
 535			idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 536					   IDPF_VC_ALLOC_VECTORS,
 537					   IDPF_VC_ALLOC_VECTORS_ERR);
 538			break;
 539		case VIRTCHNL2_OP_DEALLOC_VECTORS:
 540			idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 541					   IDPF_VC_DEALLOC_VECTORS,
 542					   IDPF_VC_DEALLOC_VECTORS_ERR);
 543			break;
 544		case VIRTCHNL2_OP_GET_PTYPE_INFO:
 545			idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 546					   IDPF_VC_GET_PTYPE_INFO,
 547					   IDPF_VC_GET_PTYPE_INFO_ERR);
 548			break;
 549		case VIRTCHNL2_OP_LOOPBACK:
 550			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 551					   IDPF_VC_LOOPBACK_STATE,
 552					   IDPF_VC_LOOPBACK_STATE_ERR);
 553			break;
 554		case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE:
 555			/* This message can only be sent asynchronously. As
 556			 * such we'll have lost the context in which it was
 557			 * called and thus can only really report if it looks
 558			 * like an error occurred. Don't bother setting ERR bit
 559			 * or waking chnl_wq since no work queue will be waiting
 560			 * to read the message.
 561			 */
 562			if (ctlq_msg.cookie.mbx.chnl_retval) {
 563				dev_err(&adapter->pdev->dev, "Failed to set promiscuous mode: %d\n",
 564					ctlq_msg.cookie.mbx.chnl_retval);
 565			}
 566			break;
 567		case VIRTCHNL2_OP_ADD_MAC_ADDR:
 568			vport_config = adapter->vport_config[vport->idx];
 569			if (test_and_clear_bit(IDPF_VPORT_ADD_MAC_REQ,
 570					       vport_config->flags)) {
 571				/* Message was sent asynchronously. We don't
 572				 * normally print errors here, instead
 573				 * prefer to handle errors in the function
 574				 * calling wait_for_event. However, if
 575				 * asynchronous, the context in which the
 576				 * message was sent is lost. We can't really do
 577				 * anything about at it this point, but we
 578				 * should at a minimum indicate that it looks
 579				 * like something went wrong. Also don't bother
 580				 * setting ERR bit or waking vchnl_wq since no
 581				 * one will be waiting to read the async
 582				 * message.
 583				 */
 584				if (ctlq_msg.cookie.mbx.chnl_retval)
 585					dev_err(&adapter->pdev->dev, "Failed to add MAC address: %d\n",
 586						ctlq_msg.cookie.mbx.chnl_retval);
 587				break;
 588			}
 589			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 590					   IDPF_VC_ADD_MAC_ADDR,
 591					   IDPF_VC_ADD_MAC_ADDR_ERR);
 592			break;
 593		case VIRTCHNL2_OP_DEL_MAC_ADDR:
 594			vport_config = adapter->vport_config[vport->idx];
 595			if (test_and_clear_bit(IDPF_VPORT_DEL_MAC_REQ,
 596					       vport_config->flags)) {
 597				/* Message was sent asynchronously like the
 598				 * VIRTCHNL2_OP_ADD_MAC_ADDR
 599				 */
 600				if (ctlq_msg.cookie.mbx.chnl_retval)
 601					dev_err(&adapter->pdev->dev, "Failed to delete MAC address: %d\n",
 602						ctlq_msg.cookie.mbx.chnl_retval);
 603				break;
 604			}
 605			idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 606					   IDPF_VC_DEL_MAC_ADDR,
 607					   IDPF_VC_DEL_MAC_ADDR_ERR);
 608			break;
 609		case VIRTCHNL2_OP_EVENT:
 610			idpf_recv_event_msg(vport, &ctlq_msg);
 611			break;
 612		default:
 613			dev_warn(&adapter->pdev->dev,
 614				 "Unhandled virtchnl response %d\n",
 615				 ctlq_msg.cookie.mbx.chnl_opcode);
 616			break;
 617		}
 618
 619post_buffs:
 620		if (ctlq_msg.data_len)
 621			dma_mem = ctlq_msg.ctx.indirect.payload;
 622		else
 623			num_q_msg = 0;
 624
 625		err = idpf_ctlq_post_rx_buffs(&adapter->hw, adapter->hw.arq,
 626					      &num_q_msg, &dma_mem);
 627		/* If post failed clear the only buffer we supplied */
 628		if (err && dma_mem)
 629			dma_free_coherent(&adapter->pdev->dev, dma_mem->size,
 630					  dma_mem->va, dma_mem->pa);
 631
 632		/* Applies only if we are looking for a specific opcode */
 633		if (work_done)
 634			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 635	}
 636
 
 
 
 
 
 
 
 
 
 
 637	return err;
 638}
 639
 640/**
 641 * __idpf_wait_for_event - wrapper function for wait on virtchannel response
 642 * @adapter: Driver private data structure
 643 * @vport: virtual port structure
 644 * @state: check on state upon timeout
 645 * @err_check: check if this specific error bit is set
 646 * @timeout: Max time to wait
 647 *
 648 * Checks if state is set upon expiry of timeout.  Returns 0 on success,
 649 * negative on failure.
 650 */
 651static int __idpf_wait_for_event(struct idpf_adapter *adapter,
 652				 struct idpf_vport *vport,
 653				 enum idpf_vport_vc_state state,
 654				 enum idpf_vport_vc_state err_check,
 655				 int timeout)
 656{
 657	int time_to_wait, num_waits;
 658	wait_queue_head_t *vchnl_wq;
 659	unsigned long *vc_state;
 660
 661	time_to_wait = ((timeout <= IDPF_MAX_WAIT) ? timeout : IDPF_MAX_WAIT);
 662	num_waits = ((timeout <= IDPF_MAX_WAIT) ? 1 : timeout / IDPF_MAX_WAIT);
 663
 664	if (vport) {
 665		vchnl_wq = &vport->vchnl_wq;
 666		vc_state = vport->vc_state;
 667	} else {
 668		vchnl_wq = &adapter->vchnl_wq;
 669		vc_state = adapter->vc_state;
 670	}
 671
 672	while (num_waits) {
 673		int event;
 
 
 
 
 
 
 
 
 
 
 
 
 674
 675		/* If we are here and a reset is detected do not wait but
 676		 * return. Reset timing is out of drivers control. So
 677		 * while we are cleaning resources as part of reset if the
 678		 * underlying HW mailbox is gone, wait on mailbox messages
 679		 * is not meaningful
 
 
 
 
 
 
 
 
 
 
 680		 */
 681		if (idpf_is_reset_detected(adapter))
 682			return 0;
 
 
 
 
 
 
 
 
 
 
 683
 684		event = wait_event_timeout(*vchnl_wq,
 685					   test_and_clear_bit(state, vc_state),
 686					   msecs_to_jiffies(time_to_wait));
 687		if (event) {
 688			if (test_and_clear_bit(err_check, vc_state)) {
 689				dev_err(&adapter->pdev->dev, "VC response error %s\n",
 690					idpf_vport_vc_state_str[err_check]);
 
 691
 692				return -EINVAL;
 693			}
 
 
 
 
 694
 695			return 0;
 696		}
 697		num_waits--;
 698	}
 699
 700	/* Timeout occurred */
 701	dev_err(&adapter->pdev->dev, "VC timeout, state = %s\n",
 702		idpf_vport_vc_state_str[state]);
 703
 704	return -ETIMEDOUT;
 
 
 
 
 
 
 
 
 
 705}
 706
 707/**
 708 * idpf_min_wait_for_event - wait for virtchannel response
 709 * @adapter: Driver private data structure
 710 * @vport: virtual port structure
 711 * @state: check on state upon timeout
 712 * @err_check: check if this specific error bit is set
 713 *
 714 * Returns 0 on success, negative on failure.
 
 715 */
 716static int idpf_min_wait_for_event(struct idpf_adapter *adapter,
 717				   struct idpf_vport *vport,
 718				   enum idpf_vport_vc_state state,
 719				   enum idpf_vport_vc_state err_check)
 720{
 721	return __idpf_wait_for_event(adapter, vport, state, err_check,
 722				     IDPF_WAIT_FOR_EVENT_TIMEO_MIN);
 723}
 
 724
 725/**
 726 * idpf_wait_for_event - wait for virtchannel response
 727 * @adapter: Driver private data structure
 728 * @vport: virtual port structure
 729 * @state: check on state upon timeout after 500ms
 730 * @err_check: check if this specific error bit is set
 731 *
 732 * Returns 0 on success, negative on failure.
 733 */
 734static int idpf_wait_for_event(struct idpf_adapter *adapter,
 735			       struct idpf_vport *vport,
 736			       enum idpf_vport_vc_state state,
 737			       enum idpf_vport_vc_state err_check)
 738{
 739	/* Increasing the timeout in __IDPF_INIT_SW flow to consider large
 740	 * number of VF's mailbox message responses. When a message is received
 741	 * on mailbox, this thread is woken up by the idpf_recv_mb_msg before
 742	 * the timeout expires. Only in the error case i.e. if no message is
 743	 * received on mailbox, we wait for the complete timeout which is
 744	 * less likely to happen.
 745	 */
 746	return __idpf_wait_for_event(adapter, vport, state, err_check,
 747				     IDPF_WAIT_FOR_EVENT_TIMEO);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 748}
 749
 750/**
 751 * idpf_wait_for_marker_event - wait for software marker response
 752 * @vport: virtual port data structure
 753 *
 754 * Returns 0 success, negative on failure.
 755 **/
 756static int idpf_wait_for_marker_event(struct idpf_vport *vport)
 757{
 758	int event;
 759	int i;
 760
 761	for (i = 0; i < vport->num_txq; i++)
 762		set_bit(__IDPF_Q_SW_MARKER, vport->txqs[i]->flags);
 763
 764	event = wait_event_timeout(vport->sw_marker_wq,
 765				   test_and_clear_bit(IDPF_VPORT_SW_MARKER,
 766						      vport->flags),
 767				   msecs_to_jiffies(500));
 768
 769	for (i = 0; i < vport->num_txq; i++)
 770		clear_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags);
 771
 772	if (event)
 773		return 0;
 774
 775	dev_warn(&vport->adapter->pdev->dev, "Failed to receive marker packets\n");
 776
 777	return -ETIMEDOUT;
 778}
 779
 780/**
 781 * idpf_send_ver_msg - send virtchnl version message
 782 * @adapter: Driver specific private structure
 783 *
 784 * Send virtchnl version message.  Returns 0 on success, negative on failure.
 785 */
 786static int idpf_send_ver_msg(struct idpf_adapter *adapter)
 787{
 
 788	struct virtchnl2_version_info vvi;
 
 
 
 789
 790	if (adapter->virt_ver_maj) {
 791		vvi.major = cpu_to_le32(adapter->virt_ver_maj);
 792		vvi.minor = cpu_to_le32(adapter->virt_ver_min);
 793	} else {
 794		vvi.major = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MAJOR);
 795		vvi.minor = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MINOR);
 796	}
 797
 798	return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_VERSION, sizeof(vvi),
 799				(u8 *)&vvi);
 800}
 801
 802/**
 803 * idpf_recv_ver_msg - Receive virtchnl version message
 804 * @adapter: Driver specific private structure
 805 *
 806 * Receive virtchnl version message. Returns 0 on success, -EAGAIN if we need
 807 * to send version message again, otherwise negative on failure.
 808 */
 809static int idpf_recv_ver_msg(struct idpf_adapter *adapter)
 810{
 811	struct virtchnl2_version_info vvi;
 812	u32 major, minor;
 813	int err;
 814
 815	err = idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_VERSION, &vvi,
 816			       sizeof(vvi));
 817	if (err)
 818		return err;
 819
 820	major = le32_to_cpu(vvi.major);
 821	minor = le32_to_cpu(vvi.minor);
 822
 823	if (major > IDPF_VIRTCHNL_VERSION_MAJOR) {
 824		dev_warn(&adapter->pdev->dev,
 825			 "Virtchnl major version (%d) greater than supported\n",
 826			 major);
 827
 828		return -EINVAL;
 829	}
 830
 831	if (major == IDPF_VIRTCHNL_VERSION_MAJOR &&
 832	    minor > IDPF_VIRTCHNL_VERSION_MINOR)
 833		dev_warn(&adapter->pdev->dev,
 834			 "Virtchnl minor version (%d) didn't match\n", minor);
 835
 836	/* If we have a mismatch, resend version to update receiver on what
 837	 * version we will use.
 838	 */
 839	if (!adapter->virt_ver_maj &&
 840	    major != IDPF_VIRTCHNL_VERSION_MAJOR &&
 841	    minor != IDPF_VIRTCHNL_VERSION_MINOR)
 842		err = -EAGAIN;
 843
 844	adapter->virt_ver_maj = major;
 845	adapter->virt_ver_min = minor;
 846
 847	return err;
 848}
 849
 850/**
 851 * idpf_send_get_caps_msg - Send virtchnl get capabilities message
 852 * @adapter: Driver specific private structure
 853 *
 854 * Send virtchl get capabilities message. Returns 0 on success, negative on
 855 * failure.
 856 */
 857static int idpf_send_get_caps_msg(struct idpf_adapter *adapter)
 858{
 859	struct virtchnl2_get_capabilities caps = { };
 
 
 860
 861	caps.csum_caps =
 862		cpu_to_le32(VIRTCHNL2_CAP_TX_CSUM_L3_IPV4	|
 863			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_TCP	|
 864			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_UDP	|
 865			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_SCTP	|
 866			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_TCP	|
 867			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_UDP	|
 868			    VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_SCTP	|
 869			    VIRTCHNL2_CAP_RX_CSUM_L3_IPV4	|
 870			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP	|
 871			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP	|
 872			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_SCTP	|
 873			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP	|
 874			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP	|
 875			    VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_SCTP	|
 876			    VIRTCHNL2_CAP_TX_CSUM_L3_SINGLE_TUNNEL |
 877			    VIRTCHNL2_CAP_RX_CSUM_L3_SINGLE_TUNNEL |
 878			    VIRTCHNL2_CAP_TX_CSUM_L4_SINGLE_TUNNEL |
 879			    VIRTCHNL2_CAP_RX_CSUM_L4_SINGLE_TUNNEL |
 880			    VIRTCHNL2_CAP_RX_CSUM_GENERIC);
 881
 882	caps.seg_caps =
 883		cpu_to_le32(VIRTCHNL2_CAP_SEG_IPV4_TCP		|
 884			    VIRTCHNL2_CAP_SEG_IPV4_UDP		|
 885			    VIRTCHNL2_CAP_SEG_IPV4_SCTP		|
 886			    VIRTCHNL2_CAP_SEG_IPV6_TCP		|
 887			    VIRTCHNL2_CAP_SEG_IPV6_UDP		|
 888			    VIRTCHNL2_CAP_SEG_IPV6_SCTP		|
 889			    VIRTCHNL2_CAP_SEG_TX_SINGLE_TUNNEL);
 890
 891	caps.rss_caps =
 892		cpu_to_le64(VIRTCHNL2_CAP_RSS_IPV4_TCP		|
 893			    VIRTCHNL2_CAP_RSS_IPV4_UDP		|
 894			    VIRTCHNL2_CAP_RSS_IPV4_SCTP		|
 895			    VIRTCHNL2_CAP_RSS_IPV4_OTHER	|
 896			    VIRTCHNL2_CAP_RSS_IPV6_TCP		|
 897			    VIRTCHNL2_CAP_RSS_IPV6_UDP		|
 898			    VIRTCHNL2_CAP_RSS_IPV6_SCTP		|
 899			    VIRTCHNL2_CAP_RSS_IPV6_OTHER);
 900
 901	caps.hsplit_caps =
 902		cpu_to_le32(VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V4	|
 903			    VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V6);
 904
 905	caps.rsc_caps =
 906		cpu_to_le32(VIRTCHNL2_CAP_RSC_IPV4_TCP		|
 907			    VIRTCHNL2_CAP_RSC_IPV6_TCP);
 908
 909	caps.other_caps =
 910		cpu_to_le64(VIRTCHNL2_CAP_SRIOV			|
 911			    VIRTCHNL2_CAP_MACFILTER		|
 912			    VIRTCHNL2_CAP_SPLITQ_QSCHED		|
 913			    VIRTCHNL2_CAP_PROMISC		|
 914			    VIRTCHNL2_CAP_LOOPBACK);
 915
 916	return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, sizeof(caps),
 917				(u8 *)&caps);
 918}
 
 
 
 
 
 
 
 
 
 919
 920/**
 921 * idpf_recv_get_caps_msg - Receive virtchnl get capabilities message
 922 * @adapter: Driver specific private structure
 923 *
 924 * Receive virtchnl get capabilities message. Returns 0 on success, negative on
 925 * failure.
 926 */
 927static int idpf_recv_get_caps_msg(struct idpf_adapter *adapter)
 928{
 929	return idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, &adapter->caps,
 930				sizeof(struct virtchnl2_get_capabilities));
 931}
 932
 933/**
 934 * idpf_vport_alloc_max_qs - Allocate max queues for a vport
 935 * @adapter: Driver specific private structure
 936 * @max_q: vport max queue structure
 937 */
 938int idpf_vport_alloc_max_qs(struct idpf_adapter *adapter,
 939			    struct idpf_vport_max_q *max_q)
 940{
 941	struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues;
 942	struct virtchnl2_get_capabilities *caps = &adapter->caps;
 943	u16 default_vports = idpf_get_default_vports(adapter);
 944	int max_rx_q, max_tx_q;
 945
 946	mutex_lock(&adapter->queue_lock);
 947
 948	max_rx_q = le16_to_cpu(caps->max_rx_q) / default_vports;
 949	max_tx_q = le16_to_cpu(caps->max_tx_q) / default_vports;
 950	if (adapter->num_alloc_vports < default_vports) {
 951		max_q->max_rxq = min_t(u16, max_rx_q, IDPF_MAX_Q);
 952		max_q->max_txq = min_t(u16, max_tx_q, IDPF_MAX_Q);
 953	} else {
 954		max_q->max_rxq = IDPF_MIN_Q;
 955		max_q->max_txq = IDPF_MIN_Q;
 956	}
 957	max_q->max_bufq = max_q->max_rxq * IDPF_MAX_BUFQS_PER_RXQ_GRP;
 958	max_q->max_complq = max_q->max_txq;
 959
 960	if (avail_queues->avail_rxq < max_q->max_rxq ||
 961	    avail_queues->avail_txq < max_q->max_txq ||
 962	    avail_queues->avail_bufq < max_q->max_bufq ||
 963	    avail_queues->avail_complq < max_q->max_complq) {
 964		mutex_unlock(&adapter->queue_lock);
 965
 966		return -EINVAL;
 967	}
 968
 969	avail_queues->avail_rxq -= max_q->max_rxq;
 970	avail_queues->avail_txq -= max_q->max_txq;
 971	avail_queues->avail_bufq -= max_q->max_bufq;
 972	avail_queues->avail_complq -= max_q->max_complq;
 973
 974	mutex_unlock(&adapter->queue_lock);
 975
 976	return 0;
 977}
 978
 979/**
 980 * idpf_vport_dealloc_max_qs - Deallocate max queues of a vport
 981 * @adapter: Driver specific private structure
 982 * @max_q: vport max queue structure
 983 */
 984void idpf_vport_dealloc_max_qs(struct idpf_adapter *adapter,
 985			       struct idpf_vport_max_q *max_q)
 986{
 987	struct idpf_avail_queue_info *avail_queues;
 988
 989	mutex_lock(&adapter->queue_lock);
 990	avail_queues = &adapter->avail_queues;
 991
 992	avail_queues->avail_rxq += max_q->max_rxq;
 993	avail_queues->avail_txq += max_q->max_txq;
 994	avail_queues->avail_bufq += max_q->max_bufq;
 995	avail_queues->avail_complq += max_q->max_complq;
 996
 997	mutex_unlock(&adapter->queue_lock);
 998}
 999
1000/**
1001 * idpf_init_avail_queues - Initialize available queues on the device
1002 * @adapter: Driver specific private structure
1003 */
1004static void idpf_init_avail_queues(struct idpf_adapter *adapter)
1005{
1006	struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues;
1007	struct virtchnl2_get_capabilities *caps = &adapter->caps;
1008
1009	avail_queues->avail_rxq = le16_to_cpu(caps->max_rx_q);
1010	avail_queues->avail_txq = le16_to_cpu(caps->max_tx_q);
1011	avail_queues->avail_bufq = le16_to_cpu(caps->max_rx_bufq);
1012	avail_queues->avail_complq = le16_to_cpu(caps->max_tx_complq);
1013}
1014
1015/**
1016 * idpf_get_reg_intr_vecs - Get vector queue register offset
1017 * @vport: virtual port structure
1018 * @reg_vals: Register offsets to store in
1019 *
1020 * Returns number of registers that got populated
1021 */
1022int idpf_get_reg_intr_vecs(struct idpf_vport *vport,
1023			   struct idpf_vec_regs *reg_vals)
1024{
1025	struct virtchnl2_vector_chunks *chunks;
1026	struct idpf_vec_regs reg_val;
1027	u16 num_vchunks, num_vec;
1028	int num_regs = 0, i, j;
1029
1030	chunks = &vport->adapter->req_vec_chunks->vchunks;
1031	num_vchunks = le16_to_cpu(chunks->num_vchunks);
1032
1033	for (j = 0; j < num_vchunks; j++) {
1034		struct virtchnl2_vector_chunk *chunk;
1035		u32 dynctl_reg_spacing;
1036		u32 itrn_reg_spacing;
1037
1038		chunk = &chunks->vchunks[j];
1039		num_vec = le16_to_cpu(chunk->num_vectors);
1040		reg_val.dyn_ctl_reg = le32_to_cpu(chunk->dynctl_reg_start);
1041		reg_val.itrn_reg = le32_to_cpu(chunk->itrn_reg_start);
1042		reg_val.itrn_index_spacing = le32_to_cpu(chunk->itrn_index_spacing);
1043
1044		dynctl_reg_spacing = le32_to_cpu(chunk->dynctl_reg_spacing);
1045		itrn_reg_spacing = le32_to_cpu(chunk->itrn_reg_spacing);
1046
1047		for (i = 0; i < num_vec; i++) {
1048			reg_vals[num_regs].dyn_ctl_reg = reg_val.dyn_ctl_reg;
1049			reg_vals[num_regs].itrn_reg = reg_val.itrn_reg;
1050			reg_vals[num_regs].itrn_index_spacing =
1051						reg_val.itrn_index_spacing;
1052
1053			reg_val.dyn_ctl_reg += dynctl_reg_spacing;
1054			reg_val.itrn_reg += itrn_reg_spacing;
1055			num_regs++;
1056		}
1057	}
1058
1059	return num_regs;
1060}
1061
1062/**
1063 * idpf_vport_get_q_reg - Get the queue registers for the vport
1064 * @reg_vals: register values needing to be set
1065 * @num_regs: amount we expect to fill
1066 * @q_type: queue model
1067 * @chunks: queue regs received over mailbox
1068 *
1069 * This function parses the queue register offsets from the queue register
1070 * chunk information, with a specific queue type and stores it into the array
1071 * passed as an argument. It returns the actual number of queue registers that
1072 * are filled.
1073 */
1074static int idpf_vport_get_q_reg(u32 *reg_vals, int num_regs, u32 q_type,
1075				struct virtchnl2_queue_reg_chunks *chunks)
1076{
1077	u16 num_chunks = le16_to_cpu(chunks->num_chunks);
1078	int reg_filled = 0, i;
1079	u32 reg_val;
1080
1081	while (num_chunks--) {
1082		struct virtchnl2_queue_reg_chunk *chunk;
1083		u16 num_q;
1084
1085		chunk = &chunks->chunks[num_chunks];
1086		if (le32_to_cpu(chunk->type) != q_type)
1087			continue;
1088
1089		num_q = le32_to_cpu(chunk->num_queues);
1090		reg_val = le64_to_cpu(chunk->qtail_reg_start);
1091		for (i = 0; i < num_q && reg_filled < num_regs ; i++) {
1092			reg_vals[reg_filled++] = reg_val;
1093			reg_val += le32_to_cpu(chunk->qtail_reg_spacing);
1094		}
1095	}
1096
1097	return reg_filled;
1098}
1099
1100/**
1101 * __idpf_queue_reg_init - initialize queue registers
1102 * @vport: virtual port structure
1103 * @reg_vals: registers we are initializing
1104 * @num_regs: how many registers there are in total
1105 * @q_type: queue model
1106 *
1107 * Return number of queues that are initialized
1108 */
1109static int __idpf_queue_reg_init(struct idpf_vport *vport, u32 *reg_vals,
1110				 int num_regs, u32 q_type)
1111{
1112	struct idpf_adapter *adapter = vport->adapter;
1113	struct idpf_queue *q;
1114	int i, j, k = 0;
1115
1116	switch (q_type) {
1117	case VIRTCHNL2_QUEUE_TYPE_TX:
1118		for (i = 0; i < vport->num_txq_grp; i++) {
1119			struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1120
1121			for (j = 0; j < tx_qgrp->num_txq && k < num_regs; j++, k++)
1122				tx_qgrp->txqs[j]->tail =
1123					idpf_get_reg_addr(adapter, reg_vals[k]);
1124		}
1125		break;
1126	case VIRTCHNL2_QUEUE_TYPE_RX:
1127		for (i = 0; i < vport->num_rxq_grp; i++) {
1128			struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1129			u16 num_rxq = rx_qgrp->singleq.num_rxq;
1130
1131			for (j = 0; j < num_rxq && k < num_regs; j++, k++) {
1132				q = rx_qgrp->singleq.rxqs[j];
1133				q->tail = idpf_get_reg_addr(adapter,
1134							    reg_vals[k]);
1135			}
1136		}
1137		break;
1138	case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER:
1139		for (i = 0; i < vport->num_rxq_grp; i++) {
1140			struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1141			u8 num_bufqs = vport->num_bufqs_per_qgrp;
1142
1143			for (j = 0; j < num_bufqs && k < num_regs; j++, k++) {
1144				q = &rx_qgrp->splitq.bufq_sets[j].bufq;
1145				q->tail = idpf_get_reg_addr(adapter,
1146							    reg_vals[k]);
1147			}
1148		}
1149		break;
1150	default:
1151		break;
1152	}
1153
1154	return k;
1155}
1156
1157/**
1158 * idpf_queue_reg_init - initialize queue registers
1159 * @vport: virtual port structure
1160 *
1161 * Return 0 on success, negative on failure
1162 */
1163int idpf_queue_reg_init(struct idpf_vport *vport)
1164{
1165	struct virtchnl2_create_vport *vport_params;
1166	struct virtchnl2_queue_reg_chunks *chunks;
1167	struct idpf_vport_config *vport_config;
1168	u16 vport_idx = vport->idx;
1169	int num_regs, ret = 0;
1170	u32 *reg_vals;
1171
1172	/* We may never deal with more than 256 same type of queues */
1173	reg_vals = kzalloc(sizeof(void *) * IDPF_LARGE_MAX_Q, GFP_KERNEL);
1174	if (!reg_vals)
1175		return -ENOMEM;
1176
1177	vport_config = vport->adapter->vport_config[vport_idx];
1178	if (vport_config->req_qs_chunks) {
1179		struct virtchnl2_add_queues *vc_aq =
1180		  (struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
1181		chunks = &vc_aq->chunks;
1182	} else {
1183		vport_params = vport->adapter->vport_params_recvd[vport_idx];
1184		chunks = &vport_params->chunks;
1185	}
1186
1187	/* Initialize Tx queue tail register address */
1188	num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1189					VIRTCHNL2_QUEUE_TYPE_TX,
1190					chunks);
1191	if (num_regs < vport->num_txq) {
1192		ret = -EINVAL;
1193		goto free_reg_vals;
1194	}
1195
1196	num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1197					 VIRTCHNL2_QUEUE_TYPE_TX);
1198	if (num_regs < vport->num_txq) {
1199		ret = -EINVAL;
1200		goto free_reg_vals;
1201	}
1202
1203	/* Initialize Rx/buffer queue tail register address based on Rx queue
1204	 * model
1205	 */
1206	if (idpf_is_queue_model_split(vport->rxq_model)) {
1207		num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1208						VIRTCHNL2_QUEUE_TYPE_RX_BUFFER,
1209						chunks);
1210		if (num_regs < vport->num_bufq) {
1211			ret = -EINVAL;
1212			goto free_reg_vals;
1213		}
1214
1215		num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1216						 VIRTCHNL2_QUEUE_TYPE_RX_BUFFER);
1217		if (num_regs < vport->num_bufq) {
1218			ret = -EINVAL;
1219			goto free_reg_vals;
1220		}
1221	} else {
1222		num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1223						VIRTCHNL2_QUEUE_TYPE_RX,
1224						chunks);
1225		if (num_regs < vport->num_rxq) {
1226			ret = -EINVAL;
1227			goto free_reg_vals;
1228		}
1229
1230		num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1231						 VIRTCHNL2_QUEUE_TYPE_RX);
1232		if (num_regs < vport->num_rxq) {
1233			ret = -EINVAL;
1234			goto free_reg_vals;
1235		}
1236	}
1237
1238free_reg_vals:
1239	kfree(reg_vals);
1240
1241	return ret;
1242}
1243
1244/**
1245 * idpf_send_create_vport_msg - Send virtchnl create vport message
1246 * @adapter: Driver specific private structure
1247 * @max_q: vport max queue info
1248 *
1249 * send virtchnl creae vport message
1250 *
1251 * Returns 0 on success, negative on failure
1252 */
1253int idpf_send_create_vport_msg(struct idpf_adapter *adapter,
1254			       struct idpf_vport_max_q *max_q)
1255{
1256	struct virtchnl2_create_vport *vport_msg;
 
1257	u16 idx = adapter->next_vport;
1258	int err, buf_size;
 
1259
1260	buf_size = sizeof(struct virtchnl2_create_vport);
1261	if (!adapter->vport_params_reqd[idx]) {
1262		adapter->vport_params_reqd[idx] = kzalloc(buf_size,
1263							  GFP_KERNEL);
1264		if (!adapter->vport_params_reqd[idx])
1265			return -ENOMEM;
1266	}
1267
1268	vport_msg = adapter->vport_params_reqd[idx];
1269	vport_msg->vport_type = cpu_to_le16(VIRTCHNL2_VPORT_TYPE_DEFAULT);
1270	vport_msg->vport_index = cpu_to_le16(idx);
1271
1272	if (adapter->req_tx_splitq)
1273		vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT);
1274	else
1275		vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE);
1276
1277	if (adapter->req_rx_splitq)
1278		vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT);
1279	else
1280		vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE);
1281
1282	err = idpf_vport_calc_total_qs(adapter, idx, vport_msg, max_q);
1283	if (err) {
1284		dev_err(&adapter->pdev->dev, "Enough queues are not available");
1285
1286		return err;
1287	}
1288
1289	mutex_lock(&adapter->vc_buf_lock);
1290
1291	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CREATE_VPORT, buf_size,
1292			       (u8 *)vport_msg);
1293	if (err)
1294		goto rel_lock;
1295
1296	err = idpf_wait_for_event(adapter, NULL, IDPF_VC_CREATE_VPORT,
1297				  IDPF_VC_CREATE_VPORT_ERR);
1298	if (err) {
1299		dev_err(&adapter->pdev->dev, "Failed to receive create vport message");
1300
1301		goto rel_lock;
1302	}
1303
1304	if (!adapter->vport_params_recvd[idx]) {
1305		adapter->vport_params_recvd[idx] = kzalloc(IDPF_CTLQ_MAX_BUF_LEN,
1306							   GFP_KERNEL);
1307		if (!adapter->vport_params_recvd[idx]) {
1308			err = -ENOMEM;
1309			goto rel_lock;
1310		}
1311	}
1312
1313	vport_msg = adapter->vport_params_recvd[idx];
1314	memcpy(vport_msg, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN);
 
 
 
 
 
 
 
 
 
 
 
 
 
1315
1316rel_lock:
1317	mutex_unlock(&adapter->vc_buf_lock);
 
 
 
 
 
1318
1319	return err;
1320}
1321
1322/**
1323 * idpf_check_supported_desc_ids - Verify we have required descriptor support
1324 * @vport: virtual port structure
1325 *
1326 * Return 0 on success, error on failure
1327 */
1328int idpf_check_supported_desc_ids(struct idpf_vport *vport)
1329{
1330	struct idpf_adapter *adapter = vport->adapter;
1331	struct virtchnl2_create_vport *vport_msg;
1332	u64 rx_desc_ids, tx_desc_ids;
1333
1334	vport_msg = adapter->vport_params_recvd[vport->idx];
1335
1336	rx_desc_ids = le64_to_cpu(vport_msg->rx_desc_ids);
1337	tx_desc_ids = le64_to_cpu(vport_msg->tx_desc_ids);
1338
1339	if (vport->rxq_model == VIRTCHNL2_QUEUE_MODEL_SPLIT) {
1340		if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M)) {
1341			dev_info(&adapter->pdev->dev, "Minimum RX descriptor support not provided, using the default\n");
1342			vport_msg->rx_desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M);
1343		}
1344	} else {
1345		if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SQ_NIC_M))
1346			vport->base_rxd = true;
1347	}
1348
1349	if (vport->txq_model != VIRTCHNL2_QUEUE_MODEL_SPLIT)
1350		return 0;
1351
1352	if ((tx_desc_ids & MIN_SUPPORT_TXDID) != MIN_SUPPORT_TXDID) {
1353		dev_info(&adapter->pdev->dev, "Minimum TX descriptor support not provided, using the default\n");
1354		vport_msg->tx_desc_ids = cpu_to_le64(MIN_SUPPORT_TXDID);
1355	}
1356
1357	return 0;
1358}
1359
1360/**
1361 * idpf_send_destroy_vport_msg - Send virtchnl destroy vport message
1362 * @vport: virtual port data structure
1363 *
1364 * Send virtchnl destroy vport message.  Returns 0 on success, negative on
1365 * failure.
1366 */
1367int idpf_send_destroy_vport_msg(struct idpf_vport *vport)
1368{
1369	struct idpf_adapter *adapter = vport->adapter;
1370	struct virtchnl2_vport v_id;
1371	int err;
1372
1373	v_id.vport_id = cpu_to_le32(vport->vport_id);
1374
1375	mutex_lock(&vport->vc_buf_lock);
1376
1377	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DESTROY_VPORT,
1378			       sizeof(v_id), (u8 *)&v_id);
1379	if (err)
1380		goto rel_lock;
1381
1382	err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DESTROY_VPORT,
1383				      IDPF_VC_DESTROY_VPORT_ERR);
1384
1385rel_lock:
1386	mutex_unlock(&vport->vc_buf_lock);
1387
1388	return err;
1389}
1390
1391/**
1392 * idpf_send_enable_vport_msg - Send virtchnl enable vport message
1393 * @vport: virtual port data structure
1394 *
1395 * Send enable vport virtchnl message.  Returns 0 on success, negative on
1396 * failure.
1397 */
1398int idpf_send_enable_vport_msg(struct idpf_vport *vport)
1399{
1400	struct idpf_adapter *adapter = vport->adapter;
1401	struct virtchnl2_vport v_id;
1402	int err;
1403
1404	v_id.vport_id = cpu_to_le32(vport->vport_id);
1405
1406	mutex_lock(&vport->vc_buf_lock);
1407
1408	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ENABLE_VPORT,
1409			       sizeof(v_id), (u8 *)&v_id);
1410	if (err)
1411		goto rel_lock;
1412
1413	err = idpf_wait_for_event(adapter, vport, IDPF_VC_ENA_VPORT,
1414				  IDPF_VC_ENA_VPORT_ERR);
1415
1416rel_lock:
1417	mutex_unlock(&vport->vc_buf_lock);
1418
1419	return err;
1420}
1421
1422/**
1423 * idpf_send_disable_vport_msg - Send virtchnl disable vport message
1424 * @vport: virtual port data structure
1425 *
1426 * Send disable vport virtchnl message.  Returns 0 on success, negative on
1427 * failure.
1428 */
1429int idpf_send_disable_vport_msg(struct idpf_vport *vport)
1430{
1431	struct idpf_adapter *adapter = vport->adapter;
1432	struct virtchnl2_vport v_id;
1433	int err;
1434
1435	v_id.vport_id = cpu_to_le32(vport->vport_id);
1436
1437	mutex_lock(&vport->vc_buf_lock);
 
 
 
 
1438
1439	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DISABLE_VPORT,
1440			       sizeof(v_id), (u8 *)&v_id);
1441	if (err)
1442		goto rel_lock;
1443
1444	err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DIS_VPORT,
1445				      IDPF_VC_DIS_VPORT_ERR);
1446
1447rel_lock:
1448	mutex_unlock(&vport->vc_buf_lock);
1449
1450	return err;
1451}
1452
1453/**
1454 * idpf_send_config_tx_queues_msg - Send virtchnl config tx queues message
1455 * @vport: virtual port data structure
1456 *
1457 * Send config tx queues virtchnl message. Returns 0 on success, negative on
1458 * failure.
1459 */
1460static int idpf_send_config_tx_queues_msg(struct idpf_vport *vport)
1461{
1462	struct virtchnl2_config_tx_queues *ctq;
 
 
1463	u32 config_sz, chunk_sz, buf_sz;
1464	int totqs, num_msgs, num_chunks;
1465	struct virtchnl2_txq_info *qi;
1466	int err = 0, i, k = 0;
1467
1468	totqs = vport->num_txq + vport->num_complq;
1469	qi = kcalloc(totqs, sizeof(struct virtchnl2_txq_info), GFP_KERNEL);
1470	if (!qi)
1471		return -ENOMEM;
1472
1473	/* Populate the queue info buffer with all queue context info */
1474	for (i = 0; i < vport->num_txq_grp; i++) {
1475		struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1476		int j, sched_mode;
1477
1478		for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1479			qi[k].queue_id =
1480				cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1481			qi[k].model =
1482				cpu_to_le16(vport->txq_model);
1483			qi[k].type =
1484				cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1485			qi[k].ring_len =
1486				cpu_to_le16(tx_qgrp->txqs[j]->desc_count);
1487			qi[k].dma_ring_addr =
1488				cpu_to_le64(tx_qgrp->txqs[j]->dma);
1489			if (idpf_is_queue_model_split(vport->txq_model)) {
1490				struct idpf_queue *q = tx_qgrp->txqs[j];
1491
1492				qi[k].tx_compl_queue_id =
1493					cpu_to_le16(tx_qgrp->complq->q_id);
1494				qi[k].relative_queue_id = cpu_to_le16(j);
1495
1496				if (test_bit(__IDPF_Q_FLOW_SCH_EN, q->flags))
1497					qi[k].sched_mode =
1498					cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_FLOW);
1499				else
1500					qi[k].sched_mode =
1501					cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE);
1502			} else {
1503				qi[k].sched_mode =
1504					cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE);
1505			}
1506		}
1507
1508		if (!idpf_is_queue_model_split(vport->txq_model))
1509			continue;
1510
1511		qi[k].queue_id = cpu_to_le32(tx_qgrp->complq->q_id);
1512		qi[k].model = cpu_to_le16(vport->txq_model);
1513		qi[k].type = cpu_to_le32(tx_qgrp->complq->q_type);
1514		qi[k].ring_len = cpu_to_le16(tx_qgrp->complq->desc_count);
1515		qi[k].dma_ring_addr = cpu_to_le64(tx_qgrp->complq->dma);
1516
1517		if (test_bit(__IDPF_Q_FLOW_SCH_EN, tx_qgrp->complq->flags))
1518			sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_FLOW;
1519		else
1520			sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_QUEUE;
1521		qi[k].sched_mode = cpu_to_le16(sched_mode);
1522
1523		k++;
1524	}
1525
1526	/* Make sure accounting agrees */
1527	if (k != totqs) {
1528		err = -EINVAL;
1529		goto error;
1530	}
1531
1532	/* Chunk up the queue contexts into multiple messages to avoid
1533	 * sending a control queue message buffer that is too large
1534	 */
1535	config_sz = sizeof(struct virtchnl2_config_tx_queues);
1536	chunk_sz = sizeof(struct virtchnl2_txq_info);
1537
1538	num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1539			   totqs);
1540	num_msgs = DIV_ROUND_UP(totqs, num_chunks);
1541
1542	buf_sz = struct_size(ctq, qinfo, num_chunks);
1543	ctq = kzalloc(buf_sz, GFP_KERNEL);
1544	if (!ctq) {
1545		err = -ENOMEM;
1546		goto error;
1547	}
1548
1549	mutex_lock(&vport->vc_buf_lock);
 
1550
1551	for (i = 0, k = 0; i < num_msgs; i++) {
1552		memset(ctq, 0, buf_sz);
1553		ctq->vport_id = cpu_to_le32(vport->vport_id);
1554		ctq->num_qinfo = cpu_to_le16(num_chunks);
1555		memcpy(ctq->qinfo, &qi[k], chunk_sz * num_chunks);
1556
1557		err = idpf_send_mb_msg(vport->adapter,
1558				       VIRTCHNL2_OP_CONFIG_TX_QUEUES,
1559				       buf_sz, (u8 *)ctq);
1560		if (err)
1561			goto mbx_error;
1562
1563		err = idpf_wait_for_event(vport->adapter, vport,
1564					  IDPF_VC_CONFIG_TXQ,
1565					  IDPF_VC_CONFIG_TXQ_ERR);
1566		if (err)
1567			goto mbx_error;
1568
1569		k += num_chunks;
1570		totqs -= num_chunks;
1571		num_chunks = min(num_chunks, totqs);
1572		/* Recalculate buffer size */
1573		buf_sz = struct_size(ctq, qinfo, num_chunks);
1574	}
1575
1576mbx_error:
1577	mutex_unlock(&vport->vc_buf_lock);
1578	kfree(ctq);
1579error:
1580	kfree(qi);
1581
1582	return err;
1583}
1584
1585/**
1586 * idpf_send_config_rx_queues_msg - Send virtchnl config rx queues message
1587 * @vport: virtual port data structure
1588 *
1589 * Send config rx queues virtchnl message.  Returns 0 on success, negative on
1590 * failure.
1591 */
1592static int idpf_send_config_rx_queues_msg(struct idpf_vport *vport)
1593{
1594	struct virtchnl2_config_rx_queues *crq;
 
 
1595	u32 config_sz, chunk_sz, buf_sz;
1596	int totqs, num_msgs, num_chunks;
1597	struct virtchnl2_rxq_info *qi;
1598	int err = 0, i, k = 0;
1599
1600	totqs = vport->num_rxq + vport->num_bufq;
1601	qi = kcalloc(totqs, sizeof(struct virtchnl2_rxq_info), GFP_KERNEL);
1602	if (!qi)
1603		return -ENOMEM;
1604
1605	/* Populate the queue info buffer with all queue context info */
1606	for (i = 0; i < vport->num_rxq_grp; i++) {
1607		struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1608		u16 num_rxq;
1609		int j;
1610
1611		if (!idpf_is_queue_model_split(vport->rxq_model))
1612			goto setup_rxqs;
1613
1614		for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) {
1615			struct idpf_queue *bufq =
1616				&rx_qgrp->splitq.bufq_sets[j].bufq;
1617
1618			qi[k].queue_id = cpu_to_le32(bufq->q_id);
1619			qi[k].model = cpu_to_le16(vport->rxq_model);
1620			qi[k].type = cpu_to_le32(bufq->q_type);
1621			qi[k].desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M);
1622			qi[k].ring_len = cpu_to_le16(bufq->desc_count);
1623			qi[k].dma_ring_addr = cpu_to_le64(bufq->dma);
1624			qi[k].data_buffer_size = cpu_to_le32(bufq->rx_buf_size);
1625			qi[k].buffer_notif_stride = bufq->rx_buf_stride;
1626			qi[k].rx_buffer_low_watermark =
1627				cpu_to_le16(bufq->rx_buffer_low_watermark);
1628			if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW))
1629				qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC);
1630		}
1631
1632setup_rxqs:
1633		if (idpf_is_queue_model_split(vport->rxq_model))
1634			num_rxq = rx_qgrp->splitq.num_rxq_sets;
1635		else
1636			num_rxq = rx_qgrp->singleq.num_rxq;
1637
1638		for (j = 0; j < num_rxq; j++, k++) {
1639			struct idpf_queue *rxq;
1640
1641			if (!idpf_is_queue_model_split(vport->rxq_model)) {
1642				rxq = rx_qgrp->singleq.rxqs[j];
1643				goto common_qi_fields;
1644			}
1645			rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq;
1646			qi[k].rx_bufq1_id =
1647			  cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[0].bufq.q_id);
1648			if (vport->num_bufqs_per_qgrp > IDPF_SINGLE_BUFQ_PER_RXQ_GRP) {
1649				qi[k].bufq2_ena = IDPF_BUFQ2_ENA;
1650				qi[k].rx_bufq2_id =
1651				  cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[1].bufq.q_id);
1652			}
1653			qi[k].rx_buffer_low_watermark =
1654				cpu_to_le16(rxq->rx_buffer_low_watermark);
1655			if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW))
1656				qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC);
1657
1658common_qi_fields:
1659			if (rxq->rx_hsplit_en) {
1660				qi[k].qflags |=
1661					cpu_to_le16(VIRTCHNL2_RXQ_HDR_SPLIT);
1662				qi[k].hdr_buffer_size =
1663					cpu_to_le16(rxq->rx_hbuf_size);
1664			}
1665			qi[k].queue_id = cpu_to_le32(rxq->q_id);
1666			qi[k].model = cpu_to_le16(vport->rxq_model);
1667			qi[k].type = cpu_to_le32(rxq->q_type);
1668			qi[k].ring_len = cpu_to_le16(rxq->desc_count);
1669			qi[k].dma_ring_addr = cpu_to_le64(rxq->dma);
1670			qi[k].max_pkt_size = cpu_to_le32(rxq->rx_max_pkt_size);
1671			qi[k].data_buffer_size = cpu_to_le32(rxq->rx_buf_size);
1672			qi[k].qflags |=
1673				cpu_to_le16(VIRTCHNL2_RX_DESC_SIZE_32BYTE);
1674			qi[k].desc_ids = cpu_to_le64(rxq->rxdids);
1675		}
1676	}
1677
1678	/* Make sure accounting agrees */
1679	if (k != totqs) {
1680		err = -EINVAL;
1681		goto error;
1682	}
1683
1684	/* Chunk up the queue contexts into multiple messages to avoid
1685	 * sending a control queue message buffer that is too large
1686	 */
1687	config_sz = sizeof(struct virtchnl2_config_rx_queues);
1688	chunk_sz = sizeof(struct virtchnl2_rxq_info);
1689
1690	num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1691			   totqs);
1692	num_msgs = DIV_ROUND_UP(totqs, num_chunks);
1693
1694	buf_sz = struct_size(crq, qinfo, num_chunks);
1695	crq = kzalloc(buf_sz, GFP_KERNEL);
1696	if (!crq) {
1697		err = -ENOMEM;
1698		goto error;
1699	}
1700
1701	mutex_lock(&vport->vc_buf_lock);
 
1702
1703	for (i = 0, k = 0; i < num_msgs; i++) {
1704		memset(crq, 0, buf_sz);
1705		crq->vport_id = cpu_to_le32(vport->vport_id);
1706		crq->num_qinfo = cpu_to_le16(num_chunks);
1707		memcpy(crq->qinfo, &qi[k], chunk_sz * num_chunks);
1708
1709		err = idpf_send_mb_msg(vport->adapter,
1710				       VIRTCHNL2_OP_CONFIG_RX_QUEUES,
1711				       buf_sz, (u8 *)crq);
1712		if (err)
1713			goto mbx_error;
1714
1715		err = idpf_wait_for_event(vport->adapter, vport,
1716					  IDPF_VC_CONFIG_RXQ,
1717					  IDPF_VC_CONFIG_RXQ_ERR);
1718		if (err)
1719			goto mbx_error;
1720
1721		k += num_chunks;
1722		totqs -= num_chunks;
1723		num_chunks = min(num_chunks, totqs);
1724		/* Recalculate buffer size */
1725		buf_sz = struct_size(crq, qinfo, num_chunks);
1726	}
1727
1728mbx_error:
1729	mutex_unlock(&vport->vc_buf_lock);
1730	kfree(crq);
1731error:
1732	kfree(qi);
1733
1734	return err;
1735}
1736
1737/**
1738 * idpf_send_ena_dis_queues_msg - Send virtchnl enable or disable
1739 * queues message
1740 * @vport: virtual port data structure
1741 * @vc_op: virtchnl op code to send
1742 *
1743 * Send enable or disable queues virtchnl message. Returns 0 on success,
1744 * negative on failure.
1745 */
1746static int idpf_send_ena_dis_queues_msg(struct idpf_vport *vport, u32 vc_op)
1747{
 
 
1748	u32 num_msgs, num_chunks, num_txq, num_rxq, num_q;
1749	struct idpf_adapter *adapter = vport->adapter;
1750	struct virtchnl2_del_ena_dis_queues *eq;
1751	struct virtchnl2_queue_chunks *qcs;
1752	struct virtchnl2_queue_chunk *qc;
1753	u32 config_sz, chunk_sz, buf_sz;
1754	int i, j, k = 0, err = 0;
1755
1756	/* validate virtchnl op */
1757	switch (vc_op) {
1758	case VIRTCHNL2_OP_ENABLE_QUEUES:
1759	case VIRTCHNL2_OP_DISABLE_QUEUES:
1760		break;
1761	default:
1762		return -EINVAL;
1763	}
1764
1765	num_txq = vport->num_txq + vport->num_complq;
1766	num_rxq = vport->num_rxq + vport->num_bufq;
1767	num_q = num_txq + num_rxq;
1768	buf_sz = sizeof(struct virtchnl2_queue_chunk) * num_q;
1769	qc = kzalloc(buf_sz, GFP_KERNEL);
1770	if (!qc)
1771		return -ENOMEM;
1772
1773	for (i = 0; i < vport->num_txq_grp; i++) {
1774		struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1775
1776		for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1777			qc[k].type = cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1778			qc[k].start_queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1779			qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1780		}
1781	}
1782	if (vport->num_txq != k) {
1783		err = -EINVAL;
1784		goto error;
1785	}
1786
1787	if (!idpf_is_queue_model_split(vport->txq_model))
1788		goto setup_rx;
1789
1790	for (i = 0; i < vport->num_txq_grp; i++, k++) {
1791		struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1792
1793		qc[k].type = cpu_to_le32(tx_qgrp->complq->q_type);
1794		qc[k].start_queue_id = cpu_to_le32(tx_qgrp->complq->q_id);
1795		qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1796	}
1797	if (vport->num_complq != (k - vport->num_txq)) {
1798		err = -EINVAL;
1799		goto error;
1800	}
1801
1802setup_rx:
1803	for (i = 0; i < vport->num_rxq_grp; i++) {
1804		struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1805
1806		if (idpf_is_queue_model_split(vport->rxq_model))
1807			num_rxq = rx_qgrp->splitq.num_rxq_sets;
1808		else
1809			num_rxq = rx_qgrp->singleq.num_rxq;
1810
1811		for (j = 0; j < num_rxq; j++, k++) {
1812			if (idpf_is_queue_model_split(vport->rxq_model)) {
1813				qc[k].start_queue_id =
1814				cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_id);
1815				qc[k].type =
1816				cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_type);
1817			} else {
1818				qc[k].start_queue_id =
1819				cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_id);
1820				qc[k].type =
1821				cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_type);
1822			}
1823			qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1824		}
1825	}
1826	if (vport->num_rxq != k - (vport->num_txq + vport->num_complq)) {
1827		err = -EINVAL;
1828		goto error;
1829	}
1830
1831	if (!idpf_is_queue_model_split(vport->rxq_model))
1832		goto send_msg;
1833
1834	for (i = 0; i < vport->num_rxq_grp; i++) {
1835		struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1836
1837		for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) {
1838			struct idpf_queue *q;
1839
1840			q = &rx_qgrp->splitq.bufq_sets[j].bufq;
1841			qc[k].type = cpu_to_le32(q->q_type);
1842			qc[k].start_queue_id = cpu_to_le32(q->q_id);
1843			qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1844		}
1845	}
1846	if (vport->num_bufq != k - (vport->num_txq +
1847				    vport->num_complq +
1848				    vport->num_rxq)) {
1849		err = -EINVAL;
1850		goto error;
1851	}
1852
1853send_msg:
1854	/* Chunk up the queue info into multiple messages */
1855	config_sz = sizeof(struct virtchnl2_del_ena_dis_queues);
1856	chunk_sz = sizeof(struct virtchnl2_queue_chunk);
1857
1858	num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1859			   num_q);
1860	num_msgs = DIV_ROUND_UP(num_q, num_chunks);
1861
1862	buf_sz = struct_size(eq, chunks.chunks, num_chunks);
1863	eq = kzalloc(buf_sz, GFP_KERNEL);
1864	if (!eq) {
1865		err = -ENOMEM;
1866		goto error;
1867	}
1868
1869	mutex_lock(&vport->vc_buf_lock);
 
 
 
 
 
 
1870
1871	for (i = 0, k = 0; i < num_msgs; i++) {
1872		memset(eq, 0, buf_sz);
1873		eq->vport_id = cpu_to_le32(vport->vport_id);
1874		eq->chunks.num_chunks = cpu_to_le16(num_chunks);
1875		qcs = &eq->chunks;
1876		memcpy(qcs->chunks, &qc[k], chunk_sz * num_chunks);
1877
1878		err = idpf_send_mb_msg(adapter, vc_op, buf_sz, (u8 *)eq);
1879		if (err)
1880			goto mbx_error;
1881
1882		if (vc_op == VIRTCHNL2_OP_ENABLE_QUEUES)
1883			err = idpf_wait_for_event(adapter, vport,
1884						  IDPF_VC_ENA_QUEUES,
1885						  IDPF_VC_ENA_QUEUES_ERR);
1886		else
1887			err = idpf_min_wait_for_event(adapter, vport,
1888						      IDPF_VC_DIS_QUEUES,
1889						      IDPF_VC_DIS_QUEUES_ERR);
1890		if (err)
1891			goto mbx_error;
1892
1893		k += num_chunks;
1894		num_q -= num_chunks;
1895		num_chunks = min(num_chunks, num_q);
1896		/* Recalculate buffer size */
1897		buf_sz = struct_size(eq, chunks.chunks, num_chunks);
1898	}
1899
1900mbx_error:
1901	mutex_unlock(&vport->vc_buf_lock);
1902	kfree(eq);
1903error:
1904	kfree(qc);
1905
1906	return err;
1907}
1908
1909/**
1910 * idpf_send_map_unmap_queue_vector_msg - Send virtchnl map or unmap queue
1911 * vector message
1912 * @vport: virtual port data structure
1913 * @map: true for map and false for unmap
1914 *
1915 * Send map or unmap queue vector virtchnl message.  Returns 0 on success,
1916 * negative on failure.
1917 */
1918int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map)
1919{
1920	struct idpf_adapter *adapter = vport->adapter;
1921	struct virtchnl2_queue_vector_maps *vqvm;
1922	struct virtchnl2_queue_vector *vqv;
1923	u32 config_sz, chunk_sz, buf_sz;
1924	u32 num_msgs, num_chunks, num_q;
1925	int i, j, k = 0, err = 0;
 
1926
1927	num_q = vport->num_txq + vport->num_rxq;
1928
1929	buf_sz = sizeof(struct virtchnl2_queue_vector) * num_q;
1930	vqv = kzalloc(buf_sz, GFP_KERNEL);
1931	if (!vqv)
1932		return -ENOMEM;
1933
1934	for (i = 0; i < vport->num_txq_grp; i++) {
1935		struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1936
1937		for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1938			vqv[k].queue_type = cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1939			vqv[k].queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1940
1941			if (idpf_is_queue_model_split(vport->txq_model)) {
1942				vqv[k].vector_id =
1943				cpu_to_le16(tx_qgrp->complq->q_vector->v_idx);
1944				vqv[k].itr_idx =
1945				cpu_to_le32(tx_qgrp->complq->q_vector->tx_itr_idx);
1946			} else {
1947				vqv[k].vector_id =
1948				cpu_to_le16(tx_qgrp->txqs[j]->q_vector->v_idx);
1949				vqv[k].itr_idx =
1950				cpu_to_le32(tx_qgrp->txqs[j]->q_vector->tx_itr_idx);
1951			}
1952		}
1953	}
1954
1955	if (vport->num_txq != k) {
1956		err = -EINVAL;
1957		goto error;
1958	}
1959
1960	for (i = 0; i < vport->num_rxq_grp; i++) {
1961		struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1962		u16 num_rxq;
1963
1964		if (idpf_is_queue_model_split(vport->rxq_model))
1965			num_rxq = rx_qgrp->splitq.num_rxq_sets;
1966		else
1967			num_rxq = rx_qgrp->singleq.num_rxq;
1968
1969		for (j = 0; j < num_rxq; j++, k++) {
1970			struct idpf_queue *rxq;
1971
1972			if (idpf_is_queue_model_split(vport->rxq_model))
1973				rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq;
1974			else
1975				rxq = rx_qgrp->singleq.rxqs[j];
1976
1977			vqv[k].queue_type = cpu_to_le32(rxq->q_type);
1978			vqv[k].queue_id = cpu_to_le32(rxq->q_id);
1979			vqv[k].vector_id = cpu_to_le16(rxq->q_vector->v_idx);
1980			vqv[k].itr_idx = cpu_to_le32(rxq->q_vector->rx_itr_idx);
1981		}
1982	}
1983
1984	if (idpf_is_queue_model_split(vport->txq_model)) {
1985		if (vport->num_rxq != k - vport->num_complq) {
1986			err = -EINVAL;
1987			goto error;
1988		}
1989	} else {
1990		if (vport->num_rxq != k - vport->num_txq) {
1991			err = -EINVAL;
1992			goto error;
1993		}
1994	}
1995
1996	/* Chunk up the vector info into multiple messages */
1997	config_sz = sizeof(struct virtchnl2_queue_vector_maps);
1998	chunk_sz = sizeof(struct virtchnl2_queue_vector);
1999
2000	num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
2001			   num_q);
2002	num_msgs = DIV_ROUND_UP(num_q, num_chunks);
2003
2004	buf_sz = struct_size(vqvm, qv_maps, num_chunks);
2005	vqvm = kzalloc(buf_sz, GFP_KERNEL);
2006	if (!vqvm) {
2007		err = -ENOMEM;
2008		goto error;
2009	}
2010
2011	mutex_lock(&vport->vc_buf_lock);
 
 
 
 
 
 
2012
2013	for (i = 0, k = 0; i < num_msgs; i++) {
2014		memset(vqvm, 0, buf_sz);
 
 
2015		vqvm->vport_id = cpu_to_le32(vport->vport_id);
2016		vqvm->num_qv_maps = cpu_to_le16(num_chunks);
2017		memcpy(vqvm->qv_maps, &vqv[k], chunk_sz * num_chunks);
2018
2019		if (map) {
2020			err = idpf_send_mb_msg(adapter,
2021					       VIRTCHNL2_OP_MAP_QUEUE_VECTOR,
2022					       buf_sz, (u8 *)vqvm);
2023			if (!err)
2024				err = idpf_wait_for_event(adapter, vport,
2025							  IDPF_VC_MAP_IRQ,
2026							  IDPF_VC_MAP_IRQ_ERR);
2027		} else {
2028			err = idpf_send_mb_msg(adapter,
2029					       VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR,
2030					       buf_sz, (u8 *)vqvm);
2031			if (!err)
2032				err =
2033				idpf_min_wait_for_event(adapter, vport,
2034							IDPF_VC_UNMAP_IRQ,
2035							IDPF_VC_UNMAP_IRQ_ERR);
2036		}
2037		if (err)
2038			goto mbx_error;
2039
2040		k += num_chunks;
2041		num_q -= num_chunks;
2042		num_chunks = min(num_chunks, num_q);
2043		/* Recalculate buffer size */
2044		buf_sz = struct_size(vqvm, qv_maps, num_chunks);
2045	}
2046
2047mbx_error:
2048	mutex_unlock(&vport->vc_buf_lock);
2049	kfree(vqvm);
2050error:
2051	kfree(vqv);
2052
2053	return err;
2054}
2055
2056/**
2057 * idpf_send_enable_queues_msg - send enable queues virtchnl message
2058 * @vport: Virtual port private data structure
2059 *
2060 * Will send enable queues virtchnl message.  Returns 0 on success, negative on
2061 * failure.
2062 */
2063int idpf_send_enable_queues_msg(struct idpf_vport *vport)
2064{
2065	return idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_ENABLE_QUEUES);
2066}
2067
2068/**
2069 * idpf_send_disable_queues_msg - send disable queues virtchnl message
2070 * @vport: Virtual port private data structure
2071 *
2072 * Will send disable queues virtchnl message.  Returns 0 on success, negative
2073 * on failure.
2074 */
2075int idpf_send_disable_queues_msg(struct idpf_vport *vport)
2076{
2077	int err, i;
2078
2079	err = idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_DISABLE_QUEUES);
2080	if (err)
2081		return err;
2082
2083	/* switch to poll mode as interrupts will be disabled after disable
2084	 * queues virtchnl message is sent
2085	 */
2086	for (i = 0; i < vport->num_txq; i++)
2087		set_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags);
2088
2089	/* schedule the napi to receive all the marker packets */
2090	local_bh_disable();
2091	for (i = 0; i < vport->num_q_vectors; i++)
2092		napi_schedule(&vport->q_vectors[i].napi);
2093	local_bh_enable();
2094
2095	return idpf_wait_for_marker_event(vport);
2096}
2097
2098/**
2099 * idpf_convert_reg_to_queue_chunks - Copy queue chunk information to the right
2100 * structure
2101 * @dchunks: Destination chunks to store data to
2102 * @schunks: Source chunks to copy data from
2103 * @num_chunks: number of chunks to copy
2104 */
2105static void idpf_convert_reg_to_queue_chunks(struct virtchnl2_queue_chunk *dchunks,
2106					     struct virtchnl2_queue_reg_chunk *schunks,
2107					     u16 num_chunks)
2108{
2109	u16 i;
2110
2111	for (i = 0; i < num_chunks; i++) {
2112		dchunks[i].type = schunks[i].type;
2113		dchunks[i].start_queue_id = schunks[i].start_queue_id;
2114		dchunks[i].num_queues = schunks[i].num_queues;
2115	}
2116}
2117
2118/**
2119 * idpf_send_delete_queues_msg - send delete queues virtchnl message
2120 * @vport: Virtual port private data structure
2121 *
2122 * Will send delete queues virtchnl message. Return 0 on success, negative on
2123 * failure.
2124 */
2125int idpf_send_delete_queues_msg(struct idpf_vport *vport)
2126{
2127	struct idpf_adapter *adapter = vport->adapter;
2128	struct virtchnl2_create_vport *vport_params;
2129	struct virtchnl2_queue_reg_chunks *chunks;
2130	struct virtchnl2_del_ena_dis_queues *eq;
2131	struct idpf_vport_config *vport_config;
2132	u16 vport_idx = vport->idx;
2133	int buf_size, err;
2134	u16 num_chunks;
 
2135
2136	vport_config = adapter->vport_config[vport_idx];
2137	if (vport_config->req_qs_chunks) {
2138		struct virtchnl2_add_queues *vc_aq =
2139			(struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
2140		chunks = &vc_aq->chunks;
2141	} else {
2142		vport_params = adapter->vport_params_recvd[vport_idx];
2143		chunks = &vport_params->chunks;
2144	}
2145
2146	num_chunks = le16_to_cpu(chunks->num_chunks);
2147	buf_size = struct_size(eq, chunks.chunks, num_chunks);
2148
2149	eq = kzalloc(buf_size, GFP_KERNEL);
2150	if (!eq)
2151		return -ENOMEM;
2152
2153	eq->vport_id = cpu_to_le32(vport->vport_id);
2154	eq->chunks.num_chunks = cpu_to_le16(num_chunks);
2155
2156	idpf_convert_reg_to_queue_chunks(eq->chunks.chunks, chunks->chunks,
2157					 num_chunks);
2158
2159	mutex_lock(&vport->vc_buf_lock);
2160
2161	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEL_QUEUES,
2162			       buf_size, (u8 *)eq);
2163	if (err)
2164		goto rel_lock;
2165
2166	err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DEL_QUEUES,
2167				      IDPF_VC_DEL_QUEUES_ERR);
2168
2169rel_lock:
2170	mutex_unlock(&vport->vc_buf_lock);
2171	kfree(eq);
2172
2173	return err;
2174}
2175
2176/**
2177 * idpf_send_config_queues_msg - Send config queues virtchnl message
2178 * @vport: Virtual port private data structure
2179 *
2180 * Will send config queues virtchnl message. Returns 0 on success, negative on
2181 * failure.
2182 */
2183int idpf_send_config_queues_msg(struct idpf_vport *vport)
2184{
2185	int err;
2186
2187	err = idpf_send_config_tx_queues_msg(vport);
2188	if (err)
2189		return err;
2190
2191	return idpf_send_config_rx_queues_msg(vport);
2192}
2193
2194/**
2195 * idpf_send_add_queues_msg - Send virtchnl add queues message
2196 * @vport: Virtual port private data structure
2197 * @num_tx_q: number of transmit queues
2198 * @num_complq: number of transmit completion queues
2199 * @num_rx_q: number of receive queues
2200 * @num_rx_bufq: number of receive buffer queues
2201 *
2202 * Returns 0 on success, negative on failure. vport _MUST_ be const here as
2203 * we should not change any fields within vport itself in this function.
2204 */
2205int idpf_send_add_queues_msg(const struct idpf_vport *vport, u16 num_tx_q,
2206			     u16 num_complq, u16 num_rx_q, u16 num_rx_bufq)
2207{
2208	struct idpf_adapter *adapter = vport->adapter;
 
2209	struct idpf_vport_config *vport_config;
2210	struct virtchnl2_add_queues aq = { };
2211	struct virtchnl2_add_queues *vc_msg;
2212	u16 vport_idx = vport->idx;
2213	int size, err;
 
2214
2215	vport_config = adapter->vport_config[vport_idx];
 
 
 
 
 
 
2216
2217	aq.vport_id = cpu_to_le32(vport->vport_id);
2218	aq.num_tx_q = cpu_to_le16(num_tx_q);
2219	aq.num_tx_complq = cpu_to_le16(num_complq);
2220	aq.num_rx_q = cpu_to_le16(num_rx_q);
2221	aq.num_rx_bufq = cpu_to_le16(num_rx_bufq);
2222
2223	mutex_lock(&((struct idpf_vport *)vport)->vc_buf_lock);
2224
2225	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ADD_QUEUES,
2226			       sizeof(struct virtchnl2_add_queues), (u8 *)&aq);
2227	if (err)
2228		goto rel_lock;
 
 
 
2229
2230	/* We want vport to be const to prevent incidental code changes making
2231	 * changes to the vport config. We're making a special exception here
2232	 * to discard const to use the virtchnl.
2233	 */
2234	err = idpf_wait_for_event(adapter, (struct idpf_vport *)vport,
2235				  IDPF_VC_ADD_QUEUES, IDPF_VC_ADD_QUEUES_ERR);
2236	if (err)
2237		goto rel_lock;
2238
2239	kfree(vport_config->req_qs_chunks);
2240	vport_config->req_qs_chunks = NULL;
2241
2242	vc_msg = (struct virtchnl2_add_queues *)vport->vc_msg;
2243	/* compare vc_msg num queues with vport num queues */
2244	if (le16_to_cpu(vc_msg->num_tx_q) != num_tx_q ||
2245	    le16_to_cpu(vc_msg->num_rx_q) != num_rx_q ||
2246	    le16_to_cpu(vc_msg->num_tx_complq) != num_complq ||
2247	    le16_to_cpu(vc_msg->num_rx_bufq) != num_rx_bufq) {
2248		err = -EINVAL;
2249		goto rel_lock;
2250	}
2251
2252	size = struct_size(vc_msg, chunks.chunks,
2253			   le16_to_cpu(vc_msg->chunks.num_chunks));
2254	vport_config->req_qs_chunks = kmemdup(vc_msg, size, GFP_KERNEL);
2255	if (!vport_config->req_qs_chunks) {
2256		err = -ENOMEM;
2257		goto rel_lock;
2258	}
2259
2260rel_lock:
2261	mutex_unlock(&((struct idpf_vport *)vport)->vc_buf_lock);
 
2262
2263	return err;
2264}
2265
2266/**
2267 * idpf_send_alloc_vectors_msg - Send virtchnl alloc vectors message
2268 * @adapter: Driver specific private structure
2269 * @num_vectors: number of vectors to be allocated
2270 *
2271 * Returns 0 on success, negative on failure.
2272 */
2273int idpf_send_alloc_vectors_msg(struct idpf_adapter *adapter, u16 num_vectors)
2274{
2275	struct virtchnl2_alloc_vectors *alloc_vec, *rcvd_vec;
2276	struct virtchnl2_alloc_vectors ac = { };
 
 
2277	u16 num_vchunks;
2278	int size, err;
2279
2280	ac.num_vectors = cpu_to_le16(num_vectors);
2281
2282	mutex_lock(&adapter->vc_buf_lock);
2283
2284	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ALLOC_VECTORS,
2285			       sizeof(ac), (u8 *)&ac);
2286	if (err)
2287		goto rel_lock;
2288
2289	err = idpf_wait_for_event(adapter, NULL, IDPF_VC_ALLOC_VECTORS,
2290				  IDPF_VC_ALLOC_VECTORS_ERR);
2291	if (err)
2292		goto rel_lock;
 
 
 
 
 
2293
2294	rcvd_vec = (struct virtchnl2_alloc_vectors *)adapter->vc_msg;
2295	num_vchunks = le16_to_cpu(rcvd_vec->vchunks.num_vchunks);
2296
2297	size = struct_size(rcvd_vec, vchunks.vchunks, num_vchunks);
2298	if (size > sizeof(adapter->vc_msg)) {
2299		err = -EINVAL;
2300		goto rel_lock;
2301	}
 
2302
2303	kfree(adapter->req_vec_chunks);
2304	adapter->req_vec_chunks = NULL;
2305	adapter->req_vec_chunks = kmemdup(adapter->vc_msg, size, GFP_KERNEL);
2306	if (!adapter->req_vec_chunks) {
2307		err = -ENOMEM;
2308		goto rel_lock;
2309	}
2310
2311	alloc_vec = adapter->req_vec_chunks;
2312	if (le16_to_cpu(alloc_vec->num_vectors) < num_vectors) {
2313		kfree(adapter->req_vec_chunks);
2314		adapter->req_vec_chunks = NULL;
2315		err = -EINVAL;
2316	}
2317
2318rel_lock:
2319	mutex_unlock(&adapter->vc_buf_lock);
2320
2321	return err;
2322}
2323
2324/**
2325 * idpf_send_dealloc_vectors_msg - Send virtchnl de allocate vectors message
2326 * @adapter: Driver specific private structure
2327 *
2328 * Returns 0 on success, negative on failure.
2329 */
2330int idpf_send_dealloc_vectors_msg(struct idpf_adapter *adapter)
2331{
2332	struct virtchnl2_alloc_vectors *ac = adapter->req_vec_chunks;
2333	struct virtchnl2_vector_chunks *vcs = &ac->vchunks;
2334	int buf_size, err;
 
 
2335
2336	buf_size = struct_size(vcs, vchunks, le16_to_cpu(vcs->num_vchunks));
2337
2338	mutex_lock(&adapter->vc_buf_lock);
2339
2340	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEALLOC_VECTORS, buf_size,
2341			       (u8 *)vcs);
2342	if (err)
2343		goto rel_lock;
2344
2345	err = idpf_min_wait_for_event(adapter, NULL, IDPF_VC_DEALLOC_VECTORS,
2346				      IDPF_VC_DEALLOC_VECTORS_ERR);
2347	if (err)
2348		goto rel_lock;
2349
2350	kfree(adapter->req_vec_chunks);
2351	adapter->req_vec_chunks = NULL;
2352
2353rel_lock:
2354	mutex_unlock(&adapter->vc_buf_lock);
2355
2356	return err;
2357}
2358
2359/**
2360 * idpf_get_max_vfs - Get max number of vfs supported
2361 * @adapter: Driver specific private structure
2362 *
2363 * Returns max number of VFs
2364 */
2365static int idpf_get_max_vfs(struct idpf_adapter *adapter)
2366{
2367	return le16_to_cpu(adapter->caps.max_sriov_vfs);
2368}
2369
2370/**
2371 * idpf_send_set_sriov_vfs_msg - Send virtchnl set sriov vfs message
2372 * @adapter: Driver specific private structure
2373 * @num_vfs: number of virtual functions to be created
2374 *
2375 * Returns 0 on success, negative on failure.
2376 */
2377int idpf_send_set_sriov_vfs_msg(struct idpf_adapter *adapter, u16 num_vfs)
2378{
2379	struct virtchnl2_sriov_vfs_info svi = { };
2380	int err;
 
2381
2382	svi.num_vfs = cpu_to_le16(num_vfs);
 
 
 
 
 
2383
2384	mutex_lock(&adapter->vc_buf_lock);
2385
2386	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_SRIOV_VFS,
2387			       sizeof(svi), (u8 *)&svi);
2388	if (err)
2389		goto rel_lock;
2390
2391	err = idpf_wait_for_event(adapter, NULL, IDPF_VC_SET_SRIOV_VFS,
2392				  IDPF_VC_SET_SRIOV_VFS_ERR);
2393
2394rel_lock:
2395	mutex_unlock(&adapter->vc_buf_lock);
2396
2397	return err;
2398}
2399
2400/**
2401 * idpf_send_get_stats_msg - Send virtchnl get statistics message
2402 * @vport: vport to get stats for
2403 *
2404 * Returns 0 on success, negative on failure.
2405 */
2406int idpf_send_get_stats_msg(struct idpf_vport *vport)
2407{
2408	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
2409	struct rtnl_link_stats64 *netstats = &np->netstats;
2410	struct idpf_adapter *adapter = vport->adapter;
2411	struct virtchnl2_vport_stats stats_msg = { };
2412	struct virtchnl2_vport_stats *stats;
2413	int err;
2414
2415	/* Don't send get_stats message if the link is down */
2416	if (np->state <= __IDPF_VPORT_DOWN)
2417		return 0;
2418
2419	stats_msg.vport_id = cpu_to_le32(vport->vport_id);
2420
2421	mutex_lock(&vport->vc_buf_lock);
2422
2423	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_STATS,
2424			       sizeof(struct virtchnl2_vport_stats),
2425			       (u8 *)&stats_msg);
2426	if (err)
2427		goto rel_lock;
2428
2429	err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_STATS,
2430				  IDPF_VC_GET_STATS_ERR);
2431	if (err)
2432		goto rel_lock;
2433
2434	stats = (struct virtchnl2_vport_stats *)vport->vc_msg;
2435
2436	spin_lock_bh(&np->stats_lock);
2437
2438	netstats->rx_packets = le64_to_cpu(stats->rx_unicast) +
2439			       le64_to_cpu(stats->rx_multicast) +
2440			       le64_to_cpu(stats->rx_broadcast);
2441	netstats->rx_bytes = le64_to_cpu(stats->rx_bytes);
2442	netstats->rx_dropped = le64_to_cpu(stats->rx_discards);
2443	netstats->rx_over_errors = le64_to_cpu(stats->rx_overflow_drop);
2444	netstats->rx_length_errors = le64_to_cpu(stats->rx_invalid_frame_length);
2445
2446	netstats->tx_packets = le64_to_cpu(stats->tx_unicast) +
2447			       le64_to_cpu(stats->tx_multicast) +
2448			       le64_to_cpu(stats->tx_broadcast);
2449	netstats->tx_bytes = le64_to_cpu(stats->tx_bytes);
2450	netstats->tx_errors = le64_to_cpu(stats->tx_errors);
2451	netstats->tx_dropped = le64_to_cpu(stats->tx_discards);
2452
2453	vport->port_stats.vport_stats = *stats;
2454
2455	spin_unlock_bh(&np->stats_lock);
2456
2457rel_lock:
2458	mutex_unlock(&vport->vc_buf_lock);
2459
2460	return err;
2461}
2462
2463/**
2464 * idpf_send_get_set_rss_lut_msg - Send virtchnl get or set rss lut message
2465 * @vport: virtual port data structure
2466 * @get: flag to set or get rss look up table
2467 *
2468 * Returns 0 on success, negative on failure.
2469 */
2470int idpf_send_get_set_rss_lut_msg(struct idpf_vport *vport, bool get)
2471{
2472	struct idpf_adapter *adapter = vport->adapter;
2473	struct virtchnl2_rss_lut *recv_rl;
 
2474	struct idpf_rss_data *rss_data;
2475	struct virtchnl2_rss_lut *rl;
2476	int buf_size, lut_buf_size;
2477	int i, err;
 
2478
2479	rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data;
 
2480	buf_size = struct_size(rl, lut, rss_data->rss_lut_size);
2481	rl = kzalloc(buf_size, GFP_KERNEL);
2482	if (!rl)
2483		return -ENOMEM;
2484
2485	rl->vport_id = cpu_to_le32(vport->vport_id);
2486	mutex_lock(&vport->vc_buf_lock);
2487
2488	if (!get) {
 
 
 
 
 
 
 
 
 
 
 
2489		rl->lut_entries = cpu_to_le16(rss_data->rss_lut_size);
2490		for (i = 0; i < rss_data->rss_lut_size; i++)
2491			rl->lut[i] = cpu_to_le32(rss_data->rss_lut[i]);
2492
2493		err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_LUT,
2494				       buf_size, (u8 *)rl);
2495		if (err)
2496			goto free_mem;
2497
2498		err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_LUT,
2499					  IDPF_VC_SET_RSS_LUT_ERR);
2500
2501		goto free_mem;
2502	}
 
 
 
 
 
 
 
2503
2504	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_LUT,
2505			       buf_size, (u8 *)rl);
2506	if (err)
2507		goto free_mem;
2508
2509	err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_LUT,
2510				  IDPF_VC_GET_RSS_LUT_ERR);
2511	if (err)
2512		goto free_mem;
2513
2514	recv_rl = (struct virtchnl2_rss_lut *)vport->vc_msg;
2515	if (rss_data->rss_lut_size == le16_to_cpu(recv_rl->lut_entries))
2516		goto do_memcpy;
2517
2518	rss_data->rss_lut_size = le16_to_cpu(recv_rl->lut_entries);
2519	kfree(rss_data->rss_lut);
2520
2521	lut_buf_size = rss_data->rss_lut_size * sizeof(u32);
2522	rss_data->rss_lut = kzalloc(lut_buf_size, GFP_KERNEL);
2523	if (!rss_data->rss_lut) {
2524		rss_data->rss_lut_size = 0;
2525		err = -ENOMEM;
2526		goto free_mem;
2527	}
2528
2529do_memcpy:
2530	memcpy(rss_data->rss_lut, vport->vc_msg, rss_data->rss_lut_size);
2531free_mem:
2532	mutex_unlock(&vport->vc_buf_lock);
2533	kfree(rl);
2534
2535	return err;
2536}
2537
2538/**
2539 * idpf_send_get_set_rss_key_msg - Send virtchnl get or set rss key message
2540 * @vport: virtual port data structure
2541 * @get: flag to set or get rss look up table
2542 *
2543 * Returns 0 on success, negative on failure
2544 */
2545int idpf_send_get_set_rss_key_msg(struct idpf_vport *vport, bool get)
2546{
2547	struct idpf_adapter *adapter = vport->adapter;
2548	struct virtchnl2_rss_key *recv_rk;
 
2549	struct idpf_rss_data *rss_data;
2550	struct virtchnl2_rss_key *rk;
2551	int i, buf_size, err;
 
2552
2553	rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data;
 
2554	buf_size = struct_size(rk, key_flex, rss_data->rss_key_size);
2555	rk = kzalloc(buf_size, GFP_KERNEL);
2556	if (!rk)
2557		return -ENOMEM;
2558
2559	rk->vport_id = cpu_to_le32(vport->vport_id);
2560	mutex_lock(&vport->vc_buf_lock);
2561
 
2562	if (get) {
2563		err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_KEY,
2564				       buf_size, (u8 *)rk);
2565		if (err)
2566			goto error;
2567
2568		err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_KEY,
2569					  IDPF_VC_GET_RSS_KEY_ERR);
2570		if (err)
2571			goto error;
2572
2573		recv_rk = (struct virtchnl2_rss_key *)vport->vc_msg;
2574		if (rss_data->rss_key_size !=
2575		    le16_to_cpu(recv_rk->key_len)) {
2576			rss_data->rss_key_size =
2577				min_t(u16, NETDEV_RSS_KEY_LEN,
2578				      le16_to_cpu(recv_rk->key_len));
2579			kfree(rss_data->rss_key);
2580			rss_data->rss_key = kzalloc(rss_data->rss_key_size,
2581						    GFP_KERNEL);
2582			if (!rss_data->rss_key) {
2583				rss_data->rss_key_size = 0;
2584				err = -ENOMEM;
2585				goto error;
2586			}
2587		}
2588		memcpy(rss_data->rss_key, recv_rk->key_flex,
2589		       rss_data->rss_key_size);
2590	} else {
2591		rk->key_len = cpu_to_le16(rss_data->rss_key_size);
2592		for (i = 0; i < rss_data->rss_key_size; i++)
2593			rk->key_flex[i] = rss_data->rss_key[i];
2594
2595		err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_KEY,
2596				       buf_size, (u8 *)rk);
2597		if (err)
2598			goto error;
2599
2600		err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_KEY,
2601					  IDPF_VC_SET_RSS_KEY_ERR);
2602	}
2603
2604error:
2605	mutex_unlock(&vport->vc_buf_lock);
2606	kfree(rk);
 
 
 
 
2607
2608	return err;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2609}
2610
2611/**
2612 * idpf_fill_ptype_lookup - Fill L3 specific fields in ptype lookup table
2613 * @ptype: ptype lookup table
2614 * @pstate: state machine for ptype lookup table
2615 * @ipv4: ipv4 or ipv6
2616 * @frag: fragmentation allowed
2617 *
2618 */
2619static void idpf_fill_ptype_lookup(struct idpf_rx_ptype_decoded *ptype,
2620				   struct idpf_ptype_state *pstate,
2621				   bool ipv4, bool frag)
2622{
2623	if (!pstate->outer_ip || !pstate->outer_frag) {
2624		ptype->outer_ip = IDPF_RX_PTYPE_OUTER_IP;
2625		pstate->outer_ip = true;
2626
2627		if (ipv4)
2628			ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV4;
2629		else
2630			ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV6;
2631
2632		if (frag) {
2633			ptype->outer_frag = IDPF_RX_PTYPE_FRAG;
2634			pstate->outer_frag = true;
2635		}
2636	} else {
2637		ptype->tunnel_type = IDPF_RX_PTYPE_TUNNEL_IP_IP;
2638		pstate->tunnel_state = IDPF_PTYPE_TUNNEL_IP;
2639
2640		if (ipv4)
2641			ptype->tunnel_end_prot =
2642					IDPF_RX_PTYPE_TUNNEL_END_IPV4;
2643		else
2644			ptype->tunnel_end_prot =
2645					IDPF_RX_PTYPE_TUNNEL_END_IPV6;
2646
2647		if (frag)
2648			ptype->tunnel_end_frag = IDPF_RX_PTYPE_FRAG;
2649	}
2650}
2651
2652/**
2653 * idpf_send_get_rx_ptype_msg - Send virtchnl for ptype info
2654 * @vport: virtual port data structure
2655 *
2656 * Returns 0 on success, negative on failure.
2657 */
2658int idpf_send_get_rx_ptype_msg(struct idpf_vport *vport)
2659{
 
 
2660	struct idpf_rx_ptype_decoded *ptype_lkup = vport->rx_ptype_lkup;
2661	struct virtchnl2_get_ptype_info get_ptype_info;
2662	int max_ptype, ptypes_recvd = 0, ptype_offset;
2663	struct idpf_adapter *adapter = vport->adapter;
2664	struct virtchnl2_get_ptype_info *ptype_info;
2665	u16 next_ptype_id = 0;
2666	int err = 0, i, j, k;
 
2667
2668	if (idpf_is_queue_model_split(vport->rxq_model))
2669		max_ptype = IDPF_RX_MAX_PTYPE;
2670	else
2671		max_ptype = IDPF_RX_MAX_BASE_PTYPE;
2672
2673	memset(vport->rx_ptype_lkup, 0, sizeof(vport->rx_ptype_lkup));
2674
 
 
 
 
2675	ptype_info = kzalloc(IDPF_CTLQ_MAX_BUF_LEN, GFP_KERNEL);
2676	if (!ptype_info)
2677		return -ENOMEM;
2678
2679	mutex_lock(&adapter->vc_buf_lock);
 
 
 
 
 
2680
2681	while (next_ptype_id < max_ptype) {
2682		get_ptype_info.start_ptype_id = cpu_to_le16(next_ptype_id);
2683
2684		if ((next_ptype_id + IDPF_RX_MAX_PTYPES_PER_BUF) > max_ptype)
2685			get_ptype_info.num_ptypes =
2686				cpu_to_le16(max_ptype - next_ptype_id);
2687		else
2688			get_ptype_info.num_ptypes =
2689				cpu_to_le16(IDPF_RX_MAX_PTYPES_PER_BUF);
2690
2691		err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_PTYPE_INFO,
2692				       sizeof(struct virtchnl2_get_ptype_info),
2693				       (u8 *)&get_ptype_info);
2694		if (err)
2695			goto vc_buf_unlock;
2696
2697		err = idpf_wait_for_event(adapter, NULL, IDPF_VC_GET_PTYPE_INFO,
2698					  IDPF_VC_GET_PTYPE_INFO_ERR);
2699		if (err)
2700			goto vc_buf_unlock;
2701
2702		memcpy(ptype_info, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN);
 
2703
2704		ptypes_recvd += le16_to_cpu(ptype_info->num_ptypes);
2705		if (ptypes_recvd > max_ptype) {
2706			err = -EINVAL;
2707			goto vc_buf_unlock;
2708		}
2709
2710		next_ptype_id = le16_to_cpu(get_ptype_info.start_ptype_id) +
2711				le16_to_cpu(get_ptype_info.num_ptypes);
2712
2713		ptype_offset = IDPF_RX_PTYPE_HDR_SZ;
2714
2715		for (i = 0; i < le16_to_cpu(ptype_info->num_ptypes); i++) {
2716			struct idpf_ptype_state pstate = { };
2717			struct virtchnl2_ptype *ptype;
2718			u16 id;
2719
2720			ptype = (struct virtchnl2_ptype *)
2721					((u8 *)ptype_info + ptype_offset);
2722
2723			ptype_offset += IDPF_GET_PTYPE_SIZE(ptype);
2724			if (ptype_offset > IDPF_CTLQ_MAX_BUF_LEN) {
2725				err = -EINVAL;
2726				goto vc_buf_unlock;
2727			}
2728
2729			/* 0xFFFF indicates end of ptypes */
2730			if (le16_to_cpu(ptype->ptype_id_10) ==
2731							IDPF_INVALID_PTYPE_ID) {
2732				err = 0;
2733				goto vc_buf_unlock;
2734			}
2735
2736			if (idpf_is_queue_model_split(vport->rxq_model))
2737				k = le16_to_cpu(ptype->ptype_id_10);
2738			else
2739				k = ptype->ptype_id_8;
2740
2741			if (ptype->proto_id_count)
2742				ptype_lkup[k].known = 1;
2743
2744			for (j = 0; j < ptype->proto_id_count; j++) {
2745				id = le16_to_cpu(ptype->proto_id[j]);
2746				switch (id) {
2747				case VIRTCHNL2_PROTO_HDR_GRE:
2748					if (pstate.tunnel_state ==
2749							IDPF_PTYPE_TUNNEL_IP) {
2750						ptype_lkup[k].tunnel_type =
2751						IDPF_RX_PTYPE_TUNNEL_IP_GRENAT;
2752						pstate.tunnel_state |=
2753						IDPF_PTYPE_TUNNEL_IP_GRENAT;
2754					}
2755					break;
2756				case VIRTCHNL2_PROTO_HDR_MAC:
2757					ptype_lkup[k].outer_ip =
2758						IDPF_RX_PTYPE_OUTER_L2;
2759					if (pstate.tunnel_state ==
2760							IDPF_TUN_IP_GRE) {
2761						ptype_lkup[k].tunnel_type =
2762						IDPF_RX_PTYPE_TUNNEL_IP_GRENAT_MAC;
2763						pstate.tunnel_state |=
2764						IDPF_PTYPE_TUNNEL_IP_GRENAT_MAC;
2765					}
2766					break;
2767				case VIRTCHNL2_PROTO_HDR_IPV4:
2768					idpf_fill_ptype_lookup(&ptype_lkup[k],
2769							       &pstate, true,
2770							       false);
2771					break;
2772				case VIRTCHNL2_PROTO_HDR_IPV6:
2773					idpf_fill_ptype_lookup(&ptype_lkup[k],
2774							       &pstate, false,
2775							       false);
2776					break;
2777				case VIRTCHNL2_PROTO_HDR_IPV4_FRAG:
2778					idpf_fill_ptype_lookup(&ptype_lkup[k],
2779							       &pstate, true,
2780							       true);
2781					break;
2782				case VIRTCHNL2_PROTO_HDR_IPV6_FRAG:
2783					idpf_fill_ptype_lookup(&ptype_lkup[k],
2784							       &pstate, false,
2785							       true);
2786					break;
2787				case VIRTCHNL2_PROTO_HDR_UDP:
2788					ptype_lkup[k].inner_prot =
2789					IDPF_RX_PTYPE_INNER_PROT_UDP;
2790					break;
2791				case VIRTCHNL2_PROTO_HDR_TCP:
2792					ptype_lkup[k].inner_prot =
2793					IDPF_RX_PTYPE_INNER_PROT_TCP;
2794					break;
2795				case VIRTCHNL2_PROTO_HDR_SCTP:
2796					ptype_lkup[k].inner_prot =
2797					IDPF_RX_PTYPE_INNER_PROT_SCTP;
2798					break;
2799				case VIRTCHNL2_PROTO_HDR_ICMP:
2800					ptype_lkup[k].inner_prot =
2801					IDPF_RX_PTYPE_INNER_PROT_ICMP;
2802					break;
2803				case VIRTCHNL2_PROTO_HDR_PAY:
2804					ptype_lkup[k].payload_layer =
2805						IDPF_RX_PTYPE_PAYLOAD_LAYER_PAY2;
2806					break;
2807				case VIRTCHNL2_PROTO_HDR_ICMPV6:
2808				case VIRTCHNL2_PROTO_HDR_IPV6_EH:
2809				case VIRTCHNL2_PROTO_HDR_PRE_MAC:
2810				case VIRTCHNL2_PROTO_HDR_POST_MAC:
2811				case VIRTCHNL2_PROTO_HDR_ETHERTYPE:
2812				case VIRTCHNL2_PROTO_HDR_SVLAN:
2813				case VIRTCHNL2_PROTO_HDR_CVLAN:
2814				case VIRTCHNL2_PROTO_HDR_MPLS:
2815				case VIRTCHNL2_PROTO_HDR_MMPLS:
2816				case VIRTCHNL2_PROTO_HDR_PTP:
2817				case VIRTCHNL2_PROTO_HDR_CTRL:
2818				case VIRTCHNL2_PROTO_HDR_LLDP:
2819				case VIRTCHNL2_PROTO_HDR_ARP:
2820				case VIRTCHNL2_PROTO_HDR_ECP:
2821				case VIRTCHNL2_PROTO_HDR_EAPOL:
2822				case VIRTCHNL2_PROTO_HDR_PPPOD:
2823				case VIRTCHNL2_PROTO_HDR_PPPOE:
2824				case VIRTCHNL2_PROTO_HDR_IGMP:
2825				case VIRTCHNL2_PROTO_HDR_AH:
2826				case VIRTCHNL2_PROTO_HDR_ESP:
2827				case VIRTCHNL2_PROTO_HDR_IKE:
2828				case VIRTCHNL2_PROTO_HDR_NATT_KEEP:
2829				case VIRTCHNL2_PROTO_HDR_L2TPV2:
2830				case VIRTCHNL2_PROTO_HDR_L2TPV2_CONTROL:
2831				case VIRTCHNL2_PROTO_HDR_L2TPV3:
2832				case VIRTCHNL2_PROTO_HDR_GTP:
2833				case VIRTCHNL2_PROTO_HDR_GTP_EH:
2834				case VIRTCHNL2_PROTO_HDR_GTPCV2:
2835				case VIRTCHNL2_PROTO_HDR_GTPC_TEID:
2836				case VIRTCHNL2_PROTO_HDR_GTPU:
2837				case VIRTCHNL2_PROTO_HDR_GTPU_UL:
2838				case VIRTCHNL2_PROTO_HDR_GTPU_DL:
2839				case VIRTCHNL2_PROTO_HDR_ECPRI:
2840				case VIRTCHNL2_PROTO_HDR_VRRP:
2841				case VIRTCHNL2_PROTO_HDR_OSPF:
2842				case VIRTCHNL2_PROTO_HDR_TUN:
2843				case VIRTCHNL2_PROTO_HDR_NVGRE:
2844				case VIRTCHNL2_PROTO_HDR_VXLAN:
2845				case VIRTCHNL2_PROTO_HDR_VXLAN_GPE:
2846				case VIRTCHNL2_PROTO_HDR_GENEVE:
2847				case VIRTCHNL2_PROTO_HDR_NSH:
2848				case VIRTCHNL2_PROTO_HDR_QUIC:
2849				case VIRTCHNL2_PROTO_HDR_PFCP:
2850				case VIRTCHNL2_PROTO_HDR_PFCP_NODE:
2851				case VIRTCHNL2_PROTO_HDR_PFCP_SESSION:
2852				case VIRTCHNL2_PROTO_HDR_RTP:
2853				case VIRTCHNL2_PROTO_HDR_NO_PROTO:
2854					break;
2855				default:
2856					break;
2857				}
2858			}
2859		}
2860	}
2861
2862vc_buf_unlock:
2863	mutex_unlock(&adapter->vc_buf_lock);
2864	kfree(ptype_info);
2865
2866	return err;
2867}
2868
2869/**
2870 * idpf_send_ena_dis_loopback_msg - Send virtchnl enable/disable loopback
2871 *				    message
2872 * @vport: virtual port data structure
2873 *
2874 * Returns 0 on success, negative on failure.
2875 */
2876int idpf_send_ena_dis_loopback_msg(struct idpf_vport *vport)
2877{
 
2878	struct virtchnl2_loopback loopback;
2879	int err;
2880
2881	loopback.vport_id = cpu_to_le32(vport->vport_id);
2882	loopback.enable = idpf_is_feature_ena(vport, NETIF_F_LOOPBACK);
2883
2884	mutex_lock(&vport->vc_buf_lock);
 
 
 
 
2885
2886	err = idpf_send_mb_msg(vport->adapter, VIRTCHNL2_OP_LOOPBACK,
2887			       sizeof(loopback), (u8 *)&loopback);
2888	if (err)
2889		goto rel_lock;
2890
2891	err = idpf_wait_for_event(vport->adapter, vport,
2892				  IDPF_VC_LOOPBACK_STATE,
2893				  IDPF_VC_LOOPBACK_STATE_ERR);
2894
2895rel_lock:
2896	mutex_unlock(&vport->vc_buf_lock);
2897
2898	return err;
2899}
2900
2901/**
2902 * idpf_find_ctlq - Given a type and id, find ctlq info
2903 * @hw: hardware struct
2904 * @type: type of ctrlq to find
2905 * @id: ctlq id to find
2906 *
2907 * Returns pointer to found ctlq info struct, NULL otherwise.
2908 */
2909static struct idpf_ctlq_info *idpf_find_ctlq(struct idpf_hw *hw,
2910					     enum idpf_ctlq_type type, int id)
2911{
2912	struct idpf_ctlq_info *cq, *tmp;
2913
2914	list_for_each_entry_safe(cq, tmp, &hw->cq_list_head, cq_list)
2915		if (cq->q_id == id && cq->cq_type == type)
2916			return cq;
2917
2918	return NULL;
2919}
2920
2921/**
2922 * idpf_init_dflt_mbx - Setup default mailbox parameters and make request
2923 * @adapter: adapter info struct
2924 *
2925 * Returns 0 on success, negative otherwise
2926 */
2927int idpf_init_dflt_mbx(struct idpf_adapter *adapter)
2928{
2929	struct idpf_ctlq_create_info ctlq_info[] = {
2930		{
2931			.type = IDPF_CTLQ_TYPE_MAILBOX_TX,
2932			.id = IDPF_DFLT_MBX_ID,
2933			.len = IDPF_DFLT_MBX_Q_LEN,
2934			.buf_size = IDPF_CTLQ_MAX_BUF_LEN
2935		},
2936		{
2937			.type = IDPF_CTLQ_TYPE_MAILBOX_RX,
2938			.id = IDPF_DFLT_MBX_ID,
2939			.len = IDPF_DFLT_MBX_Q_LEN,
2940			.buf_size = IDPF_CTLQ_MAX_BUF_LEN
2941		}
2942	};
2943	struct idpf_hw *hw = &adapter->hw;
2944	int err;
2945
2946	adapter->dev_ops.reg_ops.ctlq_reg_init(ctlq_info);
2947
2948	err = idpf_ctlq_init(hw, IDPF_NUM_DFLT_MBX_Q, ctlq_info);
2949	if (err)
2950		return err;
2951
2952	hw->asq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_TX,
2953				 IDPF_DFLT_MBX_ID);
2954	hw->arq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_RX,
2955				 IDPF_DFLT_MBX_ID);
2956
2957	if (!hw->asq || !hw->arq) {
2958		idpf_ctlq_deinit(hw);
2959
2960		return -ENOENT;
2961	}
2962
2963	adapter->state = __IDPF_STARTUP;
2964
2965	return 0;
2966}
2967
2968/**
2969 * idpf_deinit_dflt_mbx - Free up ctlqs setup
2970 * @adapter: Driver specific private data structure
2971 */
2972void idpf_deinit_dflt_mbx(struct idpf_adapter *adapter)
2973{
2974	if (adapter->hw.arq && adapter->hw.asq) {
2975		idpf_mb_clean(adapter);
2976		idpf_ctlq_deinit(&adapter->hw);
2977	}
2978	adapter->hw.arq = NULL;
2979	adapter->hw.asq = NULL;
2980}
2981
2982/**
2983 * idpf_vport_params_buf_rel - Release memory for MailBox resources
2984 * @adapter: Driver specific private data structure
2985 *
2986 * Will release memory to hold the vport parameters received on MailBox
2987 */
2988static void idpf_vport_params_buf_rel(struct idpf_adapter *adapter)
2989{
2990	kfree(adapter->vport_params_recvd);
2991	adapter->vport_params_recvd = NULL;
2992	kfree(adapter->vport_params_reqd);
2993	adapter->vport_params_reqd = NULL;
2994	kfree(adapter->vport_ids);
2995	adapter->vport_ids = NULL;
2996}
2997
2998/**
2999 * idpf_vport_params_buf_alloc - Allocate memory for MailBox resources
3000 * @adapter: Driver specific private data structure
3001 *
3002 * Will alloc memory to hold the vport parameters received on MailBox
3003 */
3004static int idpf_vport_params_buf_alloc(struct idpf_adapter *adapter)
3005{
3006	u16 num_max_vports = idpf_get_max_vports(adapter);
3007
3008	adapter->vport_params_reqd = kcalloc(num_max_vports,
3009					     sizeof(*adapter->vport_params_reqd),
3010					     GFP_KERNEL);
3011	if (!adapter->vport_params_reqd)
3012		return -ENOMEM;
3013
3014	adapter->vport_params_recvd = kcalloc(num_max_vports,
3015					      sizeof(*adapter->vport_params_recvd),
3016					      GFP_KERNEL);
3017	if (!adapter->vport_params_recvd)
3018		goto err_mem;
3019
3020	adapter->vport_ids = kcalloc(num_max_vports, sizeof(u32), GFP_KERNEL);
3021	if (!adapter->vport_ids)
3022		goto err_mem;
3023
3024	if (adapter->vport_config)
3025		return 0;
3026
3027	adapter->vport_config = kcalloc(num_max_vports,
3028					sizeof(*adapter->vport_config),
3029					GFP_KERNEL);
3030	if (!adapter->vport_config)
3031		goto err_mem;
3032
3033	return 0;
3034
3035err_mem:
3036	idpf_vport_params_buf_rel(adapter);
3037
3038	return -ENOMEM;
3039}
3040
3041/**
3042 * idpf_vc_core_init - Initialize state machine and get driver specific
3043 * resources
3044 * @adapter: Driver specific private structure
3045 *
3046 * This function will initialize the state machine and request all necessary
3047 * resources required by the device driver. Once the state machine is
3048 * initialized, allocate memory to store vport specific information and also
3049 * requests required interrupts.
3050 *
3051 * Returns 0 on success, -EAGAIN function will get called again,
3052 * otherwise negative on failure.
3053 */
3054int idpf_vc_core_init(struct idpf_adapter *adapter)
3055{
3056	int task_delay = 30;
3057	u16 num_max_vports;
3058	int err = 0;
3059
 
 
 
 
 
 
 
 
 
3060	while (adapter->state != __IDPF_INIT_SW) {
3061		switch (adapter->state) {
3062		case __IDPF_STARTUP:
3063			if (idpf_send_ver_msg(adapter))
3064				goto init_failed;
3065			adapter->state = __IDPF_VER_CHECK;
3066			goto restart;
3067		case __IDPF_VER_CHECK:
3068			err = idpf_recv_ver_msg(adapter);
3069			if (err == -EIO) {
3070				return err;
3071			} else if (err == -EAGAIN) {
3072				adapter->state = __IDPF_STARTUP;
 
 
3073				goto restart;
3074			} else if (err) {
 
 
 
3075				goto init_failed;
3076			}
3077			if (idpf_send_get_caps_msg(adapter))
3078				goto init_failed;
3079			adapter->state = __IDPF_GET_CAPS;
3080			goto restart;
3081		case __IDPF_GET_CAPS:
3082			if (idpf_recv_get_caps_msg(adapter))
 
3083				goto init_failed;
3084			adapter->state = __IDPF_INIT_SW;
3085			break;
3086		default:
3087			dev_err(&adapter->pdev->dev, "Device is in bad state: %d\n",
3088				adapter->state);
 
3089			goto init_failed;
3090		}
3091		break;
3092restart:
3093		/* Give enough time before proceeding further with
3094		 * state machine
3095		 */
3096		msleep(task_delay);
3097	}
3098
3099	pci_sriov_set_totalvfs(adapter->pdev, idpf_get_max_vfs(adapter));
3100	num_max_vports = idpf_get_max_vports(adapter);
3101	adapter->max_vports = num_max_vports;
3102	adapter->vports = kcalloc(num_max_vports, sizeof(*adapter->vports),
3103				  GFP_KERNEL);
3104	if (!adapter->vports)
3105		return -ENOMEM;
3106
3107	if (!adapter->netdevs) {
3108		adapter->netdevs = kcalloc(num_max_vports,
3109					   sizeof(struct net_device *),
3110					   GFP_KERNEL);
3111		if (!adapter->netdevs) {
3112			err = -ENOMEM;
3113			goto err_netdev_alloc;
3114		}
3115	}
3116
3117	err = idpf_vport_params_buf_alloc(adapter);
3118	if (err) {
3119		dev_err(&adapter->pdev->dev, "Failed to alloc vport params buffer: %d\n",
3120			err);
3121		goto err_netdev_alloc;
3122	}
3123
3124	/* Start the mailbox task before requesting vectors. This will ensure
3125	 * vector information response from mailbox is handled
3126	 */
3127	queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
3128
3129	queue_delayed_work(adapter->serv_wq, &adapter->serv_task,
3130			   msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
3131
3132	err = idpf_intr_req(adapter);
3133	if (err) {
3134		dev_err(&adapter->pdev->dev, "failed to enable interrupt vectors: %d\n",
3135			err);
3136		goto err_intr_req;
3137	}
3138
3139	idpf_init_avail_queues(adapter);
3140
3141	/* Skew the delay for init tasks for each function based on fn number
3142	 * to prevent every function from making the same call simultaneously.
3143	 */
3144	queue_delayed_work(adapter->init_wq, &adapter->init_task,
3145			   msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
3146
3147	goto no_err;
 
 
3148
3149err_intr_req:
3150	cancel_delayed_work_sync(&adapter->serv_task);
3151	cancel_delayed_work_sync(&adapter->mbx_task);
3152	idpf_vport_params_buf_rel(adapter);
3153err_netdev_alloc:
3154	kfree(adapter->vports);
3155	adapter->vports = NULL;
3156no_err:
3157	return err;
3158
3159init_failed:
3160	/* Don't retry if we're trying to go down, just bail. */
3161	if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
3162		return err;
3163
3164	if (++adapter->mb_wait_count > IDPF_MB_MAX_ERR) {
3165		dev_err(&adapter->pdev->dev, "Failed to establish mailbox communications with hardware\n");
3166
3167		return -EFAULT;
3168	}
3169	/* If it reached here, it is possible that mailbox queue initialization
3170	 * register writes might not have taken effect. Retry to initialize
3171	 * the mailbox again
3172	 */
3173	adapter->state = __IDPF_STARTUP;
 
 
3174	idpf_deinit_dflt_mbx(adapter);
3175	set_bit(IDPF_HR_DRV_LOAD, adapter->flags);
3176	queue_delayed_work(adapter->vc_event_wq, &adapter->vc_event_task,
3177			   msecs_to_jiffies(task_delay));
3178
3179	return -EAGAIN;
3180}
3181
3182/**
3183 * idpf_vc_core_deinit - Device deinit routine
3184 * @adapter: Driver specific private structure
3185 *
3186 */
3187void idpf_vc_core_deinit(struct idpf_adapter *adapter)
3188{
3189	int i;
 
3190
 
3191	idpf_deinit_task(adapter);
3192	idpf_intr_rel(adapter);
3193	/* Set all bits as we dont know on which vc_state the vhnl_wq is
3194	 * waiting on and wakeup the virtchnl workqueue even if it is waiting
3195	 * for the response as we are going down
3196	 */
3197	for (i = 0; i < IDPF_VC_NBITS; i++)
3198		set_bit(i, adapter->vc_state);
3199	wake_up(&adapter->vchnl_wq);
3200
3201	cancel_delayed_work_sync(&adapter->serv_task);
3202	cancel_delayed_work_sync(&adapter->mbx_task);
3203
3204	idpf_vport_params_buf_rel(adapter);
3205
3206	/* Clear all the bits */
3207	for (i = 0; i < IDPF_VC_NBITS; i++)
3208		clear_bit(i, adapter->vc_state);
3209
3210	kfree(adapter->vports);
3211	adapter->vports = NULL;
 
 
3212}
3213
3214/**
3215 * idpf_vport_alloc_vec_indexes - Get relative vector indexes
3216 * @vport: virtual port data struct
3217 *
3218 * This function requests the vector information required for the vport and
3219 * stores the vector indexes received from the 'global vector distribution'
3220 * in the vport's queue vectors array.
3221 *
3222 * Return 0 on success, error on failure
3223 */
3224int idpf_vport_alloc_vec_indexes(struct idpf_vport *vport)
3225{
3226	struct idpf_vector_info vec_info;
3227	int num_alloc_vecs;
3228
3229	vec_info.num_curr_vecs = vport->num_q_vectors;
3230	vec_info.num_req_vecs = max(vport->num_txq, vport->num_rxq);
3231	vec_info.default_vport = vport->default_vport;
3232	vec_info.index = vport->idx;
3233
3234	num_alloc_vecs = idpf_req_rel_vector_indexes(vport->adapter,
3235						     vport->q_vector_idxs,
3236						     &vec_info);
3237	if (num_alloc_vecs <= 0) {
3238		dev_err(&vport->adapter->pdev->dev, "Vector distribution failed: %d\n",
3239			num_alloc_vecs);
3240		return -EINVAL;
3241	}
3242
3243	vport->num_q_vectors = num_alloc_vecs;
3244
3245	return 0;
3246}
3247
3248/**
3249 * idpf_vport_init - Initialize virtual port
3250 * @vport: virtual port to be initialized
3251 * @max_q: vport max queue info
3252 *
3253 * Will initialize vport with the info received through MB earlier
3254 */
3255void idpf_vport_init(struct idpf_vport *vport, struct idpf_vport_max_q *max_q)
3256{
3257	struct idpf_adapter *adapter = vport->adapter;
3258	struct virtchnl2_create_vport *vport_msg;
3259	struct idpf_vport_config *vport_config;
3260	u16 tx_itr[] = {2, 8, 64, 128, 256};
3261	u16 rx_itr[] = {2, 8, 32, 96, 128};
3262	struct idpf_rss_data *rss_data;
3263	u16 idx = vport->idx;
3264
3265	vport_config = adapter->vport_config[idx];
3266	rss_data = &vport_config->user_config.rss_data;
3267	vport_msg = adapter->vport_params_recvd[idx];
3268
3269	vport_config->max_q.max_txq = max_q->max_txq;
3270	vport_config->max_q.max_rxq = max_q->max_rxq;
3271	vport_config->max_q.max_complq = max_q->max_complq;
3272	vport_config->max_q.max_bufq = max_q->max_bufq;
3273
3274	vport->txq_model = le16_to_cpu(vport_msg->txq_model);
3275	vport->rxq_model = le16_to_cpu(vport_msg->rxq_model);
3276	vport->vport_type = le16_to_cpu(vport_msg->vport_type);
3277	vport->vport_id = le32_to_cpu(vport_msg->vport_id);
3278
3279	rss_data->rss_key_size = min_t(u16, NETDEV_RSS_KEY_LEN,
3280				       le16_to_cpu(vport_msg->rss_key_size));
3281	rss_data->rss_lut_size = le16_to_cpu(vport_msg->rss_lut_size);
3282
3283	ether_addr_copy(vport->default_mac_addr, vport_msg->default_mac_addr);
3284	vport->max_mtu = le16_to_cpu(vport_msg->max_mtu) - IDPF_PACKET_HDR_PAD;
3285
3286	/* Initialize Tx and Rx profiles for Dynamic Interrupt Moderation */
3287	memcpy(vport->rx_itr_profile, rx_itr, IDPF_DIM_PROFILE_SLOTS);
3288	memcpy(vport->tx_itr_profile, tx_itr, IDPF_DIM_PROFILE_SLOTS);
3289
3290	idpf_vport_set_hsplit(vport, ETHTOOL_TCP_DATA_SPLIT_ENABLED);
3291
3292	idpf_vport_init_num_qs(vport, vport_msg);
3293	idpf_vport_calc_num_q_desc(vport);
3294	idpf_vport_calc_num_q_groups(vport);
3295	idpf_vport_alloc_vec_indexes(vport);
3296
3297	vport->crc_enable = adapter->crc_enable;
3298}
3299
3300/**
3301 * idpf_get_vec_ids - Initialize vector id from Mailbox parameters
3302 * @adapter: adapter structure to get the mailbox vector id
3303 * @vecids: Array of vector ids
3304 * @num_vecids: number of vector ids
3305 * @chunks: vector ids received over mailbox
3306 *
3307 * Will initialize the mailbox vector id which is received from the
3308 * get capabilities and data queue vector ids with ids received as
3309 * mailbox parameters.
3310 * Returns number of ids filled
3311 */
3312int idpf_get_vec_ids(struct idpf_adapter *adapter,
3313		     u16 *vecids, int num_vecids,
3314		     struct virtchnl2_vector_chunks *chunks)
3315{
3316	u16 num_chunks = le16_to_cpu(chunks->num_vchunks);
3317	int num_vecid_filled = 0;
3318	int i, j;
3319
3320	vecids[num_vecid_filled] = adapter->mb_vector.v_idx;
3321	num_vecid_filled++;
3322
3323	for (j = 0; j < num_chunks; j++) {
3324		struct virtchnl2_vector_chunk *chunk;
3325		u16 start_vecid, num_vec;
3326
3327		chunk = &chunks->vchunks[j];
3328		num_vec = le16_to_cpu(chunk->num_vectors);
3329		start_vecid = le16_to_cpu(chunk->start_vector_id);
3330
3331		for (i = 0; i < num_vec; i++) {
3332			if ((num_vecid_filled + i) < num_vecids) {
3333				vecids[num_vecid_filled + i] = start_vecid;
3334				start_vecid++;
3335			} else {
3336				break;
3337			}
3338		}
3339		num_vecid_filled = num_vecid_filled + i;
3340	}
3341
3342	return num_vecid_filled;
3343}
3344
3345/**
3346 * idpf_vport_get_queue_ids - Initialize queue id from Mailbox parameters
3347 * @qids: Array of queue ids
3348 * @num_qids: number of queue ids
3349 * @q_type: queue model
3350 * @chunks: queue ids received over mailbox
3351 *
3352 * Will initialize all queue ids with ids received as mailbox parameters
3353 * Returns number of ids filled
3354 */
3355static int idpf_vport_get_queue_ids(u32 *qids, int num_qids, u16 q_type,
3356				    struct virtchnl2_queue_reg_chunks *chunks)
3357{
3358	u16 num_chunks = le16_to_cpu(chunks->num_chunks);
3359	u32 num_q_id_filled = 0, i;
3360	u32 start_q_id, num_q;
3361
3362	while (num_chunks--) {
3363		struct virtchnl2_queue_reg_chunk *chunk;
3364
3365		chunk = &chunks->chunks[num_chunks];
3366		if (le32_to_cpu(chunk->type) != q_type)
3367			continue;
3368
3369		num_q = le32_to_cpu(chunk->num_queues);
3370		start_q_id = le32_to_cpu(chunk->start_queue_id);
3371
3372		for (i = 0; i < num_q; i++) {
3373			if ((num_q_id_filled + i) < num_qids) {
3374				qids[num_q_id_filled + i] = start_q_id;
3375				start_q_id++;
3376			} else {
3377				break;
3378			}
3379		}
3380		num_q_id_filled = num_q_id_filled + i;
3381	}
3382
3383	return num_q_id_filled;
3384}
3385
3386/**
3387 * __idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters
3388 * @vport: virtual port for which the queues ids are initialized
3389 * @qids: queue ids
3390 * @num_qids: number of queue ids
3391 * @q_type: type of queue
3392 *
3393 * Will initialize all queue ids with ids received as mailbox
3394 * parameters. Returns number of queue ids initialized.
3395 */
3396static int __idpf_vport_queue_ids_init(struct idpf_vport *vport,
3397				       const u32 *qids,
3398				       int num_qids,
3399				       u32 q_type)
3400{
3401	struct idpf_queue *q;
3402	int i, j, k = 0;
3403
3404	switch (q_type) {
3405	case VIRTCHNL2_QUEUE_TYPE_TX:
3406		for (i = 0; i < vport->num_txq_grp; i++) {
3407			struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
3408
3409			for (j = 0; j < tx_qgrp->num_txq && k < num_qids; j++, k++) {
3410				tx_qgrp->txqs[j]->q_id = qids[k];
3411				tx_qgrp->txqs[j]->q_type =
3412					VIRTCHNL2_QUEUE_TYPE_TX;
3413			}
3414		}
3415		break;
3416	case VIRTCHNL2_QUEUE_TYPE_RX:
3417		for (i = 0; i < vport->num_rxq_grp; i++) {
3418			struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
3419			u16 num_rxq;
3420
3421			if (idpf_is_queue_model_split(vport->rxq_model))
3422				num_rxq = rx_qgrp->splitq.num_rxq_sets;
3423			else
3424				num_rxq = rx_qgrp->singleq.num_rxq;
3425
3426			for (j = 0; j < num_rxq && k < num_qids; j++, k++) {
3427				if (idpf_is_queue_model_split(vport->rxq_model))
3428					q = &rx_qgrp->splitq.rxq_sets[j]->rxq;
3429				else
3430					q = rx_qgrp->singleq.rxqs[j];
3431				q->q_id = qids[k];
3432				q->q_type = VIRTCHNL2_QUEUE_TYPE_RX;
3433			}
3434		}
3435		break;
3436	case VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION:
3437		for (i = 0; i < vport->num_txq_grp && k < num_qids; i++, k++) {
3438			struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
3439
3440			tx_qgrp->complq->q_id = qids[k];
3441			tx_qgrp->complq->q_type =
3442				VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION;
3443		}
3444		break;
3445	case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER:
3446		for (i = 0; i < vport->num_rxq_grp; i++) {
3447			struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
3448			u8 num_bufqs = vport->num_bufqs_per_qgrp;
3449
3450			for (j = 0; j < num_bufqs && k < num_qids; j++, k++) {
3451				q = &rx_qgrp->splitq.bufq_sets[j].bufq;
3452				q->q_id = qids[k];
3453				q->q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER;
3454			}
3455		}
3456		break;
3457	default:
3458		break;
3459	}
3460
3461	return k;
3462}
3463
3464/**
3465 * idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters
3466 * @vport: virtual port for which the queues ids are initialized
3467 *
3468 * Will initialize all queue ids with ids received as mailbox parameters.
3469 * Returns 0 on success, negative if all the queues are not initialized.
3470 */
3471int idpf_vport_queue_ids_init(struct idpf_vport *vport)
3472{
3473	struct virtchnl2_create_vport *vport_params;
3474	struct virtchnl2_queue_reg_chunks *chunks;
3475	struct idpf_vport_config *vport_config;
3476	u16 vport_idx = vport->idx;
3477	int num_ids, err = 0;
3478	u16 q_type;
3479	u32 *qids;
3480
3481	vport_config = vport->adapter->vport_config[vport_idx];
3482	if (vport_config->req_qs_chunks) {
3483		struct virtchnl2_add_queues *vc_aq =
3484			(struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
3485		chunks = &vc_aq->chunks;
3486	} else {
3487		vport_params = vport->adapter->vport_params_recvd[vport_idx];
3488		chunks = &vport_params->chunks;
3489	}
3490
3491	qids = kcalloc(IDPF_MAX_QIDS, sizeof(u32), GFP_KERNEL);
3492	if (!qids)
3493		return -ENOMEM;
3494
3495	num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS,
3496					   VIRTCHNL2_QUEUE_TYPE_TX,
3497					   chunks);
3498	if (num_ids < vport->num_txq) {
3499		err = -EINVAL;
3500		goto mem_rel;
3501	}
3502	num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids,
3503					      VIRTCHNL2_QUEUE_TYPE_TX);
3504	if (num_ids < vport->num_txq) {
3505		err = -EINVAL;
3506		goto mem_rel;
3507	}
3508
3509	num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS,
3510					   VIRTCHNL2_QUEUE_TYPE_RX,
3511					   chunks);
3512	if (num_ids < vport->num_rxq) {
3513		err = -EINVAL;
3514		goto mem_rel;
3515	}
3516	num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids,
3517					      VIRTCHNL2_QUEUE_TYPE_RX);
3518	if (num_ids < vport->num_rxq) {
3519		err = -EINVAL;
3520		goto mem_rel;
3521	}
3522
3523	if (!idpf_is_queue_model_split(vport->txq_model))
3524		goto check_rxq;
3525
3526	q_type = VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION;
3527	num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks);
3528	if (num_ids < vport->num_complq) {
3529		err = -EINVAL;
3530		goto mem_rel;
3531	}
3532	num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type);
3533	if (num_ids < vport->num_complq) {
3534		err = -EINVAL;
3535		goto mem_rel;
3536	}
3537
3538check_rxq:
3539	if (!idpf_is_queue_model_split(vport->rxq_model))
3540		goto mem_rel;
3541
3542	q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER;
3543	num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks);
3544	if (num_ids < vport->num_bufq) {
3545		err = -EINVAL;
3546		goto mem_rel;
3547	}
3548	num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type);
3549	if (num_ids < vport->num_bufq)
3550		err = -EINVAL;
3551
3552mem_rel:
3553	kfree(qids);
3554
3555	return err;
3556}
3557
3558/**
3559 * idpf_vport_adjust_qs - Adjust to new requested queues
3560 * @vport: virtual port data struct
3561 *
3562 * Renegotiate queues.  Returns 0 on success, negative on failure.
3563 */
3564int idpf_vport_adjust_qs(struct idpf_vport *vport)
3565{
3566	struct virtchnl2_create_vport vport_msg;
3567	int err;
3568
3569	vport_msg.txq_model = cpu_to_le16(vport->txq_model);
3570	vport_msg.rxq_model = cpu_to_le16(vport->rxq_model);
3571	err = idpf_vport_calc_total_qs(vport->adapter, vport->idx, &vport_msg,
3572				       NULL);
3573	if (err)
3574		return err;
3575
3576	idpf_vport_init_num_qs(vport, &vport_msg);
3577	idpf_vport_calc_num_q_groups(vport);
3578
3579	return 0;
3580}
3581
3582/**
3583 * idpf_is_capability_ena - Default implementation of capability checking
3584 * @adapter: Private data struct
3585 * @all: all or one flag
3586 * @field: caps field to check for flags
3587 * @flag: flag to check
3588 *
3589 * Return true if all capabilities are supported, false otherwise
3590 */
3591bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all,
3592			    enum idpf_cap_field field, u64 flag)
3593{
3594	u8 *caps = (u8 *)&adapter->caps;
3595	u32 *cap_field;
3596
3597	if (!caps)
3598		return false;
3599
3600	if (field == IDPF_BASE_CAPS)
3601		return false;
3602
3603	cap_field = (u32 *)(caps + field);
3604
3605	if (all)
3606		return (*cap_field & flag) == flag;
3607	else
3608		return !!(*cap_field & flag);
3609}
3610
3611/**
3612 * idpf_get_vport_id: Get vport id
3613 * @vport: virtual port structure
3614 *
3615 * Return vport id from the adapter persistent data
3616 */
3617u32 idpf_get_vport_id(struct idpf_vport *vport)
3618{
3619	struct virtchnl2_create_vport *vport_msg;
3620
3621	vport_msg = vport->adapter->vport_params_recvd[vport->idx];
3622
3623	return le32_to_cpu(vport_msg->vport_id);
3624}
3625
3626/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3627 * idpf_add_del_mac_filters - Add/del mac filters
3628 * @vport: Virtual port data structure
3629 * @np: Netdev private structure
3630 * @add: Add or delete flag
3631 * @async: Don't wait for return message
3632 *
3633 * Returns 0 on success, error on failure.
3634 **/
3635int idpf_add_del_mac_filters(struct idpf_vport *vport,
3636			     struct idpf_netdev_priv *np,
3637			     bool add, bool async)
3638{
3639	struct virtchnl2_mac_addr_list *ma_list = NULL;
 
3640	struct idpf_adapter *adapter = np->adapter;
 
3641	struct idpf_vport_config *vport_config;
3642	enum idpf_vport_config_flags mac_flag;
3643	struct pci_dev *pdev = adapter->pdev;
3644	enum idpf_vport_vc_state vc, vc_err;
3645	struct virtchnl2_mac_addr *mac_addr;
3646	struct idpf_mac_filter *f, *tmp;
3647	u32 num_msgs, total_filters = 0;
3648	int i = 0, k, err = 0;
3649	u32 vop;
 
 
 
 
 
 
 
3650
3651	vport_config = adapter->vport_config[np->vport_idx];
3652	spin_lock_bh(&vport_config->mac_filter_list_lock);
3653
3654	/* Find the number of newly added filters */
3655	list_for_each_entry(f, &vport_config->user_config.mac_filter_list,
3656			    list) {
3657		if (add && f->add)
3658			total_filters++;
3659		else if (!add && f->remove)
3660			total_filters++;
3661	}
3662
3663	if (!total_filters) {
3664		spin_unlock_bh(&vport_config->mac_filter_list_lock);
3665
3666		return 0;
3667	}
3668
3669	/* Fill all the new filters into virtchannel message */
3670	mac_addr = kcalloc(total_filters, sizeof(struct virtchnl2_mac_addr),
3671			   GFP_ATOMIC);
3672	if (!mac_addr) {
3673		err = -ENOMEM;
3674		spin_unlock_bh(&vport_config->mac_filter_list_lock);
3675		goto error;
 
3676	}
3677
3678	list_for_each_entry_safe(f, tmp, &vport_config->user_config.mac_filter_list,
3679				 list) {
3680		if (add && f->add) {
3681			ether_addr_copy(mac_addr[i].addr, f->macaddr);
3682			i++;
3683			f->add = false;
3684			if (i == total_filters)
3685				break;
3686		}
3687		if (!add && f->remove) {
3688			ether_addr_copy(mac_addr[i].addr, f->macaddr);
3689			i++;
3690			f->remove = false;
3691			if (i == total_filters)
3692				break;
3693		}
3694	}
3695
3696	spin_unlock_bh(&vport_config->mac_filter_list_lock);
3697
3698	if (add) {
3699		vop = VIRTCHNL2_OP_ADD_MAC_ADDR;
3700		vc = IDPF_VC_ADD_MAC_ADDR;
3701		vc_err = IDPF_VC_ADD_MAC_ADDR_ERR;
3702		mac_flag = IDPF_VPORT_ADD_MAC_REQ;
3703	} else {
3704		vop = VIRTCHNL2_OP_DEL_MAC_ADDR;
3705		vc = IDPF_VC_DEL_MAC_ADDR;
3706		vc_err = IDPF_VC_DEL_MAC_ADDR_ERR;
3707		mac_flag = IDPF_VPORT_DEL_MAC_REQ;
3708	}
3709
3710	/* Chunk up the filters into multiple messages to avoid
3711	 * sending a control queue message buffer that is too large
3712	 */
3713	num_msgs = DIV_ROUND_UP(total_filters, IDPF_NUM_FILTERS_PER_MSG);
3714
3715	if (!async)
3716		mutex_lock(&vport->vc_buf_lock);
3717
3718	for (i = 0, k = 0; i < num_msgs; i++) {
3719		u32 entries_size, buf_size, num_entries;
3720
3721		num_entries = min_t(u32, total_filters,
3722				    IDPF_NUM_FILTERS_PER_MSG);
3723		entries_size = sizeof(struct virtchnl2_mac_addr) * num_entries;
3724		buf_size = struct_size(ma_list, mac_addr_list, num_entries);
3725
3726		if (!ma_list || num_entries != IDPF_NUM_FILTERS_PER_MSG) {
3727			kfree(ma_list);
3728			ma_list = kzalloc(buf_size, GFP_ATOMIC);
3729			if (!ma_list) {
3730				err = -ENOMEM;
3731				goto list_prep_error;
3732			}
3733		} else {
3734			memset(ma_list, 0, buf_size);
3735		}
3736
3737		ma_list->vport_id = cpu_to_le32(np->vport_id);
3738		ma_list->num_mac_addr = cpu_to_le16(num_entries);
3739		memcpy(ma_list->mac_addr_list, &mac_addr[k], entries_size);
3740
3741		if (async)
3742			set_bit(mac_flag, vport_config->flags);
3743
3744		err = idpf_send_mb_msg(adapter, vop, buf_size, (u8 *)ma_list);
3745		if (err)
3746			goto mbx_error;
3747
3748		if (!async) {
3749			err = idpf_wait_for_event(adapter, vport, vc, vc_err);
3750			if (err)
3751				goto mbx_error;
3752		}
3753
3754		k += num_entries;
3755		total_filters -= num_entries;
3756	}
3757
3758mbx_error:
3759	if (!async)
3760		mutex_unlock(&vport->vc_buf_lock);
3761	kfree(ma_list);
3762list_prep_error:
3763	kfree(mac_addr);
3764error:
3765	if (err)
3766		dev_err(&pdev->dev, "Failed to add or del mac filters %d", err);
3767
3768	return err;
3769}
3770
3771/**
3772 * idpf_set_promiscuous - set promiscuous and send message to mailbox
3773 * @adapter: Driver specific private structure
3774 * @config_data: Vport specific config data
3775 * @vport_id: Vport identifier
3776 *
3777 * Request to enable promiscuous mode for the vport. Message is sent
3778 * asynchronously and won't wait for response.  Returns 0 on success, negative
3779 * on failure;
3780 */
3781int idpf_set_promiscuous(struct idpf_adapter *adapter,
3782			 struct idpf_vport_user_config_data *config_data,
3783			 u32 vport_id)
3784{
 
3785	struct virtchnl2_promisc_info vpi;
 
3786	u16 flags = 0;
3787	int err;
3788
3789	if (test_bit(__IDPF_PROMISC_UC, config_data->user_flags))
3790		flags |= VIRTCHNL2_UNICAST_PROMISC;
3791	if (test_bit(__IDPF_PROMISC_MC, config_data->user_flags))
3792		flags |= VIRTCHNL2_MULTICAST_PROMISC;
3793
3794	vpi.vport_id = cpu_to_le32(vport_id);
3795	vpi.flags = cpu_to_le16(flags);
3796
3797	err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE,
3798			       sizeof(struct virtchnl2_promisc_info),
3799			       (u8 *)&vpi);
 
 
 
 
3800
3801	return err;
3802}