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