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