1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2023 Intel Corporation */
3
4 #include "idpf.h"
5 #include "idpf_virtchnl.h"
6
7 static const struct net_device_ops idpf_netdev_ops;
8
9 /**
10 * idpf_init_vector_stack - Fill the MSIX vector stack with vector index
11 * @adapter: private data struct
12 *
13 * Return 0 on success, error on failure
14 */
idpf_init_vector_stack(struct idpf_adapter * adapter)15 static int idpf_init_vector_stack(struct idpf_adapter *adapter)
16 {
17 struct idpf_vector_lifo *stack;
18 u16 min_vec;
19 u32 i;
20
21 mutex_lock(&adapter->vector_lock);
22 min_vec = adapter->num_msix_entries - adapter->num_avail_msix;
23 stack = &adapter->vector_stack;
24 stack->size = adapter->num_msix_entries;
25 /* set the base and top to point at start of the 'free pool' to
26 * distribute the unused vectors on-demand basis
27 */
28 stack->base = min_vec;
29 stack->top = min_vec;
30
31 stack->vec_idx = kcalloc(stack->size, sizeof(u16), GFP_KERNEL);
32 if (!stack->vec_idx) {
33 mutex_unlock(&adapter->vector_lock);
34
35 return -ENOMEM;
36 }
37
38 for (i = 0; i < stack->size; i++)
39 stack->vec_idx[i] = i;
40
41 mutex_unlock(&adapter->vector_lock);
42
43 return 0;
44 }
45
46 /**
47 * idpf_deinit_vector_stack - zero out the MSIX vector stack
48 * @adapter: private data struct
49 */
idpf_deinit_vector_stack(struct idpf_adapter * adapter)50 static void idpf_deinit_vector_stack(struct idpf_adapter *adapter)
51 {
52 struct idpf_vector_lifo *stack;
53
54 mutex_lock(&adapter->vector_lock);
55 stack = &adapter->vector_stack;
56 kfree(stack->vec_idx);
57 stack->vec_idx = NULL;
58 mutex_unlock(&adapter->vector_lock);
59 }
60
61 /**
62 * idpf_mb_intr_rel_irq - Free the IRQ association with the OS
63 * @adapter: adapter structure
64 *
65 * This will also disable interrupt mode and queue up mailbox task. Mailbox
66 * task will reschedule itself if not in interrupt mode.
67 */
idpf_mb_intr_rel_irq(struct idpf_adapter * adapter)68 static void idpf_mb_intr_rel_irq(struct idpf_adapter *adapter)
69 {
70 clear_bit(IDPF_MB_INTR_MODE, adapter->flags);
71 kfree(free_irq(adapter->msix_entries[0].vector, adapter));
72 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
73 }
74
75 /**
76 * idpf_intr_rel - Release interrupt capabilities and free memory
77 * @adapter: adapter to disable interrupts on
78 */
idpf_intr_rel(struct idpf_adapter * adapter)79 void idpf_intr_rel(struct idpf_adapter *adapter)
80 {
81 if (!adapter->msix_entries)
82 return;
83
84 idpf_mb_intr_rel_irq(adapter);
85 pci_free_irq_vectors(adapter->pdev);
86 idpf_send_dealloc_vectors_msg(adapter);
87 idpf_deinit_vector_stack(adapter);
88 kfree(adapter->msix_entries);
89 adapter->msix_entries = NULL;
90 }
91
92 /**
93 * idpf_mb_intr_clean - Interrupt handler for the mailbox
94 * @irq: interrupt number
95 * @data: pointer to the adapter structure
96 */
idpf_mb_intr_clean(int __always_unused irq,void * data)97 static irqreturn_t idpf_mb_intr_clean(int __always_unused irq, void *data)
98 {
99 struct idpf_adapter *adapter = (struct idpf_adapter *)data;
100
101 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
102
103 return IRQ_HANDLED;
104 }
105
106 /**
107 * idpf_mb_irq_enable - Enable MSIX interrupt for the mailbox
108 * @adapter: adapter to get the hardware address for register write
109 */
idpf_mb_irq_enable(struct idpf_adapter * adapter)110 static void idpf_mb_irq_enable(struct idpf_adapter *adapter)
111 {
112 struct idpf_intr_reg *intr = &adapter->mb_vector.intr_reg;
113 u32 val;
114
115 val = intr->dyn_ctl_intena_m | intr->dyn_ctl_itridx_m;
116 writel(val, intr->dyn_ctl);
117 writel(intr->icr_ena_ctlq_m, intr->icr_ena);
118 }
119
120 /**
121 * idpf_mb_intr_req_irq - Request irq for the mailbox interrupt
122 * @adapter: adapter structure to pass to the mailbox irq handler
123 */
idpf_mb_intr_req_irq(struct idpf_adapter * adapter)124 static int idpf_mb_intr_req_irq(struct idpf_adapter *adapter)
125 {
126 int irq_num, mb_vidx = 0, err;
127 char *name;
128
129 irq_num = adapter->msix_entries[mb_vidx].vector;
130 name = kasprintf(GFP_KERNEL, "%s-%s-%d",
131 dev_driver_string(&adapter->pdev->dev),
132 "Mailbox", mb_vidx);
133 err = request_irq(irq_num, adapter->irq_mb_handler, 0, name, adapter);
134 if (err) {
135 dev_err(&adapter->pdev->dev,
136 "IRQ request for mailbox failed, error: %d\n", err);
137
138 return err;
139 }
140
141 set_bit(IDPF_MB_INTR_MODE, adapter->flags);
142
143 return 0;
144 }
145
146 /**
147 * idpf_set_mb_vec_id - Set vector index for mailbox
148 * @adapter: adapter structure to access the vector chunks
149 *
150 * The first vector id in the requested vector chunks from the CP is for
151 * the mailbox
152 */
idpf_set_mb_vec_id(struct idpf_adapter * adapter)153 static void idpf_set_mb_vec_id(struct idpf_adapter *adapter)
154 {
155 if (adapter->req_vec_chunks)
156 adapter->mb_vector.v_idx =
157 le16_to_cpu(adapter->caps.mailbox_vector_id);
158 else
159 adapter->mb_vector.v_idx = 0;
160 }
161
162 /**
163 * idpf_mb_intr_init - Initialize the mailbox interrupt
164 * @adapter: adapter structure to store the mailbox vector
165 */
idpf_mb_intr_init(struct idpf_adapter * adapter)166 static int idpf_mb_intr_init(struct idpf_adapter *adapter)
167 {
168 adapter->dev_ops.reg_ops.mb_intr_reg_init(adapter);
169 adapter->irq_mb_handler = idpf_mb_intr_clean;
170
171 return idpf_mb_intr_req_irq(adapter);
172 }
173
174 /**
175 * idpf_vector_lifo_push - push MSIX vector index onto stack
176 * @adapter: private data struct
177 * @vec_idx: vector index to store
178 */
idpf_vector_lifo_push(struct idpf_adapter * adapter,u16 vec_idx)179 static int idpf_vector_lifo_push(struct idpf_adapter *adapter, u16 vec_idx)
180 {
181 struct idpf_vector_lifo *stack = &adapter->vector_stack;
182
183 lockdep_assert_held(&adapter->vector_lock);
184
185 if (stack->top == stack->base) {
186 dev_err(&adapter->pdev->dev, "Exceeded the vector stack limit: %d\n",
187 stack->top);
188 return -EINVAL;
189 }
190
191 stack->vec_idx[--stack->top] = vec_idx;
192
193 return 0;
194 }
195
196 /**
197 * idpf_vector_lifo_pop - pop MSIX vector index from stack
198 * @adapter: private data struct
199 */
idpf_vector_lifo_pop(struct idpf_adapter * adapter)200 static int idpf_vector_lifo_pop(struct idpf_adapter *adapter)
201 {
202 struct idpf_vector_lifo *stack = &adapter->vector_stack;
203
204 lockdep_assert_held(&adapter->vector_lock);
205
206 if (stack->top == stack->size) {
207 dev_err(&adapter->pdev->dev, "No interrupt vectors are available to distribute!\n");
208
209 return -EINVAL;
210 }
211
212 return stack->vec_idx[stack->top++];
213 }
214
215 /**
216 * idpf_vector_stash - Store the vector indexes onto the stack
217 * @adapter: private data struct
218 * @q_vector_idxs: vector index array
219 * @vec_info: info related to the number of vectors
220 *
221 * This function is a no-op if there are no vectors indexes to be stashed
222 */
idpf_vector_stash(struct idpf_adapter * adapter,u16 * q_vector_idxs,struct idpf_vector_info * vec_info)223 static void idpf_vector_stash(struct idpf_adapter *adapter, u16 *q_vector_idxs,
224 struct idpf_vector_info *vec_info)
225 {
226 int i, base = 0;
227 u16 vec_idx;
228
229 lockdep_assert_held(&adapter->vector_lock);
230
231 if (!vec_info->num_curr_vecs)
232 return;
233
234 /* For default vports, no need to stash vector allocated from the
235 * default pool onto the stack
236 */
237 if (vec_info->default_vport)
238 base = IDPF_MIN_Q_VEC;
239
240 for (i = vec_info->num_curr_vecs - 1; i >= base ; i--) {
241 vec_idx = q_vector_idxs[i];
242 idpf_vector_lifo_push(adapter, vec_idx);
243 adapter->num_avail_msix++;
244 }
245 }
246
247 /**
248 * idpf_req_rel_vector_indexes - Request or release MSIX vector indexes
249 * @adapter: driver specific private structure
250 * @q_vector_idxs: vector index array
251 * @vec_info: info related to the number of vectors
252 *
253 * This is the core function to distribute the MSIX vectors acquired from the
254 * OS. It expects the caller to pass the number of vectors required and
255 * also previously allocated. First, it stashes previously allocated vector
256 * indexes on to the stack and then figures out if it can allocate requested
257 * vectors. It can wait on acquiring the mutex lock. If the caller passes 0 as
258 * requested vectors, then this function just stashes the already allocated
259 * vectors and returns 0.
260 *
261 * Returns actual number of vectors allocated on success, error value on failure
262 * If 0 is returned, implies the stack has no vectors to allocate which is also
263 * a failure case for the caller
264 */
idpf_req_rel_vector_indexes(struct idpf_adapter * adapter,u16 * q_vector_idxs,struct idpf_vector_info * vec_info)265 int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,
266 u16 *q_vector_idxs,
267 struct idpf_vector_info *vec_info)
268 {
269 u16 num_req_vecs, num_alloc_vecs = 0, max_vecs;
270 struct idpf_vector_lifo *stack;
271 int i, j, vecid;
272
273 mutex_lock(&adapter->vector_lock);
274 stack = &adapter->vector_stack;
275 num_req_vecs = vec_info->num_req_vecs;
276
277 /* Stash interrupt vector indexes onto the stack if required */
278 idpf_vector_stash(adapter, q_vector_idxs, vec_info);
279
280 if (!num_req_vecs)
281 goto rel_lock;
282
283 if (vec_info->default_vport) {
284 /* As IDPF_MIN_Q_VEC per default vport is put aside in the
285 * default pool of the stack, use them for default vports
286 */
287 j = vec_info->index * IDPF_MIN_Q_VEC + IDPF_MBX_Q_VEC;
288 for (i = 0; i < IDPF_MIN_Q_VEC; i++) {
289 q_vector_idxs[num_alloc_vecs++] = stack->vec_idx[j++];
290 num_req_vecs--;
291 }
292 }
293
294 /* Find if stack has enough vector to allocate */
295 max_vecs = min(adapter->num_avail_msix, num_req_vecs);
296
297 for (j = 0; j < max_vecs; j++) {
298 vecid = idpf_vector_lifo_pop(adapter);
299 q_vector_idxs[num_alloc_vecs++] = vecid;
300 }
301 adapter->num_avail_msix -= max_vecs;
302
303 rel_lock:
304 mutex_unlock(&adapter->vector_lock);
305
306 return num_alloc_vecs;
307 }
308
309 /**
310 * idpf_intr_req - Request interrupt capabilities
311 * @adapter: adapter to enable interrupts on
312 *
313 * Returns 0 on success, negative on failure
314 */
idpf_intr_req(struct idpf_adapter * adapter)315 int idpf_intr_req(struct idpf_adapter *adapter)
316 {
317 u16 default_vports = idpf_get_default_vports(adapter);
318 int num_q_vecs, total_vecs, num_vec_ids;
319 int min_vectors, v_actual, err;
320 unsigned int vector;
321 u16 *vecids;
322
323 total_vecs = idpf_get_reserved_vecs(adapter);
324 num_q_vecs = total_vecs - IDPF_MBX_Q_VEC;
325
326 err = idpf_send_alloc_vectors_msg(adapter, num_q_vecs);
327 if (err) {
328 dev_err(&adapter->pdev->dev,
329 "Failed to allocate %d vectors: %d\n", num_q_vecs, err);
330
331 return -EAGAIN;
332 }
333
334 min_vectors = IDPF_MBX_Q_VEC + IDPF_MIN_Q_VEC * default_vports;
335 v_actual = pci_alloc_irq_vectors(adapter->pdev, min_vectors,
336 total_vecs, PCI_IRQ_MSIX);
337 if (v_actual < min_vectors) {
338 dev_err(&adapter->pdev->dev, "Failed to allocate MSIX vectors: %d\n",
339 v_actual);
340 err = -EAGAIN;
341 goto send_dealloc_vecs;
342 }
343
344 adapter->msix_entries = kcalloc(v_actual, sizeof(struct msix_entry),
345 GFP_KERNEL);
346
347 if (!adapter->msix_entries) {
348 err = -ENOMEM;
349 goto free_irq;
350 }
351
352 idpf_set_mb_vec_id(adapter);
353
354 vecids = kcalloc(total_vecs, sizeof(u16), GFP_KERNEL);
355 if (!vecids) {
356 err = -ENOMEM;
357 goto free_msix;
358 }
359
360 num_vec_ids = idpf_get_vec_ids(adapter, vecids, total_vecs,
361 &adapter->req_vec_chunks->vchunks);
362 if (num_vec_ids < v_actual) {
363 err = -EINVAL;
364 goto free_vecids;
365 }
366
367 for (vector = 0; vector < v_actual; vector++) {
368 adapter->msix_entries[vector].entry = vecids[vector];
369 adapter->msix_entries[vector].vector =
370 pci_irq_vector(adapter->pdev, vector);
371 }
372
373 adapter->num_req_msix = total_vecs;
374 adapter->num_msix_entries = v_actual;
375 /* 'num_avail_msix' is used to distribute excess vectors to the vports
376 * after considering the minimum vectors required per each default
377 * vport
378 */
379 adapter->num_avail_msix = v_actual - min_vectors;
380
381 /* Fill MSIX vector lifo stack with vector indexes */
382 err = idpf_init_vector_stack(adapter);
383 if (err)
384 goto free_vecids;
385
386 err = idpf_mb_intr_init(adapter);
387 if (err)
388 goto deinit_vec_stack;
389 idpf_mb_irq_enable(adapter);
390 kfree(vecids);
391
392 return 0;
393
394 deinit_vec_stack:
395 idpf_deinit_vector_stack(adapter);
396 free_vecids:
397 kfree(vecids);
398 free_msix:
399 kfree(adapter->msix_entries);
400 adapter->msix_entries = NULL;
401 free_irq:
402 pci_free_irq_vectors(adapter->pdev);
403 send_dealloc_vecs:
404 idpf_send_dealloc_vectors_msg(adapter);
405
406 return err;
407 }
408
409 /**
410 * idpf_find_mac_filter - Search filter list for specific mac filter
411 * @vconfig: Vport config structure
412 * @macaddr: The MAC address
413 *
414 * Returns ptr to the filter object or NULL. Must be called while holding the
415 * mac_filter_list_lock.
416 **/
idpf_find_mac_filter(struct idpf_vport_config * vconfig,const u8 * macaddr)417 static struct idpf_mac_filter *idpf_find_mac_filter(struct idpf_vport_config *vconfig,
418 const u8 *macaddr)
419 {
420 struct idpf_mac_filter *f;
421
422 if (!macaddr)
423 return NULL;
424
425 list_for_each_entry(f, &vconfig->user_config.mac_filter_list, list) {
426 if (ether_addr_equal(macaddr, f->macaddr))
427 return f;
428 }
429
430 return NULL;
431 }
432
433 /**
434 * __idpf_del_mac_filter - Delete a MAC filter from the filter list
435 * @vport_config: Vport config structure
436 * @macaddr: The MAC address
437 *
438 * Returns 0 on success, error value on failure
439 **/
__idpf_del_mac_filter(struct idpf_vport_config * vport_config,const u8 * macaddr)440 static int __idpf_del_mac_filter(struct idpf_vport_config *vport_config,
441 const u8 *macaddr)
442 {
443 struct idpf_mac_filter *f;
444
445 spin_lock_bh(&vport_config->mac_filter_list_lock);
446 f = idpf_find_mac_filter(vport_config, macaddr);
447 if (f) {
448 list_del(&f->list);
449 kfree(f);
450 }
451 spin_unlock_bh(&vport_config->mac_filter_list_lock);
452
453 return 0;
454 }
455
456 /**
457 * idpf_del_mac_filter - Delete a MAC filter from the filter list
458 * @vport: Main vport structure
459 * @np: Netdev private structure
460 * @macaddr: The MAC address
461 * @async: Don't wait for return message
462 *
463 * Removes filter from list and if interface is up, tells hardware about the
464 * removed filter.
465 **/
idpf_del_mac_filter(struct idpf_vport * vport,struct idpf_netdev_priv * np,const u8 * macaddr,bool async)466 static int idpf_del_mac_filter(struct idpf_vport *vport,
467 struct idpf_netdev_priv *np,
468 const u8 *macaddr, bool async)
469 {
470 struct idpf_vport_config *vport_config;
471 struct idpf_mac_filter *f;
472
473 vport_config = np->adapter->vport_config[np->vport_idx];
474
475 spin_lock_bh(&vport_config->mac_filter_list_lock);
476 f = idpf_find_mac_filter(vport_config, macaddr);
477 if (f) {
478 f->remove = true;
479 } else {
480 spin_unlock_bh(&vport_config->mac_filter_list_lock);
481
482 return -EINVAL;
483 }
484 spin_unlock_bh(&vport_config->mac_filter_list_lock);
485
486 if (np->state == __IDPF_VPORT_UP) {
487 int err;
488
489 err = idpf_add_del_mac_filters(vport, np, false, async);
490 if (err)
491 return err;
492 }
493
494 return __idpf_del_mac_filter(vport_config, macaddr);
495 }
496
497 /**
498 * __idpf_add_mac_filter - Add mac filter helper function
499 * @vport_config: Vport config structure
500 * @macaddr: Address to add
501 *
502 * Takes mac_filter_list_lock spinlock to add new filter to list.
503 */
__idpf_add_mac_filter(struct idpf_vport_config * vport_config,const u8 * macaddr)504 static int __idpf_add_mac_filter(struct idpf_vport_config *vport_config,
505 const u8 *macaddr)
506 {
507 struct idpf_mac_filter *f;
508
509 spin_lock_bh(&vport_config->mac_filter_list_lock);
510
511 f = idpf_find_mac_filter(vport_config, macaddr);
512 if (f) {
513 f->remove = false;
514 spin_unlock_bh(&vport_config->mac_filter_list_lock);
515
516 return 0;
517 }
518
519 f = kzalloc(sizeof(*f), GFP_ATOMIC);
520 if (!f) {
521 spin_unlock_bh(&vport_config->mac_filter_list_lock);
522
523 return -ENOMEM;
524 }
525
526 ether_addr_copy(f->macaddr, macaddr);
527 list_add_tail(&f->list, &vport_config->user_config.mac_filter_list);
528 f->add = true;
529
530 spin_unlock_bh(&vport_config->mac_filter_list_lock);
531
532 return 0;
533 }
534
535 /**
536 * idpf_add_mac_filter - Add a mac filter to the filter list
537 * @vport: Main vport structure
538 * @np: Netdev private structure
539 * @macaddr: The MAC address
540 * @async: Don't wait for return message
541 *
542 * Returns 0 on success or error on failure. If interface is up, we'll also
543 * send the virtchnl message to tell hardware about the filter.
544 **/
idpf_add_mac_filter(struct idpf_vport * vport,struct idpf_netdev_priv * np,const u8 * macaddr,bool async)545 static int idpf_add_mac_filter(struct idpf_vport *vport,
546 struct idpf_netdev_priv *np,
547 const u8 *macaddr, bool async)
548 {
549 struct idpf_vport_config *vport_config;
550 int err;
551
552 vport_config = np->adapter->vport_config[np->vport_idx];
553 err = __idpf_add_mac_filter(vport_config, macaddr);
554 if (err)
555 return err;
556
557 if (np->state == __IDPF_VPORT_UP)
558 err = idpf_add_del_mac_filters(vport, np, true, async);
559
560 return err;
561 }
562
563 /**
564 * idpf_del_all_mac_filters - Delete all MAC filters in list
565 * @vport: main vport struct
566 *
567 * Takes mac_filter_list_lock spinlock. Deletes all filters
568 */
idpf_del_all_mac_filters(struct idpf_vport * vport)569 static void idpf_del_all_mac_filters(struct idpf_vport *vport)
570 {
571 struct idpf_vport_config *vport_config;
572 struct idpf_mac_filter *f, *ftmp;
573
574 vport_config = vport->adapter->vport_config[vport->idx];
575 spin_lock_bh(&vport_config->mac_filter_list_lock);
576
577 list_for_each_entry_safe(f, ftmp, &vport_config->user_config.mac_filter_list,
578 list) {
579 list_del(&f->list);
580 kfree(f);
581 }
582
583 spin_unlock_bh(&vport_config->mac_filter_list_lock);
584 }
585
586 /**
587 * idpf_restore_mac_filters - Re-add all MAC filters in list
588 * @vport: main vport struct
589 *
590 * Takes mac_filter_list_lock spinlock. Sets add field to true for filters to
591 * resync filters back to HW.
592 */
idpf_restore_mac_filters(struct idpf_vport * vport)593 static void idpf_restore_mac_filters(struct idpf_vport *vport)
594 {
595 struct idpf_vport_config *vport_config;
596 struct idpf_mac_filter *f;
597
598 vport_config = vport->adapter->vport_config[vport->idx];
599 spin_lock_bh(&vport_config->mac_filter_list_lock);
600
601 list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
602 f->add = true;
603
604 spin_unlock_bh(&vport_config->mac_filter_list_lock);
605
606 idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),
607 true, false);
608 }
609
610 /**
611 * idpf_remove_mac_filters - Remove all MAC filters in list
612 * @vport: main vport struct
613 *
614 * Takes mac_filter_list_lock spinlock. Sets remove field to true for filters
615 * to remove filters in HW.
616 */
idpf_remove_mac_filters(struct idpf_vport * vport)617 static void idpf_remove_mac_filters(struct idpf_vport *vport)
618 {
619 struct idpf_vport_config *vport_config;
620 struct idpf_mac_filter *f;
621
622 vport_config = vport->adapter->vport_config[vport->idx];
623 spin_lock_bh(&vport_config->mac_filter_list_lock);
624
625 list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
626 f->remove = true;
627
628 spin_unlock_bh(&vport_config->mac_filter_list_lock);
629
630 idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),
631 false, false);
632 }
633
634 /**
635 * idpf_deinit_mac_addr - deinitialize mac address for vport
636 * @vport: main vport structure
637 */
idpf_deinit_mac_addr(struct idpf_vport * vport)638 static void idpf_deinit_mac_addr(struct idpf_vport *vport)
639 {
640 struct idpf_vport_config *vport_config;
641 struct idpf_mac_filter *f;
642
643 vport_config = vport->adapter->vport_config[vport->idx];
644
645 spin_lock_bh(&vport_config->mac_filter_list_lock);
646
647 f = idpf_find_mac_filter(vport_config, vport->default_mac_addr);
648 if (f) {
649 list_del(&f->list);
650 kfree(f);
651 }
652
653 spin_unlock_bh(&vport_config->mac_filter_list_lock);
654 }
655
656 /**
657 * idpf_init_mac_addr - initialize mac address for vport
658 * @vport: main vport structure
659 * @netdev: pointer to netdev struct associated with this vport
660 */
idpf_init_mac_addr(struct idpf_vport * vport,struct net_device * netdev)661 static int idpf_init_mac_addr(struct idpf_vport *vport,
662 struct net_device *netdev)
663 {
664 struct idpf_netdev_priv *np = netdev_priv(netdev);
665 struct idpf_adapter *adapter = vport->adapter;
666 int err;
667
668 if (is_valid_ether_addr(vport->default_mac_addr)) {
669 eth_hw_addr_set(netdev, vport->default_mac_addr);
670 ether_addr_copy(netdev->perm_addr, vport->default_mac_addr);
671
672 return idpf_add_mac_filter(vport, np, vport->default_mac_addr,
673 false);
674 }
675
676 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,
677 VIRTCHNL2_CAP_MACFILTER)) {
678 dev_err(&adapter->pdev->dev,
679 "MAC address is not provided and capability is not set\n");
680
681 return -EINVAL;
682 }
683
684 eth_hw_addr_random(netdev);
685 err = idpf_add_mac_filter(vport, np, netdev->dev_addr, false);
686 if (err)
687 return err;
688
689 dev_info(&adapter->pdev->dev, "Invalid MAC address %pM, using random %pM\n",
690 vport->default_mac_addr, netdev->dev_addr);
691 ether_addr_copy(vport->default_mac_addr, netdev->dev_addr);
692
693 return 0;
694 }
695
696 /**
697 * idpf_cfg_netdev - Allocate, configure and register a netdev
698 * @vport: main vport structure
699 *
700 * Returns 0 on success, negative value on failure.
701 */
idpf_cfg_netdev(struct idpf_vport * vport)702 static int idpf_cfg_netdev(struct idpf_vport *vport)
703 {
704 struct idpf_adapter *adapter = vport->adapter;
705 struct idpf_vport_config *vport_config;
706 netdev_features_t other_offloads = 0;
707 netdev_features_t csum_offloads = 0;
708 netdev_features_t tso_offloads = 0;
709 netdev_features_t dflt_features;
710 struct idpf_netdev_priv *np;
711 struct net_device *netdev;
712 u16 idx = vport->idx;
713 int err;
714
715 vport_config = adapter->vport_config[idx];
716
717 /* It's possible we already have a netdev allocated and registered for
718 * this vport
719 */
720 if (test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags)) {
721 netdev = adapter->netdevs[idx];
722 np = netdev_priv(netdev);
723 np->vport = vport;
724 np->vport_idx = vport->idx;
725 np->vport_id = vport->vport_id;
726 np->max_tx_hdr_size = idpf_get_max_tx_hdr_size(adapter);
727 vport->netdev = netdev;
728
729 return idpf_init_mac_addr(vport, netdev);
730 }
731
732 netdev = alloc_etherdev_mqs(sizeof(struct idpf_netdev_priv),
733 vport_config->max_q.max_txq,
734 vport_config->max_q.max_rxq);
735 if (!netdev)
736 return -ENOMEM;
737
738 vport->netdev = netdev;
739 np = netdev_priv(netdev);
740 np->vport = vport;
741 np->adapter = adapter;
742 np->vport_idx = vport->idx;
743 np->vport_id = vport->vport_id;
744 np->max_tx_hdr_size = idpf_get_max_tx_hdr_size(adapter);
745
746 spin_lock_init(&np->stats_lock);
747
748 err = idpf_init_mac_addr(vport, netdev);
749 if (err) {
750 free_netdev(vport->netdev);
751 vport->netdev = NULL;
752
753 return err;
754 }
755
756 /* assign netdev_ops */
757 netdev->netdev_ops = &idpf_netdev_ops;
758
759 /* setup watchdog timeout value to be 5 second */
760 netdev->watchdog_timeo = 5 * HZ;
761
762 netdev->dev_port = idx;
763
764 /* configure default MTU size */
765 netdev->min_mtu = ETH_MIN_MTU;
766 netdev->max_mtu = vport->max_mtu;
767
768 dflt_features = NETIF_F_SG |
769 NETIF_F_HIGHDMA;
770
771 if (idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))
772 dflt_features |= NETIF_F_RXHASH;
773 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V4))
774 csum_offloads |= NETIF_F_IP_CSUM;
775 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V6))
776 csum_offloads |= NETIF_F_IPV6_CSUM;
777 if (idpf_is_cap_ena(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM))
778 csum_offloads |= NETIF_F_RXCSUM;
779 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_SCTP_CSUM))
780 csum_offloads |= NETIF_F_SCTP_CRC;
781
782 if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV4_TCP))
783 tso_offloads |= NETIF_F_TSO;
784 if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV6_TCP))
785 tso_offloads |= NETIF_F_TSO6;
786 if (idpf_is_cap_ena_all(adapter, IDPF_SEG_CAPS,
787 VIRTCHNL2_CAP_SEG_IPV4_UDP |
788 VIRTCHNL2_CAP_SEG_IPV6_UDP))
789 tso_offloads |= NETIF_F_GSO_UDP_L4;
790 if (idpf_is_cap_ena_all(adapter, IDPF_RSC_CAPS, IDPF_CAP_RSC))
791 other_offloads |= NETIF_F_GRO_HW;
792 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_LOOPBACK))
793 other_offloads |= NETIF_F_LOOPBACK;
794
795 netdev->features |= dflt_features | csum_offloads | tso_offloads;
796 netdev->hw_features |= netdev->features | other_offloads;
797 netdev->vlan_features |= netdev->features | other_offloads;
798 netdev->hw_enc_features |= dflt_features | other_offloads;
799 idpf_set_ethtool_ops(netdev);
800 netif_set_affinity_auto(netdev);
801 SET_NETDEV_DEV(netdev, &adapter->pdev->dev);
802
803 /* carrier off on init to avoid Tx hangs */
804 netif_carrier_off(netdev);
805
806 /* make sure transmit queues start off as stopped */
807 netif_tx_stop_all_queues(netdev);
808
809 /* The vport can be arbitrarily released so we need to also track
810 * netdevs in the adapter struct
811 */
812 adapter->netdevs[idx] = netdev;
813
814 return 0;
815 }
816
817 /**
818 * idpf_get_free_slot - get the next non-NULL location index in array
819 * @adapter: adapter in which to look for a free vport slot
820 */
idpf_get_free_slot(struct idpf_adapter * adapter)821 static int idpf_get_free_slot(struct idpf_adapter *adapter)
822 {
823 unsigned int i;
824
825 for (i = 0; i < adapter->max_vports; i++) {
826 if (!adapter->vports[i])
827 return i;
828 }
829
830 return IDPF_NO_FREE_SLOT;
831 }
832
833 /**
834 * idpf_remove_features - Turn off feature configs
835 * @vport: virtual port structure
836 */
idpf_remove_features(struct idpf_vport * vport)837 static void idpf_remove_features(struct idpf_vport *vport)
838 {
839 struct idpf_adapter *adapter = vport->adapter;
840
841 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
842 idpf_remove_mac_filters(vport);
843 }
844
845 /**
846 * idpf_vport_stop - Disable a vport
847 * @vport: vport to disable
848 */
idpf_vport_stop(struct idpf_vport * vport)849 static void idpf_vport_stop(struct idpf_vport *vport)
850 {
851 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
852
853 if (np->state <= __IDPF_VPORT_DOWN)
854 return;
855
856 netif_carrier_off(vport->netdev);
857 netif_tx_disable(vport->netdev);
858
859 idpf_send_disable_vport_msg(vport);
860 idpf_send_disable_queues_msg(vport);
861 idpf_send_map_unmap_queue_vector_msg(vport, false);
862 /* Normally we ask for queues in create_vport, but if the number of
863 * initially requested queues have changed, for example via ethtool
864 * set channels, we do delete queues and then add the queues back
865 * instead of deleting and reallocating the vport.
866 */
867 if (test_and_clear_bit(IDPF_VPORT_DEL_QUEUES, vport->flags))
868 idpf_send_delete_queues_msg(vport);
869
870 idpf_remove_features(vport);
871
872 vport->link_up = false;
873 idpf_vport_intr_deinit(vport);
874 idpf_vport_queues_rel(vport);
875 idpf_vport_intr_rel(vport);
876 np->state = __IDPF_VPORT_DOWN;
877 }
878
879 /**
880 * idpf_stop - Disables a network interface
881 * @netdev: network interface device structure
882 *
883 * The stop entry point is called when an interface is de-activated by the OS,
884 * and the netdevice enters the DOWN state. The hardware is still under the
885 * driver's control, but the netdev interface is disabled.
886 *
887 * Returns success only - not allowed to fail
888 */
idpf_stop(struct net_device * netdev)889 static int idpf_stop(struct net_device *netdev)
890 {
891 struct idpf_netdev_priv *np = netdev_priv(netdev);
892 struct idpf_vport *vport;
893
894 if (test_bit(IDPF_REMOVE_IN_PROG, np->adapter->flags))
895 return 0;
896
897 idpf_vport_ctrl_lock(netdev);
898 vport = idpf_netdev_to_vport(netdev);
899
900 idpf_vport_stop(vport);
901
902 idpf_vport_ctrl_unlock(netdev);
903
904 return 0;
905 }
906
907 /**
908 * idpf_decfg_netdev - Unregister the netdev
909 * @vport: vport for which netdev to be unregistered
910 */
idpf_decfg_netdev(struct idpf_vport * vport)911 static void idpf_decfg_netdev(struct idpf_vport *vport)
912 {
913 struct idpf_adapter *adapter = vport->adapter;
914 u16 idx = vport->idx;
915
916 kfree(vport->rx_ptype_lkup);
917 vport->rx_ptype_lkup = NULL;
918
919 if (test_and_clear_bit(IDPF_VPORT_REG_NETDEV,
920 adapter->vport_config[idx]->flags)) {
921 unregister_netdev(vport->netdev);
922 free_netdev(vport->netdev);
923 }
924 vport->netdev = NULL;
925
926 adapter->netdevs[idx] = NULL;
927 }
928
929 /**
930 * idpf_vport_rel - Delete a vport and free its resources
931 * @vport: the vport being removed
932 */
idpf_vport_rel(struct idpf_vport * vport)933 static void idpf_vport_rel(struct idpf_vport *vport)
934 {
935 struct idpf_adapter *adapter = vport->adapter;
936 struct idpf_vport_config *vport_config;
937 struct idpf_vector_info vec_info;
938 struct idpf_rss_data *rss_data;
939 struct idpf_vport_max_q max_q;
940 u16 idx = vport->idx;
941
942 vport_config = adapter->vport_config[vport->idx];
943 idpf_deinit_rss(vport);
944 rss_data = &vport_config->user_config.rss_data;
945 kfree(rss_data->rss_key);
946 rss_data->rss_key = NULL;
947
948 idpf_send_destroy_vport_msg(vport);
949
950 /* Release all max queues allocated to the adapter's pool */
951 max_q.max_rxq = vport_config->max_q.max_rxq;
952 max_q.max_txq = vport_config->max_q.max_txq;
953 max_q.max_bufq = vport_config->max_q.max_bufq;
954 max_q.max_complq = vport_config->max_q.max_complq;
955 idpf_vport_dealloc_max_qs(adapter, &max_q);
956
957 /* Release all the allocated vectors on the stack */
958 vec_info.num_req_vecs = 0;
959 vec_info.num_curr_vecs = vport->num_q_vectors;
960 vec_info.default_vport = vport->default_vport;
961
962 idpf_req_rel_vector_indexes(adapter, vport->q_vector_idxs, &vec_info);
963
964 kfree(vport->q_vector_idxs);
965 vport->q_vector_idxs = NULL;
966
967 kfree(adapter->vport_params_recvd[idx]);
968 adapter->vport_params_recvd[idx] = NULL;
969 kfree(adapter->vport_params_reqd[idx]);
970 adapter->vport_params_reqd[idx] = NULL;
971 if (adapter->vport_config[idx]) {
972 kfree(adapter->vport_config[idx]->req_qs_chunks);
973 adapter->vport_config[idx]->req_qs_chunks = NULL;
974 }
975 kfree(vport);
976 adapter->num_alloc_vports--;
977 }
978
979 /**
980 * idpf_vport_dealloc - cleanup and release a given vport
981 * @vport: pointer to idpf vport structure
982 *
983 * returns nothing
984 */
idpf_vport_dealloc(struct idpf_vport * vport)985 static void idpf_vport_dealloc(struct idpf_vport *vport)
986 {
987 struct idpf_adapter *adapter = vport->adapter;
988 unsigned int i = vport->idx;
989
990 idpf_deinit_mac_addr(vport);
991 idpf_vport_stop(vport);
992
993 if (!test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
994 idpf_decfg_netdev(vport);
995 if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
996 idpf_del_all_mac_filters(vport);
997
998 if (adapter->netdevs[i]) {
999 struct idpf_netdev_priv *np = netdev_priv(adapter->netdevs[i]);
1000
1001 np->vport = NULL;
1002 }
1003
1004 idpf_vport_rel(vport);
1005
1006 adapter->vports[i] = NULL;
1007 adapter->next_vport = idpf_get_free_slot(adapter);
1008 }
1009
1010 /**
1011 * idpf_is_hsplit_supported - check whether the header split is supported
1012 * @vport: virtual port to check the capability for
1013 *
1014 * Return: true if it's supported by the HW/FW, false if not.
1015 */
idpf_is_hsplit_supported(const struct idpf_vport * vport)1016 static bool idpf_is_hsplit_supported(const struct idpf_vport *vport)
1017 {
1018 return idpf_is_queue_model_split(vport->rxq_model) &&
1019 idpf_is_cap_ena_all(vport->adapter, IDPF_HSPLIT_CAPS,
1020 IDPF_CAP_HSPLIT);
1021 }
1022
1023 /**
1024 * idpf_vport_get_hsplit - get the current header split feature state
1025 * @vport: virtual port to query the state for
1026 *
1027 * Return: ``ETHTOOL_TCP_DATA_SPLIT_UNKNOWN`` if not supported,
1028 * ``ETHTOOL_TCP_DATA_SPLIT_DISABLED`` if disabled,
1029 * ``ETHTOOL_TCP_DATA_SPLIT_ENABLED`` if active.
1030 */
idpf_vport_get_hsplit(const struct idpf_vport * vport)1031 u8 idpf_vport_get_hsplit(const struct idpf_vport *vport)
1032 {
1033 const struct idpf_vport_user_config_data *config;
1034
1035 if (!idpf_is_hsplit_supported(vport))
1036 return ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;
1037
1038 config = &vport->adapter->vport_config[vport->idx]->user_config;
1039
1040 return test_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags) ?
1041 ETHTOOL_TCP_DATA_SPLIT_ENABLED :
1042 ETHTOOL_TCP_DATA_SPLIT_DISABLED;
1043 }
1044
1045 /**
1046 * idpf_vport_set_hsplit - enable or disable header split on a given vport
1047 * @vport: virtual port to configure
1048 * @val: Ethtool flag controlling the header split state
1049 *
1050 * Return: true on success, false if not supported by the HW.
1051 */
idpf_vport_set_hsplit(const struct idpf_vport * vport,u8 val)1052 bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val)
1053 {
1054 struct idpf_vport_user_config_data *config;
1055
1056 if (!idpf_is_hsplit_supported(vport))
1057 return val == ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;
1058
1059 config = &vport->adapter->vport_config[vport->idx]->user_config;
1060
1061 switch (val) {
1062 case ETHTOOL_TCP_DATA_SPLIT_UNKNOWN:
1063 /* Default is to enable */
1064 case ETHTOOL_TCP_DATA_SPLIT_ENABLED:
1065 __set_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
1066 return true;
1067 case ETHTOOL_TCP_DATA_SPLIT_DISABLED:
1068 __clear_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
1069 return true;
1070 default:
1071 return false;
1072 }
1073 }
1074
1075 /**
1076 * idpf_vport_alloc - Allocates the next available struct vport in the adapter
1077 * @adapter: board private structure
1078 * @max_q: vport max queue info
1079 *
1080 * returns a pointer to a vport on success, NULL on failure.
1081 */
idpf_vport_alloc(struct idpf_adapter * adapter,struct idpf_vport_max_q * max_q)1082 static struct idpf_vport *idpf_vport_alloc(struct idpf_adapter *adapter,
1083 struct idpf_vport_max_q *max_q)
1084 {
1085 struct idpf_rss_data *rss_data;
1086 u16 idx = adapter->next_vport;
1087 struct idpf_vport *vport;
1088 u16 num_max_q;
1089
1090 if (idx == IDPF_NO_FREE_SLOT)
1091 return NULL;
1092
1093 vport = kzalloc(sizeof(*vport), GFP_KERNEL);
1094 if (!vport)
1095 return vport;
1096
1097 if (!adapter->vport_config[idx]) {
1098 struct idpf_vport_config *vport_config;
1099
1100 vport_config = kzalloc(sizeof(*vport_config), GFP_KERNEL);
1101 if (!vport_config) {
1102 kfree(vport);
1103
1104 return NULL;
1105 }
1106
1107 adapter->vport_config[idx] = vport_config;
1108 }
1109
1110 vport->idx = idx;
1111 vport->adapter = adapter;
1112 vport->compln_clean_budget = IDPF_TX_COMPLQ_CLEAN_BUDGET;
1113 vport->default_vport = adapter->num_alloc_vports <
1114 idpf_get_default_vports(adapter);
1115
1116 num_max_q = max(max_q->max_txq, max_q->max_rxq);
1117 vport->q_vector_idxs = kcalloc(num_max_q, sizeof(u16), GFP_KERNEL);
1118 if (!vport->q_vector_idxs)
1119 goto free_vport;
1120
1121 idpf_vport_init(vport, max_q);
1122
1123 /* This alloc is done separate from the LUT because it's not strictly
1124 * dependent on how many queues we have. If we change number of queues
1125 * and soft reset we'll need a new LUT but the key can remain the same
1126 * for as long as the vport exists.
1127 */
1128 rss_data = &adapter->vport_config[idx]->user_config.rss_data;
1129 rss_data->rss_key = kzalloc(rss_data->rss_key_size, GFP_KERNEL);
1130 if (!rss_data->rss_key)
1131 goto free_vector_idxs;
1132
1133 /* Initialize default rss key */
1134 netdev_rss_key_fill((void *)rss_data->rss_key, rss_data->rss_key_size);
1135
1136 /* fill vport slot in the adapter struct */
1137 adapter->vports[idx] = vport;
1138 adapter->vport_ids[idx] = idpf_get_vport_id(vport);
1139
1140 adapter->num_alloc_vports++;
1141 /* prepare adapter->next_vport for next use */
1142 adapter->next_vport = idpf_get_free_slot(adapter);
1143
1144 return vport;
1145
1146 free_vector_idxs:
1147 kfree(vport->q_vector_idxs);
1148 free_vport:
1149 kfree(vport);
1150
1151 return NULL;
1152 }
1153
1154 /**
1155 * idpf_get_stats64 - get statistics for network device structure
1156 * @netdev: network interface device structure
1157 * @stats: main device statistics structure
1158 */
idpf_get_stats64(struct net_device * netdev,struct rtnl_link_stats64 * stats)1159 static void idpf_get_stats64(struct net_device *netdev,
1160 struct rtnl_link_stats64 *stats)
1161 {
1162 struct idpf_netdev_priv *np = netdev_priv(netdev);
1163
1164 spin_lock_bh(&np->stats_lock);
1165 *stats = np->netstats;
1166 spin_unlock_bh(&np->stats_lock);
1167 }
1168
1169 /**
1170 * idpf_statistics_task - Delayed task to get statistics over mailbox
1171 * @work: work_struct handle to our data
1172 */
idpf_statistics_task(struct work_struct * work)1173 void idpf_statistics_task(struct work_struct *work)
1174 {
1175 struct idpf_adapter *adapter;
1176 int i;
1177
1178 adapter = container_of(work, struct idpf_adapter, stats_task.work);
1179
1180 for (i = 0; i < adapter->max_vports; i++) {
1181 struct idpf_vport *vport = adapter->vports[i];
1182
1183 if (vport && !test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
1184 idpf_send_get_stats_msg(vport);
1185 }
1186
1187 queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
1188 msecs_to_jiffies(10000));
1189 }
1190
1191 /**
1192 * idpf_mbx_task - Delayed task to handle mailbox responses
1193 * @work: work_struct handle
1194 */
idpf_mbx_task(struct work_struct * work)1195 void idpf_mbx_task(struct work_struct *work)
1196 {
1197 struct idpf_adapter *adapter;
1198
1199 adapter = container_of(work, struct idpf_adapter, mbx_task.work);
1200
1201 if (test_bit(IDPF_MB_INTR_MODE, adapter->flags))
1202 idpf_mb_irq_enable(adapter);
1203 else
1204 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task,
1205 msecs_to_jiffies(300));
1206
1207 idpf_recv_mb_msg(adapter);
1208 }
1209
1210 /**
1211 * idpf_service_task - Delayed task for handling mailbox responses
1212 * @work: work_struct handle to our data
1213 *
1214 */
idpf_service_task(struct work_struct * work)1215 void idpf_service_task(struct work_struct *work)
1216 {
1217 struct idpf_adapter *adapter;
1218
1219 adapter = container_of(work, struct idpf_adapter, serv_task.work);
1220
1221 if (idpf_is_reset_detected(adapter) &&
1222 !idpf_is_reset_in_prog(adapter) &&
1223 !test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
1224 dev_info(&adapter->pdev->dev, "HW reset detected\n");
1225 set_bit(IDPF_HR_FUNC_RESET, adapter->flags);
1226 queue_delayed_work(adapter->vc_event_wq,
1227 &adapter->vc_event_task,
1228 msecs_to_jiffies(10));
1229 }
1230
1231 queue_delayed_work(adapter->serv_wq, &adapter->serv_task,
1232 msecs_to_jiffies(300));
1233 }
1234
1235 /**
1236 * idpf_restore_features - Restore feature configs
1237 * @vport: virtual port structure
1238 */
idpf_restore_features(struct idpf_vport * vport)1239 static void idpf_restore_features(struct idpf_vport *vport)
1240 {
1241 struct idpf_adapter *adapter = vport->adapter;
1242
1243 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
1244 idpf_restore_mac_filters(vport);
1245 }
1246
1247 /**
1248 * idpf_set_real_num_queues - set number of queues for netdev
1249 * @vport: virtual port structure
1250 *
1251 * Returns 0 on success, negative on failure.
1252 */
idpf_set_real_num_queues(struct idpf_vport * vport)1253 static int idpf_set_real_num_queues(struct idpf_vport *vport)
1254 {
1255 int err;
1256
1257 err = netif_set_real_num_rx_queues(vport->netdev, vport->num_rxq);
1258 if (err)
1259 return err;
1260
1261 return netif_set_real_num_tx_queues(vport->netdev, vport->num_txq);
1262 }
1263
1264 /**
1265 * idpf_up_complete - Complete interface up sequence
1266 * @vport: virtual port structure
1267 *
1268 * Returns 0 on success, negative on failure.
1269 */
idpf_up_complete(struct idpf_vport * vport)1270 static int idpf_up_complete(struct idpf_vport *vport)
1271 {
1272 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1273
1274 if (vport->link_up && !netif_carrier_ok(vport->netdev)) {
1275 netif_carrier_on(vport->netdev);
1276 netif_tx_start_all_queues(vport->netdev);
1277 }
1278
1279 np->state = __IDPF_VPORT_UP;
1280
1281 return 0;
1282 }
1283
1284 /**
1285 * idpf_rx_init_buf_tail - Write initial buffer ring tail value
1286 * @vport: virtual port struct
1287 */
idpf_rx_init_buf_tail(struct idpf_vport * vport)1288 static void idpf_rx_init_buf_tail(struct idpf_vport *vport)
1289 {
1290 int i, j;
1291
1292 for (i = 0; i < vport->num_rxq_grp; i++) {
1293 struct idpf_rxq_group *grp = &vport->rxq_grps[i];
1294
1295 if (idpf_is_queue_model_split(vport->rxq_model)) {
1296 for (j = 0; j < vport->num_bufqs_per_qgrp; j++) {
1297 const struct idpf_buf_queue *q =
1298 &grp->splitq.bufq_sets[j].bufq;
1299
1300 writel(q->next_to_alloc, q->tail);
1301 }
1302 } else {
1303 for (j = 0; j < grp->singleq.num_rxq; j++) {
1304 const struct idpf_rx_queue *q =
1305 grp->singleq.rxqs[j];
1306
1307 writel(q->next_to_alloc, q->tail);
1308 }
1309 }
1310 }
1311 }
1312
1313 /**
1314 * idpf_vport_open - Bring up a vport
1315 * @vport: vport to bring up
1316 */
idpf_vport_open(struct idpf_vport * vport)1317 static int idpf_vport_open(struct idpf_vport *vport)
1318 {
1319 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1320 struct idpf_adapter *adapter = vport->adapter;
1321 struct idpf_vport_config *vport_config;
1322 int err;
1323
1324 if (np->state != __IDPF_VPORT_DOWN)
1325 return -EBUSY;
1326
1327 /* we do not allow interface up just yet */
1328 netif_carrier_off(vport->netdev);
1329
1330 err = idpf_vport_intr_alloc(vport);
1331 if (err) {
1332 dev_err(&adapter->pdev->dev, "Failed to allocate interrupts for vport %u: %d\n",
1333 vport->vport_id, err);
1334 return err;
1335 }
1336
1337 err = idpf_vport_queues_alloc(vport);
1338 if (err)
1339 goto intr_rel;
1340
1341 err = idpf_vport_queue_ids_init(vport);
1342 if (err) {
1343 dev_err(&adapter->pdev->dev, "Failed to initialize queue ids for vport %u: %d\n",
1344 vport->vport_id, err);
1345 goto queues_rel;
1346 }
1347
1348 err = idpf_vport_intr_init(vport);
1349 if (err) {
1350 dev_err(&adapter->pdev->dev, "Failed to initialize interrupts for vport %u: %d\n",
1351 vport->vport_id, err);
1352 goto queues_rel;
1353 }
1354
1355 err = idpf_rx_bufs_init_all(vport);
1356 if (err) {
1357 dev_err(&adapter->pdev->dev, "Failed to initialize RX buffers for vport %u: %d\n",
1358 vport->vport_id, err);
1359 goto queues_rel;
1360 }
1361
1362 err = idpf_queue_reg_init(vport);
1363 if (err) {
1364 dev_err(&adapter->pdev->dev, "Failed to initialize queue registers for vport %u: %d\n",
1365 vport->vport_id, err);
1366 goto queues_rel;
1367 }
1368
1369 idpf_rx_init_buf_tail(vport);
1370 idpf_vport_intr_ena(vport);
1371
1372 err = idpf_send_config_queues_msg(vport);
1373 if (err) {
1374 dev_err(&adapter->pdev->dev, "Failed to configure queues for vport %u, %d\n",
1375 vport->vport_id, err);
1376 goto intr_deinit;
1377 }
1378
1379 err = idpf_send_map_unmap_queue_vector_msg(vport, true);
1380 if (err) {
1381 dev_err(&adapter->pdev->dev, "Failed to map queue vectors for vport %u: %d\n",
1382 vport->vport_id, err);
1383 goto intr_deinit;
1384 }
1385
1386 err = idpf_send_enable_queues_msg(vport);
1387 if (err) {
1388 dev_err(&adapter->pdev->dev, "Failed to enable queues for vport %u: %d\n",
1389 vport->vport_id, err);
1390 goto unmap_queue_vectors;
1391 }
1392
1393 err = idpf_send_enable_vport_msg(vport);
1394 if (err) {
1395 dev_err(&adapter->pdev->dev, "Failed to enable vport %u: %d\n",
1396 vport->vport_id, err);
1397 err = -EAGAIN;
1398 goto disable_queues;
1399 }
1400
1401 idpf_restore_features(vport);
1402
1403 vport_config = adapter->vport_config[vport->idx];
1404 if (vport_config->user_config.rss_data.rss_lut)
1405 err = idpf_config_rss(vport);
1406 else
1407 err = idpf_init_rss(vport);
1408 if (err) {
1409 dev_err(&adapter->pdev->dev, "Failed to initialize RSS for vport %u: %d\n",
1410 vport->vport_id, err);
1411 goto disable_vport;
1412 }
1413
1414 err = idpf_up_complete(vport);
1415 if (err) {
1416 dev_err(&adapter->pdev->dev, "Failed to complete interface up for vport %u: %d\n",
1417 vport->vport_id, err);
1418 goto deinit_rss;
1419 }
1420
1421 return 0;
1422
1423 deinit_rss:
1424 idpf_deinit_rss(vport);
1425 disable_vport:
1426 idpf_send_disable_vport_msg(vport);
1427 disable_queues:
1428 idpf_send_disable_queues_msg(vport);
1429 unmap_queue_vectors:
1430 idpf_send_map_unmap_queue_vector_msg(vport, false);
1431 intr_deinit:
1432 idpf_vport_intr_deinit(vport);
1433 queues_rel:
1434 idpf_vport_queues_rel(vport);
1435 intr_rel:
1436 idpf_vport_intr_rel(vport);
1437
1438 return err;
1439 }
1440
1441 /**
1442 * idpf_init_task - Delayed initialization task
1443 * @work: work_struct handle to our data
1444 *
1445 * Init task finishes up pending work started in probe. Due to the asynchronous
1446 * nature in which the device communicates with hardware, we may have to wait
1447 * several milliseconds to get a response. Instead of busy polling in probe,
1448 * pulling it out into a delayed work task prevents us from bogging down the
1449 * whole system waiting for a response from hardware.
1450 */
idpf_init_task(struct work_struct * work)1451 void idpf_init_task(struct work_struct *work)
1452 {
1453 struct idpf_vport_config *vport_config;
1454 struct idpf_vport_max_q max_q;
1455 struct idpf_adapter *adapter;
1456 struct idpf_netdev_priv *np;
1457 struct idpf_vport *vport;
1458 u16 num_default_vports;
1459 struct pci_dev *pdev;
1460 bool default_vport;
1461 int index, err;
1462
1463 adapter = container_of(work, struct idpf_adapter, init_task.work);
1464
1465 num_default_vports = idpf_get_default_vports(adapter);
1466 if (adapter->num_alloc_vports < num_default_vports)
1467 default_vport = true;
1468 else
1469 default_vport = false;
1470
1471 err = idpf_vport_alloc_max_qs(adapter, &max_q);
1472 if (err)
1473 goto unwind_vports;
1474
1475 err = idpf_send_create_vport_msg(adapter, &max_q);
1476 if (err) {
1477 idpf_vport_dealloc_max_qs(adapter, &max_q);
1478 goto unwind_vports;
1479 }
1480
1481 pdev = adapter->pdev;
1482 vport = idpf_vport_alloc(adapter, &max_q);
1483 if (!vport) {
1484 err = -EFAULT;
1485 dev_err(&pdev->dev, "failed to allocate vport: %d\n",
1486 err);
1487 idpf_vport_dealloc_max_qs(adapter, &max_q);
1488 goto unwind_vports;
1489 }
1490
1491 index = vport->idx;
1492 vport_config = adapter->vport_config[index];
1493
1494 init_waitqueue_head(&vport->sw_marker_wq);
1495
1496 spin_lock_init(&vport_config->mac_filter_list_lock);
1497
1498 INIT_LIST_HEAD(&vport_config->user_config.mac_filter_list);
1499
1500 err = idpf_check_supported_desc_ids(vport);
1501 if (err) {
1502 dev_err(&pdev->dev, "failed to get required descriptor ids\n");
1503 goto cfg_netdev_err;
1504 }
1505
1506 if (idpf_cfg_netdev(vport))
1507 goto cfg_netdev_err;
1508
1509 err = idpf_send_get_rx_ptype_msg(vport);
1510 if (err)
1511 goto handle_err;
1512
1513 /* Once state is put into DOWN, driver is ready for dev_open */
1514 np = netdev_priv(vport->netdev);
1515 np->state = __IDPF_VPORT_DOWN;
1516 if (test_and_clear_bit(IDPF_VPORT_UP_REQUESTED, vport_config->flags))
1517 idpf_vport_open(vport);
1518
1519 /* Spawn and return 'idpf_init_task' work queue until all the
1520 * default vports are created
1521 */
1522 if (adapter->num_alloc_vports < num_default_vports) {
1523 queue_delayed_work(adapter->init_wq, &adapter->init_task,
1524 msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
1525
1526 return;
1527 }
1528
1529 for (index = 0; index < adapter->max_vports; index++) {
1530 struct net_device *netdev = adapter->netdevs[index];
1531 struct idpf_vport_config *vport_config;
1532
1533 vport_config = adapter->vport_config[index];
1534
1535 if (!netdev ||
1536 test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags))
1537 continue;
1538
1539 err = register_netdev(netdev);
1540 if (err) {
1541 dev_err(&pdev->dev, "failed to register netdev for vport %d: %pe\n",
1542 index, ERR_PTR(err));
1543 continue;
1544 }
1545 set_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags);
1546 }
1547
1548 /* As all the required vports are created, clear the reset flag
1549 * unconditionally here in case we were in reset and the link was down.
1550 */
1551 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1552 /* Start the statistics task now */
1553 queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
1554 msecs_to_jiffies(10 * (pdev->devfn & 0x07)));
1555
1556 return;
1557
1558 handle_err:
1559 idpf_decfg_netdev(vport);
1560 cfg_netdev_err:
1561 idpf_vport_rel(vport);
1562 adapter->vports[index] = NULL;
1563 unwind_vports:
1564 if (default_vport) {
1565 for (index = 0; index < adapter->max_vports; index++) {
1566 if (adapter->vports[index])
1567 idpf_vport_dealloc(adapter->vports[index]);
1568 }
1569 }
1570 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1571 }
1572
1573 /**
1574 * idpf_sriov_ena - Enable or change number of VFs
1575 * @adapter: private data struct
1576 * @num_vfs: number of VFs to allocate
1577 */
idpf_sriov_ena(struct idpf_adapter * adapter,int num_vfs)1578 static int idpf_sriov_ena(struct idpf_adapter *adapter, int num_vfs)
1579 {
1580 struct device *dev = &adapter->pdev->dev;
1581 int err;
1582
1583 err = idpf_send_set_sriov_vfs_msg(adapter, num_vfs);
1584 if (err) {
1585 dev_err(dev, "Failed to allocate VFs: %d\n", err);
1586
1587 return err;
1588 }
1589
1590 err = pci_enable_sriov(adapter->pdev, num_vfs);
1591 if (err) {
1592 idpf_send_set_sriov_vfs_msg(adapter, 0);
1593 dev_err(dev, "Failed to enable SR-IOV: %d\n", err);
1594
1595 return err;
1596 }
1597
1598 adapter->num_vfs = num_vfs;
1599
1600 return num_vfs;
1601 }
1602
1603 /**
1604 * idpf_sriov_configure - Configure the requested VFs
1605 * @pdev: pointer to a pci_dev structure
1606 * @num_vfs: number of vfs to allocate
1607 *
1608 * Enable or change the number of VFs. Called when the user updates the number
1609 * of VFs in sysfs.
1610 **/
idpf_sriov_configure(struct pci_dev * pdev,int num_vfs)1611 int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs)
1612 {
1613 struct idpf_adapter *adapter = pci_get_drvdata(pdev);
1614
1615 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_SRIOV)) {
1616 dev_info(&pdev->dev, "SR-IOV is not supported on this device\n");
1617
1618 return -EOPNOTSUPP;
1619 }
1620
1621 if (num_vfs)
1622 return idpf_sriov_ena(adapter, num_vfs);
1623
1624 if (pci_vfs_assigned(pdev)) {
1625 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs\n");
1626
1627 return -EBUSY;
1628 }
1629
1630 pci_disable_sriov(adapter->pdev);
1631 idpf_send_set_sriov_vfs_msg(adapter, 0);
1632 adapter->num_vfs = 0;
1633
1634 return 0;
1635 }
1636
1637 /**
1638 * idpf_deinit_task - Device deinit routine
1639 * @adapter: Driver specific private structure
1640 *
1641 * Extended remove logic which will be used for
1642 * hard reset as well
1643 */
idpf_deinit_task(struct idpf_adapter * adapter)1644 void idpf_deinit_task(struct idpf_adapter *adapter)
1645 {
1646 unsigned int i;
1647
1648 /* Wait until the init_task is done else this thread might release
1649 * the resources first and the other thread might end up in a bad state
1650 */
1651 cancel_delayed_work_sync(&adapter->init_task);
1652
1653 if (!adapter->vports)
1654 return;
1655
1656 cancel_delayed_work_sync(&adapter->stats_task);
1657
1658 for (i = 0; i < adapter->max_vports; i++) {
1659 if (adapter->vports[i])
1660 idpf_vport_dealloc(adapter->vports[i]);
1661 }
1662 }
1663
1664 /**
1665 * idpf_check_reset_complete - check that reset is complete
1666 * @hw: pointer to hw struct
1667 * @reset_reg: struct with reset registers
1668 *
1669 * Returns 0 if device is ready to use, or -EBUSY if it's in reset.
1670 **/
idpf_check_reset_complete(struct idpf_hw * hw,struct idpf_reset_reg * reset_reg)1671 static int idpf_check_reset_complete(struct idpf_hw *hw,
1672 struct idpf_reset_reg *reset_reg)
1673 {
1674 struct idpf_adapter *adapter = hw->back;
1675 int i;
1676
1677 for (i = 0; i < 2000; i++) {
1678 u32 reg_val = readl(reset_reg->rstat);
1679
1680 /* 0xFFFFFFFF might be read if other side hasn't cleared the
1681 * register for us yet and 0xFFFFFFFF is not a valid value for
1682 * the register, so treat that as invalid.
1683 */
1684 if (reg_val != 0xFFFFFFFF && (reg_val & reset_reg->rstat_m))
1685 return 0;
1686
1687 usleep_range(5000, 10000);
1688 }
1689
1690 dev_warn(&adapter->pdev->dev, "Device reset timeout!\n");
1691 /* Clear the reset flag unconditionally here since the reset
1692 * technically isn't in progress anymore from the driver's perspective
1693 */
1694 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1695
1696 return -EBUSY;
1697 }
1698
1699 /**
1700 * idpf_set_vport_state - Set the vport state to be after the reset
1701 * @adapter: Driver specific private structure
1702 */
idpf_set_vport_state(struct idpf_adapter * adapter)1703 static void idpf_set_vport_state(struct idpf_adapter *adapter)
1704 {
1705 u16 i;
1706
1707 for (i = 0; i < adapter->max_vports; i++) {
1708 struct idpf_netdev_priv *np;
1709
1710 if (!adapter->netdevs[i])
1711 continue;
1712
1713 np = netdev_priv(adapter->netdevs[i]);
1714 if (np->state == __IDPF_VPORT_UP)
1715 set_bit(IDPF_VPORT_UP_REQUESTED,
1716 adapter->vport_config[i]->flags);
1717 }
1718 }
1719
1720 /**
1721 * idpf_init_hard_reset - Initiate a hardware reset
1722 * @adapter: Driver specific private structure
1723 *
1724 * Deallocate the vports and all the resources associated with them and
1725 * reallocate. Also reinitialize the mailbox. Return 0 on success,
1726 * negative on failure.
1727 */
idpf_init_hard_reset(struct idpf_adapter * adapter)1728 static int idpf_init_hard_reset(struct idpf_adapter *adapter)
1729 {
1730 struct idpf_reg_ops *reg_ops = &adapter->dev_ops.reg_ops;
1731 struct device *dev = &adapter->pdev->dev;
1732 struct net_device *netdev;
1733 int err;
1734 u16 i;
1735
1736 mutex_lock(&adapter->vport_ctrl_lock);
1737
1738 dev_info(dev, "Device HW Reset initiated\n");
1739
1740 /* Avoid TX hangs on reset */
1741 for (i = 0; i < adapter->max_vports; i++) {
1742 netdev = adapter->netdevs[i];
1743 if (!netdev)
1744 continue;
1745
1746 netif_carrier_off(netdev);
1747 netif_tx_disable(netdev);
1748 }
1749
1750 /* Prepare for reset */
1751 if (test_and_clear_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
1752 reg_ops->trigger_reset(adapter, IDPF_HR_DRV_LOAD);
1753 } else if (test_and_clear_bit(IDPF_HR_FUNC_RESET, adapter->flags)) {
1754 bool is_reset = idpf_is_reset_detected(adapter);
1755
1756 idpf_set_vport_state(adapter);
1757 idpf_vc_core_deinit(adapter);
1758 if (!is_reset)
1759 reg_ops->trigger_reset(adapter, IDPF_HR_FUNC_RESET);
1760 idpf_deinit_dflt_mbx(adapter);
1761 } else {
1762 dev_err(dev, "Unhandled hard reset cause\n");
1763 err = -EBADRQC;
1764 goto unlock_mutex;
1765 }
1766
1767 /* Wait for reset to complete */
1768 err = idpf_check_reset_complete(&adapter->hw, &adapter->reset_reg);
1769 if (err) {
1770 dev_err(dev, "The driver was unable to contact the device's firmware. Check that the FW is running. Driver state= 0x%x\n",
1771 adapter->state);
1772 goto unlock_mutex;
1773 }
1774
1775 /* Reset is complete and so start building the driver resources again */
1776 err = idpf_init_dflt_mbx(adapter);
1777 if (err) {
1778 dev_err(dev, "Failed to initialize default mailbox: %d\n", err);
1779 goto unlock_mutex;
1780 }
1781
1782 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
1783
1784 /* Initialize the state machine, also allocate memory and request
1785 * resources
1786 */
1787 err = idpf_vc_core_init(adapter);
1788 if (err) {
1789 cancel_delayed_work_sync(&adapter->mbx_task);
1790 idpf_deinit_dflt_mbx(adapter);
1791 goto unlock_mutex;
1792 }
1793
1794 /* Wait till all the vports are initialized to release the reset lock,
1795 * else user space callbacks may access uninitialized vports
1796 */
1797 while (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
1798 msleep(100);
1799
1800 unlock_mutex:
1801 mutex_unlock(&adapter->vport_ctrl_lock);
1802
1803 return err;
1804 }
1805
1806 /**
1807 * idpf_vc_event_task - Handle virtchannel event logic
1808 * @work: work queue struct
1809 */
idpf_vc_event_task(struct work_struct * work)1810 void idpf_vc_event_task(struct work_struct *work)
1811 {
1812 struct idpf_adapter *adapter;
1813
1814 adapter = container_of(work, struct idpf_adapter, vc_event_task.work);
1815
1816 if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
1817 return;
1818
1819 if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||
1820 test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
1821 set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1822 idpf_init_hard_reset(adapter);
1823 }
1824 }
1825
1826 /**
1827 * idpf_initiate_soft_reset - Initiate a software reset
1828 * @vport: virtual port data struct
1829 * @reset_cause: reason for the soft reset
1830 *
1831 * Soft reset only reallocs vport queue resources. Returns 0 on success,
1832 * negative on failure.
1833 */
idpf_initiate_soft_reset(struct idpf_vport * vport,enum idpf_vport_reset_cause reset_cause)1834 int idpf_initiate_soft_reset(struct idpf_vport *vport,
1835 enum idpf_vport_reset_cause reset_cause)
1836 {
1837 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1838 enum idpf_vport_state current_state = np->state;
1839 struct idpf_adapter *adapter = vport->adapter;
1840 struct idpf_vport *new_vport;
1841 int err;
1842
1843 /* If the system is low on memory, we can end up in bad state if we
1844 * free all the memory for queue resources and try to allocate them
1845 * again. Instead, we can pre-allocate the new resources before doing
1846 * anything and bailing if the alloc fails.
1847 *
1848 * Make a clone of the existing vport to mimic its current
1849 * configuration, then modify the new structure with any requested
1850 * changes. Once the allocation of the new resources is done, stop the
1851 * existing vport and copy the configuration to the main vport. If an
1852 * error occurred, the existing vport will be untouched.
1853 *
1854 */
1855 new_vport = kzalloc(sizeof(*vport), GFP_KERNEL);
1856 if (!new_vport)
1857 return -ENOMEM;
1858
1859 /* This purposely avoids copying the end of the struct because it
1860 * contains wait_queues and mutexes and other stuff we don't want to
1861 * mess with. Nothing below should use those variables from new_vport
1862 * and should instead always refer to them in vport if they need to.
1863 */
1864 memcpy(new_vport, vport, offsetof(struct idpf_vport, link_up));
1865
1866 /* Adjust resource parameters prior to reallocating resources */
1867 switch (reset_cause) {
1868 case IDPF_SR_Q_CHANGE:
1869 err = idpf_vport_adjust_qs(new_vport);
1870 if (err)
1871 goto free_vport;
1872 break;
1873 case IDPF_SR_Q_DESC_CHANGE:
1874 /* Update queue parameters before allocating resources */
1875 idpf_vport_calc_num_q_desc(new_vport);
1876 break;
1877 case IDPF_SR_MTU_CHANGE:
1878 case IDPF_SR_RSC_CHANGE:
1879 break;
1880 default:
1881 dev_err(&adapter->pdev->dev, "Unhandled soft reset cause\n");
1882 err = -EINVAL;
1883 goto free_vport;
1884 }
1885
1886 if (current_state <= __IDPF_VPORT_DOWN) {
1887 idpf_send_delete_queues_msg(vport);
1888 } else {
1889 set_bit(IDPF_VPORT_DEL_QUEUES, vport->flags);
1890 idpf_vport_stop(vport);
1891 }
1892
1893 idpf_deinit_rss(vport);
1894 /* We're passing in vport here because we need its wait_queue
1895 * to send a message and it should be getting all the vport
1896 * config data out of the adapter but we need to be careful not
1897 * to add code to add_queues to change the vport config within
1898 * vport itself as it will be wiped with a memcpy later.
1899 */
1900 err = idpf_send_add_queues_msg(vport, new_vport->num_txq,
1901 new_vport->num_complq,
1902 new_vport->num_rxq,
1903 new_vport->num_bufq);
1904 if (err)
1905 goto err_reset;
1906
1907 /* Same comment as above regarding avoiding copying the wait_queues and
1908 * mutexes applies here. We do not want to mess with those if possible.
1909 */
1910 memcpy(vport, new_vport, offsetof(struct idpf_vport, link_up));
1911
1912 if (reset_cause == IDPF_SR_Q_CHANGE)
1913 idpf_vport_alloc_vec_indexes(vport);
1914
1915 err = idpf_set_real_num_queues(vport);
1916 if (err)
1917 goto err_open;
1918
1919 if (current_state == __IDPF_VPORT_UP)
1920 err = idpf_vport_open(vport);
1921
1922 kfree(new_vport);
1923
1924 return err;
1925
1926 err_reset:
1927 idpf_send_add_queues_msg(vport, vport->num_txq, vport->num_complq,
1928 vport->num_rxq, vport->num_bufq);
1929
1930 err_open:
1931 if (current_state == __IDPF_VPORT_UP)
1932 idpf_vport_open(vport);
1933
1934 free_vport:
1935 kfree(new_vport);
1936
1937 return err;
1938 }
1939
1940 /**
1941 * idpf_addr_sync - Callback for dev_(mc|uc)_sync to add address
1942 * @netdev: the netdevice
1943 * @addr: address to add
1944 *
1945 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
1946 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
1947 * meaning we cannot sleep in this context. Due to this, we have to add the
1948 * filter and send the virtchnl message asynchronously without waiting for the
1949 * response from the other side. We won't know whether or not the operation
1950 * actually succeeded until we get the message back. Returns 0 on success,
1951 * negative on failure.
1952 */
idpf_addr_sync(struct net_device * netdev,const u8 * addr)1953 static int idpf_addr_sync(struct net_device *netdev, const u8 *addr)
1954 {
1955 struct idpf_netdev_priv *np = netdev_priv(netdev);
1956
1957 return idpf_add_mac_filter(np->vport, np, addr, true);
1958 }
1959
1960 /**
1961 * idpf_addr_unsync - Callback for dev_(mc|uc)_sync to remove address
1962 * @netdev: the netdevice
1963 * @addr: address to add
1964 *
1965 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
1966 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
1967 * meaning we cannot sleep in this context. Due to this we have to delete the
1968 * filter and send the virtchnl message asynchronously without waiting for the
1969 * return from the other side. We won't know whether or not the operation
1970 * actually succeeded until we get the message back. Returns 0 on success,
1971 * negative on failure.
1972 */
idpf_addr_unsync(struct net_device * netdev,const u8 * addr)1973 static int idpf_addr_unsync(struct net_device *netdev, const u8 *addr)
1974 {
1975 struct idpf_netdev_priv *np = netdev_priv(netdev);
1976
1977 /* Under some circumstances, we might receive a request to delete
1978 * our own device address from our uc list. Because we store the
1979 * device address in the VSI's MAC filter list, we need to ignore
1980 * such requests and not delete our device address from this list.
1981 */
1982 if (ether_addr_equal(addr, netdev->dev_addr))
1983 return 0;
1984
1985 idpf_del_mac_filter(np->vport, np, addr, true);
1986
1987 return 0;
1988 }
1989
1990 /**
1991 * idpf_set_rx_mode - NDO callback to set the netdev filters
1992 * @netdev: network interface device structure
1993 *
1994 * Stack takes addr_list_lock spinlock before calling our .set_rx_mode. We
1995 * cannot sleep in this context.
1996 */
idpf_set_rx_mode(struct net_device * netdev)1997 static void idpf_set_rx_mode(struct net_device *netdev)
1998 {
1999 struct idpf_netdev_priv *np = netdev_priv(netdev);
2000 struct idpf_vport_user_config_data *config_data;
2001 struct idpf_adapter *adapter;
2002 bool changed = false;
2003 struct device *dev;
2004 int err;
2005
2006 adapter = np->adapter;
2007 dev = &adapter->pdev->dev;
2008
2009 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER)) {
2010 __dev_uc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
2011 __dev_mc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
2012 }
2013
2014 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_PROMISC))
2015 return;
2016
2017 config_data = &adapter->vport_config[np->vport_idx]->user_config;
2018 /* IFF_PROMISC enables both unicast and multicast promiscuous,
2019 * while IFF_ALLMULTI only enables multicast such that:
2020 *
2021 * promisc + allmulti = unicast | multicast
2022 * promisc + !allmulti = unicast | multicast
2023 * !promisc + allmulti = multicast
2024 */
2025 if ((netdev->flags & IFF_PROMISC) &&
2026 !test_and_set_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
2027 changed = true;
2028 dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");
2029 if (!test_and_set_bit(__IDPF_PROMISC_MC, adapter->flags))
2030 dev_info(dev, "Entering multicast promiscuous mode\n");
2031 }
2032
2033 if (!(netdev->flags & IFF_PROMISC) &&
2034 test_and_clear_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
2035 changed = true;
2036 dev_info(dev, "Leaving promiscuous mode\n");
2037 }
2038
2039 if (netdev->flags & IFF_ALLMULTI &&
2040 !test_and_set_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
2041 changed = true;
2042 dev_info(dev, "Entering multicast promiscuous mode\n");
2043 }
2044
2045 if (!(netdev->flags & (IFF_ALLMULTI | IFF_PROMISC)) &&
2046 test_and_clear_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
2047 changed = true;
2048 dev_info(dev, "Leaving multicast promiscuous mode\n");
2049 }
2050
2051 if (!changed)
2052 return;
2053
2054 err = idpf_set_promiscuous(adapter, config_data, np->vport_id);
2055 if (err)
2056 dev_err(dev, "Failed to set promiscuous mode: %d\n", err);
2057 }
2058
2059 /**
2060 * idpf_vport_manage_rss_lut - disable/enable RSS
2061 * @vport: the vport being changed
2062 *
2063 * In the event of disable request for RSS, this function will zero out RSS
2064 * LUT, while in the event of enable request for RSS, it will reconfigure RSS
2065 * LUT with the default LUT configuration.
2066 */
idpf_vport_manage_rss_lut(struct idpf_vport * vport)2067 static int idpf_vport_manage_rss_lut(struct idpf_vport *vport)
2068 {
2069 bool ena = idpf_is_feature_ena(vport, NETIF_F_RXHASH);
2070 struct idpf_rss_data *rss_data;
2071 u16 idx = vport->idx;
2072 int lut_size;
2073
2074 rss_data = &vport->adapter->vport_config[idx]->user_config.rss_data;
2075 lut_size = rss_data->rss_lut_size * sizeof(u32);
2076
2077 if (ena) {
2078 /* This will contain the default or user configured LUT */
2079 memcpy(rss_data->rss_lut, rss_data->cached_lut, lut_size);
2080 } else {
2081 /* Save a copy of the current LUT to be restored later if
2082 * requested.
2083 */
2084 memcpy(rss_data->cached_lut, rss_data->rss_lut, lut_size);
2085
2086 /* Zero out the current LUT to disable */
2087 memset(rss_data->rss_lut, 0, lut_size);
2088 }
2089
2090 return idpf_config_rss(vport);
2091 }
2092
2093 /**
2094 * idpf_set_features - set the netdev feature flags
2095 * @netdev: ptr to the netdev being adjusted
2096 * @features: the feature set that the stack is suggesting
2097 */
idpf_set_features(struct net_device * netdev,netdev_features_t features)2098 static int idpf_set_features(struct net_device *netdev,
2099 netdev_features_t features)
2100 {
2101 netdev_features_t changed = netdev->features ^ features;
2102 struct idpf_adapter *adapter;
2103 struct idpf_vport *vport;
2104 int err = 0;
2105
2106 idpf_vport_ctrl_lock(netdev);
2107 vport = idpf_netdev_to_vport(netdev);
2108
2109 adapter = vport->adapter;
2110
2111 if (idpf_is_reset_in_prog(adapter)) {
2112 dev_err(&adapter->pdev->dev, "Device is resetting, changing netdev features temporarily unavailable.\n");
2113 err = -EBUSY;
2114 goto unlock_mutex;
2115 }
2116
2117 if (changed & NETIF_F_RXHASH) {
2118 netdev->features ^= NETIF_F_RXHASH;
2119 err = idpf_vport_manage_rss_lut(vport);
2120 if (err)
2121 goto unlock_mutex;
2122 }
2123
2124 if (changed & NETIF_F_GRO_HW) {
2125 netdev->features ^= NETIF_F_GRO_HW;
2126 err = idpf_initiate_soft_reset(vport, IDPF_SR_RSC_CHANGE);
2127 if (err)
2128 goto unlock_mutex;
2129 }
2130
2131 if (changed & NETIF_F_LOOPBACK) {
2132 netdev->features ^= NETIF_F_LOOPBACK;
2133 err = idpf_send_ena_dis_loopback_msg(vport);
2134 }
2135
2136 unlock_mutex:
2137 idpf_vport_ctrl_unlock(netdev);
2138
2139 return err;
2140 }
2141
2142 /**
2143 * idpf_open - Called when a network interface becomes active
2144 * @netdev: network interface device structure
2145 *
2146 * The open entry point is called when a network interface is made
2147 * active by the system (IFF_UP). At this point all resources needed
2148 * for transmit and receive operations are allocated, the interrupt
2149 * handler is registered with the OS, the netdev watchdog is enabled,
2150 * and the stack is notified that the interface is ready.
2151 *
2152 * Returns 0 on success, negative value on failure
2153 */
idpf_open(struct net_device * netdev)2154 static int idpf_open(struct net_device *netdev)
2155 {
2156 struct idpf_vport *vport;
2157 int err;
2158
2159 idpf_vport_ctrl_lock(netdev);
2160 vport = idpf_netdev_to_vport(netdev);
2161
2162 err = idpf_set_real_num_queues(vport);
2163 if (err)
2164 goto unlock;
2165
2166 err = idpf_vport_open(vport);
2167
2168 unlock:
2169 idpf_vport_ctrl_unlock(netdev);
2170
2171 return err;
2172 }
2173
2174 /**
2175 * idpf_change_mtu - NDO callback to change the MTU
2176 * @netdev: network interface device structure
2177 * @new_mtu: new value for maximum frame size
2178 *
2179 * Returns 0 on success, negative on failure
2180 */
idpf_change_mtu(struct net_device * netdev,int new_mtu)2181 static int idpf_change_mtu(struct net_device *netdev, int new_mtu)
2182 {
2183 struct idpf_vport *vport;
2184 int err;
2185
2186 idpf_vport_ctrl_lock(netdev);
2187 vport = idpf_netdev_to_vport(netdev);
2188
2189 WRITE_ONCE(netdev->mtu, new_mtu);
2190
2191 err = idpf_initiate_soft_reset(vport, IDPF_SR_MTU_CHANGE);
2192
2193 idpf_vport_ctrl_unlock(netdev);
2194
2195 return err;
2196 }
2197
2198 /**
2199 * idpf_features_check - Validate packet conforms to limits
2200 * @skb: skb buffer
2201 * @netdev: This port's netdev
2202 * @features: Offload features that the stack believes apply
2203 */
idpf_features_check(struct sk_buff * skb,struct net_device * netdev,netdev_features_t features)2204 static netdev_features_t idpf_features_check(struct sk_buff *skb,
2205 struct net_device *netdev,
2206 netdev_features_t features)
2207 {
2208 struct idpf_netdev_priv *np = netdev_priv(netdev);
2209 u16 max_tx_hdr_size = np->max_tx_hdr_size;
2210 size_t len;
2211
2212 /* No point in doing any of this if neither checksum nor GSO are
2213 * being requested for this frame. We can rule out both by just
2214 * checking for CHECKSUM_PARTIAL
2215 */
2216 if (skb->ip_summed != CHECKSUM_PARTIAL)
2217 return features;
2218
2219 /* We cannot support GSO if the MSS is going to be less than
2220 * 88 bytes. If it is then we need to drop support for GSO.
2221 */
2222 if (skb_is_gso(skb) &&
2223 (skb_shinfo(skb)->gso_size < IDPF_TX_TSO_MIN_MSS))
2224 features &= ~NETIF_F_GSO_MASK;
2225
2226 /* Ensure MACLEN is <= 126 bytes (63 words) and not an odd size */
2227 len = skb_network_offset(skb);
2228 if (unlikely(len & ~(126)))
2229 goto unsupported;
2230
2231 len = skb_network_header_len(skb);
2232 if (unlikely(len > max_tx_hdr_size))
2233 goto unsupported;
2234
2235 if (!skb->encapsulation)
2236 return features;
2237
2238 /* L4TUNLEN can support 127 words */
2239 len = skb_inner_network_header(skb) - skb_transport_header(skb);
2240 if (unlikely(len & ~(127 * 2)))
2241 goto unsupported;
2242
2243 /* IPLEN can support at most 127 dwords */
2244 len = skb_inner_network_header_len(skb);
2245 if (unlikely(len > max_tx_hdr_size))
2246 goto unsupported;
2247
2248 /* No need to validate L4LEN as TCP is the only protocol with a
2249 * a flexible value and we support all possible values supported
2250 * by TCP, which is at most 15 dwords
2251 */
2252
2253 return features;
2254
2255 unsupported:
2256 return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
2257 }
2258
2259 /**
2260 * idpf_set_mac - NDO callback to set port mac address
2261 * @netdev: network interface device structure
2262 * @p: pointer to an address structure
2263 *
2264 * Returns 0 on success, negative on failure
2265 **/
idpf_set_mac(struct net_device * netdev,void * p)2266 static int idpf_set_mac(struct net_device *netdev, void *p)
2267 {
2268 struct idpf_netdev_priv *np = netdev_priv(netdev);
2269 struct idpf_vport_config *vport_config;
2270 struct sockaddr *addr = p;
2271 struct idpf_vport *vport;
2272 int err = 0;
2273
2274 idpf_vport_ctrl_lock(netdev);
2275 vport = idpf_netdev_to_vport(netdev);
2276
2277 if (!idpf_is_cap_ena(vport->adapter, IDPF_OTHER_CAPS,
2278 VIRTCHNL2_CAP_MACFILTER)) {
2279 dev_info(&vport->adapter->pdev->dev, "Setting MAC address is not supported\n");
2280 err = -EOPNOTSUPP;
2281 goto unlock_mutex;
2282 }
2283
2284 if (!is_valid_ether_addr(addr->sa_data)) {
2285 dev_info(&vport->adapter->pdev->dev, "Invalid MAC address: %pM\n",
2286 addr->sa_data);
2287 err = -EADDRNOTAVAIL;
2288 goto unlock_mutex;
2289 }
2290
2291 if (ether_addr_equal(netdev->dev_addr, addr->sa_data))
2292 goto unlock_mutex;
2293
2294 vport_config = vport->adapter->vport_config[vport->idx];
2295 err = idpf_add_mac_filter(vport, np, addr->sa_data, false);
2296 if (err) {
2297 __idpf_del_mac_filter(vport_config, addr->sa_data);
2298 goto unlock_mutex;
2299 }
2300
2301 if (is_valid_ether_addr(vport->default_mac_addr))
2302 idpf_del_mac_filter(vport, np, vport->default_mac_addr, false);
2303
2304 ether_addr_copy(vport->default_mac_addr, addr->sa_data);
2305 eth_hw_addr_set(netdev, addr->sa_data);
2306
2307 unlock_mutex:
2308 idpf_vport_ctrl_unlock(netdev);
2309
2310 return err;
2311 }
2312
2313 /**
2314 * idpf_alloc_dma_mem - Allocate dma memory
2315 * @hw: pointer to hw struct
2316 * @mem: pointer to dma_mem struct
2317 * @size: size of the memory to allocate
2318 */
idpf_alloc_dma_mem(struct idpf_hw * hw,struct idpf_dma_mem * mem,u64 size)2319 void *idpf_alloc_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem, u64 size)
2320 {
2321 struct idpf_adapter *adapter = hw->back;
2322 size_t sz = ALIGN(size, 4096);
2323
2324 mem->va = dma_alloc_coherent(&adapter->pdev->dev, sz,
2325 &mem->pa, GFP_KERNEL);
2326 mem->size = sz;
2327
2328 return mem->va;
2329 }
2330
2331 /**
2332 * idpf_free_dma_mem - Free the allocated dma memory
2333 * @hw: pointer to hw struct
2334 * @mem: pointer to dma_mem struct
2335 */
idpf_free_dma_mem(struct idpf_hw * hw,struct idpf_dma_mem * mem)2336 void idpf_free_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem)
2337 {
2338 struct idpf_adapter *adapter = hw->back;
2339
2340 dma_free_coherent(&adapter->pdev->dev, mem->size,
2341 mem->va, mem->pa);
2342 mem->size = 0;
2343 mem->va = NULL;
2344 mem->pa = 0;
2345 }
2346
2347 static const struct net_device_ops idpf_netdev_ops = {
2348 .ndo_open = idpf_open,
2349 .ndo_stop = idpf_stop,
2350 .ndo_start_xmit = idpf_tx_start,
2351 .ndo_features_check = idpf_features_check,
2352 .ndo_set_rx_mode = idpf_set_rx_mode,
2353 .ndo_validate_addr = eth_validate_addr,
2354 .ndo_set_mac_address = idpf_set_mac,
2355 .ndo_change_mtu = idpf_change_mtu,
2356 .ndo_get_stats64 = idpf_get_stats64,
2357 .ndo_set_features = idpf_set_features,
2358 .ndo_tx_timeout = idpf_tx_timeout,
2359 };
2360