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  */
idpf_recv_event_msg(struct idpf_vport * vport,struct idpf_ctlq_msg * ctlq_msg)13 static 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  */
idpf_mb_clean(struct idpf_adapter * adapter)58 static 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 
84 err_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  */
idpf_send_mb_msg(struct idpf_adapter * adapter,u32 op,u16 msg_size,u8 * msg)101 int 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 
151 send_error:
152 	dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va,
153 			  dma_mem->pa);
154 dma_alloc_error:
155 	kfree(dma_mem);
156 dma_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  */
idpf_find_vport(struct idpf_adapter * adapter,struct idpf_vport ** vport,struct idpf_ctlq_msg * ctlq_msg)172 static 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 
275 free_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  */
idpf_copy_data_to_vc_buf(struct idpf_adapter * adapter,struct idpf_vport * vport,struct idpf_ctlq_msg * ctlq_msg,enum idpf_vport_vc_state err_enum)291 static 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  */
idpf_recv_vchnl_op(struct idpf_adapter * adapter,struct idpf_vport * vport,struct idpf_ctlq_msg * ctlq_msg,enum idpf_vport_vc_state state,enum idpf_vport_vc_state err_state)326 static 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  */
idpf_recv_mb_msg(struct idpf_adapter * adapter,u32 op,void * msg,int msg_size)374 int 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 
619 post_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  */
__idpf_wait_for_event(struct idpf_adapter * adapter,struct idpf_vport * vport,enum idpf_vport_vc_state state,enum idpf_vport_vc_state err_check,int timeout)651 static 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  */
idpf_min_wait_for_event(struct idpf_adapter * adapter,struct idpf_vport * vport,enum idpf_vport_vc_state state,enum idpf_vport_vc_state err_check)716 static 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  */
idpf_wait_for_event(struct idpf_adapter * adapter,struct idpf_vport * vport,enum idpf_vport_vc_state state,enum idpf_vport_vc_state err_check)734 static 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  **/
idpf_wait_for_marker_event(struct idpf_vport * vport)756 static 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  */
idpf_send_ver_msg(struct idpf_adapter * adapter)786 static 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  */
idpf_recv_ver_msg(struct idpf_adapter * adapter)809 static 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  */
idpf_send_get_caps_msg(struct idpf_adapter * adapter)857 static 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  */
idpf_recv_get_caps_msg(struct idpf_adapter * adapter)927 static 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  */
idpf_vport_alloc_max_qs(struct idpf_adapter * adapter,struct idpf_vport_max_q * max_q)938 int 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  */
idpf_vport_dealloc_max_qs(struct idpf_adapter * adapter,struct idpf_vport_max_q * max_q)984 void 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  */
idpf_init_avail_queues(struct idpf_adapter * adapter)1004 static 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  */
idpf_get_reg_intr_vecs(struct idpf_vport * vport,struct idpf_vec_regs * reg_vals)1022 int 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  */
idpf_vport_get_q_reg(u32 * reg_vals,int num_regs,u32 q_type,struct virtchnl2_queue_reg_chunks * chunks)1074 static 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  */
__idpf_queue_reg_init(struct idpf_vport * vport,u32 * reg_vals,int num_regs,u32 q_type)1109 static 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  */
idpf_queue_reg_init(struct idpf_vport * vport)1163 int 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 
1238 free_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  */
idpf_send_create_vport_msg(struct idpf_adapter * adapter,struct idpf_vport_max_q * max_q)1253 int 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 
1316 rel_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  */
idpf_check_supported_desc_ids(struct idpf_vport * vport)1328 int 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  */
idpf_send_destroy_vport_msg(struct idpf_vport * vport)1367 int 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 
1385 rel_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  */
idpf_send_enable_vport_msg(struct idpf_vport * vport)1398 int 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 
1416 rel_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  */
idpf_send_disable_vport_msg(struct idpf_vport * vport)1429 int 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 
1447 rel_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  */
idpf_send_config_tx_queues_msg(struct idpf_vport * vport)1460 static 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 
1576 mbx_error:
1577 	mutex_unlock(&vport->vc_buf_lock);
1578 	kfree(ctq);
1579 error:
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  */
idpf_send_config_rx_queues_msg(struct idpf_vport * vport)1592 static 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 
1632 setup_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 
1658 common_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 
1728 mbx_error:
1729 	mutex_unlock(&vport->vc_buf_lock);
1730 	kfree(crq);
1731 error:
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  */
idpf_send_ena_dis_queues_msg(struct idpf_vport * vport,u32 vc_op)1746 static 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 
1802 setup_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 
1853 send_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 
1900 mbx_error:
1901 	mutex_unlock(&vport->vc_buf_lock);
1902 	kfree(eq);
1903 error:
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  */
idpf_send_map_unmap_queue_vector_msg(struct idpf_vport * vport,bool map)1918 int 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 
2047 mbx_error:
2048 	mutex_unlock(&vport->vc_buf_lock);
2049 	kfree(vqvm);
2050 error:
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  */
idpf_send_enable_queues_msg(struct idpf_vport * vport)2063 int 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  */
idpf_send_disable_queues_msg(struct idpf_vport * vport)2075 int 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  */
idpf_convert_reg_to_queue_chunks(struct virtchnl2_queue_chunk * dchunks,struct virtchnl2_queue_reg_chunk * schunks,u16 num_chunks)2105 static 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  */
idpf_send_delete_queues_msg(struct idpf_vport * vport)2125 int 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 
2169 rel_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  */
idpf_send_config_queues_msg(struct idpf_vport * vport)2183 int 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  */
idpf_send_add_queues_msg(const struct idpf_vport * vport,u16 num_tx_q,u16 num_complq,u16 num_rx_q,u16 num_rx_bufq)2205 int 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 
2260 rel_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  */
idpf_send_alloc_vectors_msg(struct idpf_adapter * adapter,u16 num_vectors)2273 int 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 
2318 rel_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  */
idpf_send_dealloc_vectors_msg(struct idpf_adapter * adapter)2330 int 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 
2353 rel_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  */
idpf_get_max_vfs(struct idpf_adapter * adapter)2365 static 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  */
idpf_send_set_sriov_vfs_msg(struct idpf_adapter * adapter,u16 num_vfs)2377 int 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 
2394 rel_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  */
idpf_send_get_stats_msg(struct idpf_vport * vport)2406 int 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 
2457 rel_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  */
idpf_send_get_set_rss_lut_msg(struct idpf_vport * vport,bool get)2470 int 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 
2529 do_memcpy:
2530 	memcpy(rss_data->rss_lut, vport->vc_msg, rss_data->rss_lut_size);
2531 free_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  */
idpf_send_get_set_rss_key_msg(struct idpf_vport * vport,bool get)2545 int 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 
2604 error:
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  */
idpf_fill_ptype_lookup(struct idpf_rx_ptype_decoded * ptype,struct idpf_ptype_state * pstate,bool ipv4,bool frag)2619 static 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  */
idpf_send_get_rx_ptype_msg(struct idpf_vport * vport)2658 int 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 
2862 vc_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  */
idpf_send_ena_dis_loopback_msg(struct idpf_vport * vport)2876 int 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 
2895 rel_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  */
idpf_find_ctlq(struct idpf_hw * hw,enum idpf_ctlq_type type,int id)2909 static 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  */
idpf_init_dflt_mbx(struct idpf_adapter * adapter)2927 int 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  */
idpf_deinit_dflt_mbx(struct idpf_adapter * adapter)2972 void 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  */
idpf_vport_params_buf_rel(struct idpf_adapter * adapter)2988 static 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  */
idpf_vport_params_buf_alloc(struct idpf_adapter * adapter)3004 static 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 
3035 err_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  */
idpf_vc_core_init(struct idpf_adapter * adapter)3054 int 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;
3092 restart:
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 
3149 err_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);
3153 err_netdev_alloc:
3154 	kfree(adapter->vports);
3155 	adapter->vports = NULL;
3156 no_err:
3157 	return err;
3158 
3159 init_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  */
idpf_vc_core_deinit(struct idpf_adapter * adapter)3187 void 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  */
idpf_vport_alloc_vec_indexes(struct idpf_vport * vport)3224 int 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  */
idpf_vport_init(struct idpf_vport * vport,struct idpf_vport_max_q * max_q)3255 void 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  */
idpf_get_vec_ids(struct idpf_adapter * adapter,u16 * vecids,int num_vecids,struct virtchnl2_vector_chunks * chunks)3312 int 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  */
idpf_vport_get_queue_ids(u32 * qids,int num_qids,u16 q_type,struct virtchnl2_queue_reg_chunks * chunks)3355 static 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  */
__idpf_vport_queue_ids_init(struct idpf_vport * vport,const u32 * qids,int num_qids,u32 q_type)3396 static 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  */
idpf_vport_queue_ids_init(struct idpf_vport * vport)3471 int 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 
3538 check_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 
3552 mem_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  */
idpf_vport_adjust_qs(struct idpf_vport * vport)3564 int 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  */
idpf_is_capability_ena(struct idpf_adapter * adapter,bool all,enum idpf_cap_field field,u64 flag)3591 bool 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  */
idpf_get_vport_id(struct idpf_vport * vport)3617 u32 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  **/
idpf_add_del_mac_filters(struct idpf_vport * vport,struct idpf_netdev_priv * np,bool add,bool async)3635 int 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 
3758 mbx_error:
3759 	if (!async)
3760 		mutex_unlock(&vport->vc_buf_lock);
3761 	kfree(ma_list);
3762 list_prep_error:
3763 	kfree(mac_addr);
3764 error:
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  */
idpf_set_promiscuous(struct idpf_adapter * adapter,struct idpf_vport_user_config_data * config_data,u32 vport_id)3781 int 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 }
3803