Loading...
1/* SPDX-License-Identifier: GPL-2.0-only */
2/* Copyright (C) 2023 Intel Corporation */
3
4#ifndef _IDPF_H_
5#define _IDPF_H_
6
7/* Forward declaration */
8struct idpf_adapter;
9struct idpf_vport;
10struct idpf_vport_max_q;
11
12#include <net/pkt_sched.h>
13#include <linux/aer.h>
14#include <linux/etherdevice.h>
15#include <linux/pci.h>
16#include <linux/bitfield.h>
17#include <linux/sctp.h>
18#include <linux/ethtool_netlink.h>
19#include <net/gro.h>
20#include <linux/dim.h>
21
22#include "virtchnl2.h"
23#include "idpf_lan_txrx.h"
24#include "idpf_txrx.h"
25#include "idpf_controlq.h"
26
27#define GETMAXVAL(num_bits) GENMASK((num_bits) - 1, 0)
28
29#define IDPF_NO_FREE_SLOT 0xffff
30
31/* Default Mailbox settings */
32#define IDPF_NUM_FILTERS_PER_MSG 20
33#define IDPF_NUM_DFLT_MBX_Q 2 /* includes both TX and RX */
34#define IDPF_DFLT_MBX_Q_LEN 64
35#define IDPF_DFLT_MBX_ID -1
36/* maximum number of times to try before resetting mailbox */
37#define IDPF_MB_MAX_ERR 20
38#define IDPF_NUM_CHUNKS_PER_MSG(struct_sz, chunk_sz) \
39 ((IDPF_CTLQ_MAX_BUF_LEN - (struct_sz)) / (chunk_sz))
40
41#define IDPF_MAX_WAIT 500
42
43/* available message levels */
44#define IDPF_AVAIL_NETIF_M (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
45
46#define IDPF_DIM_PROFILE_SLOTS 5
47
48#define IDPF_VIRTCHNL_VERSION_MAJOR VIRTCHNL2_VERSION_MAJOR_2
49#define IDPF_VIRTCHNL_VERSION_MINOR VIRTCHNL2_VERSION_MINOR_0
50
51/**
52 * struct idpf_mac_filter
53 * @list: list member field
54 * @macaddr: MAC address
55 * @remove: filter should be removed (virtchnl)
56 * @add: filter should be added (virtchnl)
57 */
58struct idpf_mac_filter {
59 struct list_head list;
60 u8 macaddr[ETH_ALEN];
61 bool remove;
62 bool add;
63};
64
65/**
66 * enum idpf_state - State machine to handle bring up
67 * @__IDPF_VER_CHECK: Negotiate virtchnl version
68 * @__IDPF_GET_CAPS: Negotiate capabilities
69 * @__IDPF_INIT_SW: Init based on given capabilities
70 * @__IDPF_STATE_LAST: Must be last, used to determine size
71 */
72enum idpf_state {
73 __IDPF_VER_CHECK,
74 __IDPF_GET_CAPS,
75 __IDPF_INIT_SW,
76 __IDPF_STATE_LAST,
77};
78
79/**
80 * enum idpf_flags - Hard reset causes.
81 * @IDPF_HR_FUNC_RESET: Hard reset when TxRx timeout
82 * @IDPF_HR_DRV_LOAD: Set on driver load for a clean HW
83 * @IDPF_HR_RESET_IN_PROG: Reset in progress
84 * @IDPF_REMOVE_IN_PROG: Driver remove in progress
85 * @IDPF_MB_INTR_MODE: Mailbox in interrupt mode
86 * @IDPF_VC_CORE_INIT: virtchnl core has been init
87 * @IDPF_FLAGS_NBITS: Must be last
88 */
89enum idpf_flags {
90 IDPF_HR_FUNC_RESET,
91 IDPF_HR_DRV_LOAD,
92 IDPF_HR_RESET_IN_PROG,
93 IDPF_REMOVE_IN_PROG,
94 IDPF_MB_INTR_MODE,
95 IDPF_VC_CORE_INIT,
96 IDPF_FLAGS_NBITS,
97};
98
99/**
100 * enum idpf_cap_field - Offsets into capabilities struct for specific caps
101 * @IDPF_BASE_CAPS: generic base capabilities
102 * @IDPF_CSUM_CAPS: checksum offload capabilities
103 * @IDPF_SEG_CAPS: segmentation offload capabilities
104 * @IDPF_RSS_CAPS: RSS offload capabilities
105 * @IDPF_HSPLIT_CAPS: Header split capabilities
106 * @IDPF_RSC_CAPS: RSC offload capabilities
107 * @IDPF_OTHER_CAPS: miscellaneous offloads
108 *
109 * Used when checking for a specific capability flag since different capability
110 * sets are not mutually exclusive numerically, the caller must specify which
111 * type of capability they are checking for.
112 */
113enum idpf_cap_field {
114 IDPF_BASE_CAPS = -1,
115 IDPF_CSUM_CAPS = offsetof(struct virtchnl2_get_capabilities,
116 csum_caps),
117 IDPF_SEG_CAPS = offsetof(struct virtchnl2_get_capabilities,
118 seg_caps),
119 IDPF_RSS_CAPS = offsetof(struct virtchnl2_get_capabilities,
120 rss_caps),
121 IDPF_HSPLIT_CAPS = offsetof(struct virtchnl2_get_capabilities,
122 hsplit_caps),
123 IDPF_RSC_CAPS = offsetof(struct virtchnl2_get_capabilities,
124 rsc_caps),
125 IDPF_OTHER_CAPS = offsetof(struct virtchnl2_get_capabilities,
126 other_caps),
127};
128
129/**
130 * enum idpf_vport_state - Current vport state
131 * @__IDPF_VPORT_DOWN: Vport is down
132 * @__IDPF_VPORT_UP: Vport is up
133 * @__IDPF_VPORT_STATE_LAST: Must be last, number of states
134 */
135enum idpf_vport_state {
136 __IDPF_VPORT_DOWN,
137 __IDPF_VPORT_UP,
138 __IDPF_VPORT_STATE_LAST,
139};
140
141/**
142 * struct idpf_netdev_priv - Struct to store vport back pointer
143 * @adapter: Adapter back pointer
144 * @vport: Vport back pointer
145 * @vport_id: Vport identifier
146 * @vport_idx: Relative vport index
147 * @state: See enum idpf_vport_state
148 * @netstats: Packet and byte stats
149 * @stats_lock: Lock to protect stats update
150 */
151struct idpf_netdev_priv {
152 struct idpf_adapter *adapter;
153 struct idpf_vport *vport;
154 u32 vport_id;
155 u16 vport_idx;
156 enum idpf_vport_state state;
157 struct rtnl_link_stats64 netstats;
158 spinlock_t stats_lock;
159};
160
161/**
162 * struct idpf_reset_reg - Reset register offsets/masks
163 * @rstat: Reset status register
164 * @rstat_m: Reset status mask
165 */
166struct idpf_reset_reg {
167 void __iomem *rstat;
168 u32 rstat_m;
169};
170
171/**
172 * struct idpf_vport_max_q - Queue limits
173 * @max_rxq: Maximum number of RX queues supported
174 * @max_txq: Maixmum number of TX queues supported
175 * @max_bufq: In splitq, maximum number of buffer queues supported
176 * @max_complq: In splitq, maximum number of completion queues supported
177 */
178struct idpf_vport_max_q {
179 u16 max_rxq;
180 u16 max_txq;
181 u16 max_bufq;
182 u16 max_complq;
183};
184
185/**
186 * struct idpf_reg_ops - Device specific register operation function pointers
187 * @ctlq_reg_init: Mailbox control queue register initialization
188 * @intr_reg_init: Traffic interrupt register initialization
189 * @mb_intr_reg_init: Mailbox interrupt register initialization
190 * @reset_reg_init: Reset register initialization
191 * @trigger_reset: Trigger a reset to occur
192 */
193struct idpf_reg_ops {
194 void (*ctlq_reg_init)(struct idpf_ctlq_create_info *cq);
195 int (*intr_reg_init)(struct idpf_vport *vport);
196 void (*mb_intr_reg_init)(struct idpf_adapter *adapter);
197 void (*reset_reg_init)(struct idpf_adapter *adapter);
198 void (*trigger_reset)(struct idpf_adapter *adapter,
199 enum idpf_flags trig_cause);
200};
201
202/**
203 * struct idpf_dev_ops - Device specific operations
204 * @reg_ops: Register operations
205 */
206struct idpf_dev_ops {
207 struct idpf_reg_ops reg_ops;
208};
209
210/**
211 * enum idpf_vport_reset_cause - Vport soft reset causes
212 * @IDPF_SR_Q_CHANGE: Soft reset queue change
213 * @IDPF_SR_Q_DESC_CHANGE: Soft reset descriptor change
214 * @IDPF_SR_MTU_CHANGE: Soft reset MTU change
215 * @IDPF_SR_RSC_CHANGE: Soft reset RSC change
216 */
217enum idpf_vport_reset_cause {
218 IDPF_SR_Q_CHANGE,
219 IDPF_SR_Q_DESC_CHANGE,
220 IDPF_SR_MTU_CHANGE,
221 IDPF_SR_RSC_CHANGE,
222};
223
224/**
225 * enum idpf_vport_flags - Vport flags
226 * @IDPF_VPORT_DEL_QUEUES: To send delete queues message
227 * @IDPF_VPORT_SW_MARKER: Indicate TX pipe drain software marker packets
228 * processing is done
229 * @IDPF_VPORT_FLAGS_NBITS: Must be last
230 */
231enum idpf_vport_flags {
232 IDPF_VPORT_DEL_QUEUES,
233 IDPF_VPORT_SW_MARKER,
234 IDPF_VPORT_FLAGS_NBITS,
235};
236
237struct idpf_port_stats {
238 struct u64_stats_sync stats_sync;
239 u64_stats_t rx_hw_csum_err;
240 u64_stats_t rx_hsplit;
241 u64_stats_t rx_hsplit_hbo;
242 u64_stats_t rx_bad_descs;
243 u64_stats_t tx_linearize;
244 u64_stats_t tx_busy;
245 u64_stats_t tx_drops;
246 u64_stats_t tx_dma_map_errs;
247 struct virtchnl2_vport_stats vport_stats;
248};
249
250/**
251 * struct idpf_vport - Handle for netdevices and queue resources
252 * @num_txq: Number of allocated TX queues
253 * @num_complq: Number of allocated completion queues
254 * @txq_desc_count: TX queue descriptor count
255 * @complq_desc_count: Completion queue descriptor count
256 * @compln_clean_budget: Work budget for completion clean
257 * @num_txq_grp: Number of TX queue groups
258 * @txq_grps: Array of TX queue groups
259 * @txq_model: Split queue or single queue queuing model
260 * @txqs: Used only in hotpath to get to the right queue very fast
261 * @crc_enable: Enable CRC insertion offload
262 * @num_rxq: Number of allocated RX queues
263 * @num_bufq: Number of allocated buffer queues
264 * @rxq_desc_count: RX queue descriptor count. *MUST* have enough descriptors
265 * to complete all buffer descriptors for all buffer queues in
266 * the worst case.
267 * @num_bufqs_per_qgrp: Buffer queues per RX queue in a given grouping
268 * @bufq_desc_count: Buffer queue descriptor count
269 * @bufq_size: Size of buffers in ring (e.g. 2K, 4K, etc)
270 * @num_rxq_grp: Number of RX queues in a group
271 * @rxq_grps: Total number of RX groups. Number of groups * number of RX per
272 * group will yield total number of RX queues.
273 * @rxq_model: Splitq queue or single queue queuing model
274 * @rx_ptype_lkup: Lookup table for ptypes on RX
275 * @adapter: back pointer to associated adapter
276 * @netdev: Associated net_device. Each vport should have one and only one
277 * associated netdev.
278 * @flags: See enum idpf_vport_flags
279 * @vport_type: Default SRIOV, SIOV, etc.
280 * @vport_id: Device given vport identifier
281 * @idx: Software index in adapter vports struct
282 * @default_vport: Use this vport if one isn't specified
283 * @base_rxd: True if the driver should use base descriptors instead of flex
284 * @num_q_vectors: Number of IRQ vectors allocated
285 * @q_vectors: Array of queue vectors
286 * @q_vector_idxs: Starting index of queue vectors
287 * @max_mtu: device given max possible MTU
288 * @default_mac_addr: device will give a default MAC to use
289 * @rx_itr_profile: RX profiles for Dynamic Interrupt Moderation
290 * @tx_itr_profile: TX profiles for Dynamic Interrupt Moderation
291 * @port_stats: per port csum, header split, and other offload stats
292 * @link_up: True if link is up
293 * @link_speed_mbps: Link speed in mbps
294 * @sw_marker_wq: workqueue for marker packets
295 */
296struct idpf_vport {
297 u16 num_txq;
298 u16 num_complq;
299 u32 txq_desc_count;
300 u32 complq_desc_count;
301 u32 compln_clean_budget;
302 u16 num_txq_grp;
303 struct idpf_txq_group *txq_grps;
304 u32 txq_model;
305 struct idpf_queue **txqs;
306 bool crc_enable;
307
308 u16 num_rxq;
309 u16 num_bufq;
310 u32 rxq_desc_count;
311 u8 num_bufqs_per_qgrp;
312 u32 bufq_desc_count[IDPF_MAX_BUFQS_PER_RXQ_GRP];
313 u32 bufq_size[IDPF_MAX_BUFQS_PER_RXQ_GRP];
314 u16 num_rxq_grp;
315 struct idpf_rxq_group *rxq_grps;
316 u32 rxq_model;
317 struct idpf_rx_ptype_decoded rx_ptype_lkup[IDPF_RX_MAX_PTYPE];
318
319 struct idpf_adapter *adapter;
320 struct net_device *netdev;
321 DECLARE_BITMAP(flags, IDPF_VPORT_FLAGS_NBITS);
322 u16 vport_type;
323 u32 vport_id;
324 u16 idx;
325 bool default_vport;
326 bool base_rxd;
327
328 u16 num_q_vectors;
329 struct idpf_q_vector *q_vectors;
330 u16 *q_vector_idxs;
331 u16 max_mtu;
332 u8 default_mac_addr[ETH_ALEN];
333 u16 rx_itr_profile[IDPF_DIM_PROFILE_SLOTS];
334 u16 tx_itr_profile[IDPF_DIM_PROFILE_SLOTS];
335 struct idpf_port_stats port_stats;
336
337 bool link_up;
338 u32 link_speed_mbps;
339
340 wait_queue_head_t sw_marker_wq;
341};
342
343/**
344 * enum idpf_user_flags
345 * @__IDPF_USER_FLAG_HSPLIT: header split state
346 * @__IDPF_PROMISC_UC: Unicast promiscuous mode
347 * @__IDPF_PROMISC_MC: Multicast promiscuous mode
348 * @__IDPF_USER_FLAGS_NBITS: Must be last
349 */
350enum idpf_user_flags {
351 __IDPF_USER_FLAG_HSPLIT = 0U,
352 __IDPF_PROMISC_UC = 32,
353 __IDPF_PROMISC_MC,
354
355 __IDPF_USER_FLAGS_NBITS,
356};
357
358/**
359 * struct idpf_rss_data - Associated RSS data
360 * @rss_key_size: Size of RSS hash key
361 * @rss_key: RSS hash key
362 * @rss_lut_size: Size of RSS lookup table
363 * @rss_lut: RSS lookup table
364 * @cached_lut: Used to restore previously init RSS lut
365 */
366struct idpf_rss_data {
367 u16 rss_key_size;
368 u8 *rss_key;
369 u16 rss_lut_size;
370 u32 *rss_lut;
371 u32 *cached_lut;
372};
373
374/**
375 * struct idpf_vport_user_config_data - User defined configuration values for
376 * each vport.
377 * @rss_data: See struct idpf_rss_data
378 * @num_req_tx_qs: Number of user requested TX queues through ethtool
379 * @num_req_rx_qs: Number of user requested RX queues through ethtool
380 * @num_req_txq_desc: Number of user requested TX queue descriptors through
381 * ethtool
382 * @num_req_rxq_desc: Number of user requested RX queue descriptors through
383 * ethtool
384 * @user_flags: User toggled config flags
385 * @mac_filter_list: List of MAC filters
386 *
387 * Used to restore configuration after a reset as the vport will get wiped.
388 */
389struct idpf_vport_user_config_data {
390 struct idpf_rss_data rss_data;
391 u16 num_req_tx_qs;
392 u16 num_req_rx_qs;
393 u32 num_req_txq_desc;
394 u32 num_req_rxq_desc;
395 DECLARE_BITMAP(user_flags, __IDPF_USER_FLAGS_NBITS);
396 struct list_head mac_filter_list;
397};
398
399/**
400 * enum idpf_vport_config_flags - Vport config flags
401 * @IDPF_VPORT_REG_NETDEV: Register netdev
402 * @IDPF_VPORT_UP_REQUESTED: Set if interface up is requested on core reset
403 * @IDPF_VPORT_CONFIG_FLAGS_NBITS: Must be last
404 */
405enum idpf_vport_config_flags {
406 IDPF_VPORT_REG_NETDEV,
407 IDPF_VPORT_UP_REQUESTED,
408 IDPF_VPORT_CONFIG_FLAGS_NBITS,
409};
410
411/**
412 * struct idpf_avail_queue_info
413 * @avail_rxq: Available RX queues
414 * @avail_txq: Available TX queues
415 * @avail_bufq: Available buffer queues
416 * @avail_complq: Available completion queues
417 *
418 * Maintain total queues available after allocating max queues to each vport.
419 */
420struct idpf_avail_queue_info {
421 u16 avail_rxq;
422 u16 avail_txq;
423 u16 avail_bufq;
424 u16 avail_complq;
425};
426
427/**
428 * struct idpf_vector_info - Utility structure to pass function arguments as a
429 * structure
430 * @num_req_vecs: Vectors required based on the number of queues updated by the
431 * user via ethtool
432 * @num_curr_vecs: Current number of vectors, must be >= @num_req_vecs
433 * @index: Relative starting index for vectors
434 * @default_vport: Vectors are for default vport
435 */
436struct idpf_vector_info {
437 u16 num_req_vecs;
438 u16 num_curr_vecs;
439 u16 index;
440 bool default_vport;
441};
442
443/**
444 * struct idpf_vector_lifo - Stack to maintain vector indexes used for vector
445 * distribution algorithm
446 * @top: Points to stack top i.e. next available vector index
447 * @base: Always points to start of the free pool
448 * @size: Total size of the vector stack
449 * @vec_idx: Array to store all the vector indexes
450 *
451 * Vector stack maintains all the relative vector indexes at the *adapter*
452 * level. This stack is divided into 2 parts, first one is called as 'default
453 * pool' and other one is called 'free pool'. Vector distribution algorithm
454 * gives priority to default vports in a way that at least IDPF_MIN_Q_VEC
455 * vectors are allocated per default vport and the relative vector indexes for
456 * those are maintained in default pool. Free pool contains all the unallocated
457 * vector indexes which can be allocated on-demand basis. Mailbox vector index
458 * is maintained in the default pool of the stack.
459 */
460struct idpf_vector_lifo {
461 u16 top;
462 u16 base;
463 u16 size;
464 u16 *vec_idx;
465};
466
467/**
468 * struct idpf_vport_config - Vport configuration data
469 * @user_config: see struct idpf_vport_user_config_data
470 * @max_q: Maximum possible queues
471 * @req_qs_chunks: Queue chunk data for requested queues
472 * @mac_filter_list_lock: Lock to protect mac filters
473 * @flags: See enum idpf_vport_config_flags
474 */
475struct idpf_vport_config {
476 struct idpf_vport_user_config_data user_config;
477 struct idpf_vport_max_q max_q;
478 struct virtchnl2_add_queues *req_qs_chunks;
479 spinlock_t mac_filter_list_lock;
480 DECLARE_BITMAP(flags, IDPF_VPORT_CONFIG_FLAGS_NBITS);
481};
482
483struct idpf_vc_xn_manager;
484
485/**
486 * struct idpf_adapter - Device data struct generated on probe
487 * @pdev: PCI device struct given on probe
488 * @virt_ver_maj: Virtchnl version major
489 * @virt_ver_min: Virtchnl version minor
490 * @msg_enable: Debug message level enabled
491 * @mb_wait_count: Number of times mailbox was attempted initialization
492 * @state: Init state machine
493 * @flags: See enum idpf_flags
494 * @reset_reg: See struct idpf_reset_reg
495 * @hw: Device access data
496 * @num_req_msix: Requested number of MSIX vectors
497 * @num_avail_msix: Available number of MSIX vectors
498 * @num_msix_entries: Number of entries in MSIX table
499 * @msix_entries: MSIX table
500 * @req_vec_chunks: Requested vector chunk data
501 * @mb_vector: Mailbox vector data
502 * @vector_stack: Stack to store the msix vector indexes
503 * @irq_mb_handler: Handler for hard interrupt for mailbox
504 * @tx_timeout_count: Number of TX timeouts that have occurred
505 * @avail_queues: Device given queue limits
506 * @vports: Array to store vports created by the driver
507 * @netdevs: Associated Vport netdevs
508 * @vport_params_reqd: Vport params requested
509 * @vport_params_recvd: Vport params received
510 * @vport_ids: Array of device given vport identifiers
511 * @vport_config: Vport config parameters
512 * @max_vports: Maximum vports that can be allocated
513 * @num_alloc_vports: Current number of vports allocated
514 * @next_vport: Next free slot in pf->vport[] - 0-based!
515 * @init_task: Initialization task
516 * @init_wq: Workqueue for initialization task
517 * @serv_task: Periodically recurring maintenance task
518 * @serv_wq: Workqueue for service task
519 * @mbx_task: Task to handle mailbox interrupts
520 * @mbx_wq: Workqueue for mailbox responses
521 * @vc_event_task: Task to handle out of band virtchnl event notifications
522 * @vc_event_wq: Workqueue for virtchnl events
523 * @stats_task: Periodic statistics retrieval task
524 * @stats_wq: Workqueue for statistics task
525 * @caps: Negotiated capabilities with device
526 * @vcxn_mngr: Virtchnl transaction manager
527 * @dev_ops: See idpf_dev_ops
528 * @num_vfs: Number of allocated VFs through sysfs. PF does not directly talk
529 * to VFs but is used to initialize them
530 * @crc_enable: Enable CRC insertion offload
531 * @req_tx_splitq: TX split or single queue model to request
532 * @req_rx_splitq: RX split or single queue model to request
533 * @vport_ctrl_lock: Lock to protect the vport control flow
534 * @vector_lock: Lock to protect vector distribution
535 * @queue_lock: Lock to protect queue distribution
536 * @vc_buf_lock: Lock to protect virtchnl buffer
537 */
538struct idpf_adapter {
539 struct pci_dev *pdev;
540 u32 virt_ver_maj;
541 u32 virt_ver_min;
542
543 u32 msg_enable;
544 u32 mb_wait_count;
545 enum idpf_state state;
546 DECLARE_BITMAP(flags, IDPF_FLAGS_NBITS);
547 struct idpf_reset_reg reset_reg;
548 struct idpf_hw hw;
549 u16 num_req_msix;
550 u16 num_avail_msix;
551 u16 num_msix_entries;
552 struct msix_entry *msix_entries;
553 struct virtchnl2_alloc_vectors *req_vec_chunks;
554 struct idpf_q_vector mb_vector;
555 struct idpf_vector_lifo vector_stack;
556 irqreturn_t (*irq_mb_handler)(int irq, void *data);
557
558 u32 tx_timeout_count;
559 struct idpf_avail_queue_info avail_queues;
560 struct idpf_vport **vports;
561 struct net_device **netdevs;
562 struct virtchnl2_create_vport **vport_params_reqd;
563 struct virtchnl2_create_vport **vport_params_recvd;
564 u32 *vport_ids;
565
566 struct idpf_vport_config **vport_config;
567 u16 max_vports;
568 u16 num_alloc_vports;
569 u16 next_vport;
570
571 struct delayed_work init_task;
572 struct workqueue_struct *init_wq;
573 struct delayed_work serv_task;
574 struct workqueue_struct *serv_wq;
575 struct delayed_work mbx_task;
576 struct workqueue_struct *mbx_wq;
577 struct delayed_work vc_event_task;
578 struct workqueue_struct *vc_event_wq;
579 struct delayed_work stats_task;
580 struct workqueue_struct *stats_wq;
581 struct virtchnl2_get_capabilities caps;
582 struct idpf_vc_xn_manager *vcxn_mngr;
583
584 struct idpf_dev_ops dev_ops;
585 int num_vfs;
586 bool crc_enable;
587 bool req_tx_splitq;
588 bool req_rx_splitq;
589
590 struct mutex vport_ctrl_lock;
591 struct mutex vector_lock;
592 struct mutex queue_lock;
593 struct mutex vc_buf_lock;
594};
595
596/**
597 * idpf_is_queue_model_split - check if queue model is split
598 * @q_model: queue model single or split
599 *
600 * Returns true if queue model is split else false
601 */
602static inline int idpf_is_queue_model_split(u16 q_model)
603{
604 return q_model == VIRTCHNL2_QUEUE_MODEL_SPLIT;
605}
606
607#define idpf_is_cap_ena(adapter, field, flag) \
608 idpf_is_capability_ena(adapter, false, field, flag)
609#define idpf_is_cap_ena_all(adapter, field, flag) \
610 idpf_is_capability_ena(adapter, true, field, flag)
611
612bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all,
613 enum idpf_cap_field field, u64 flag);
614
615#define IDPF_CAP_RSS (\
616 VIRTCHNL2_CAP_RSS_IPV4_TCP |\
617 VIRTCHNL2_CAP_RSS_IPV4_TCP |\
618 VIRTCHNL2_CAP_RSS_IPV4_UDP |\
619 VIRTCHNL2_CAP_RSS_IPV4_SCTP |\
620 VIRTCHNL2_CAP_RSS_IPV4_OTHER |\
621 VIRTCHNL2_CAP_RSS_IPV6_TCP |\
622 VIRTCHNL2_CAP_RSS_IPV6_TCP |\
623 VIRTCHNL2_CAP_RSS_IPV6_UDP |\
624 VIRTCHNL2_CAP_RSS_IPV6_SCTP |\
625 VIRTCHNL2_CAP_RSS_IPV6_OTHER)
626
627#define IDPF_CAP_RSC (\
628 VIRTCHNL2_CAP_RSC_IPV4_TCP |\
629 VIRTCHNL2_CAP_RSC_IPV6_TCP)
630
631#define IDPF_CAP_HSPLIT (\
632 VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V4 |\
633 VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V6)
634
635#define IDPF_CAP_RX_CSUM_L4V4 (\
636 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP |\
637 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP)
638
639#define IDPF_CAP_RX_CSUM_L4V6 (\
640 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP |\
641 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP)
642
643#define IDPF_CAP_RX_CSUM (\
644 VIRTCHNL2_CAP_RX_CSUM_L3_IPV4 |\
645 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP |\
646 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP |\
647 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP |\
648 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP)
649
650#define IDPF_CAP_SCTP_CSUM (\
651 VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_SCTP |\
652 VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_SCTP |\
653 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_SCTP |\
654 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_SCTP)
655
656#define IDPF_CAP_TUNNEL_TX_CSUM (\
657 VIRTCHNL2_CAP_TX_CSUM_L3_SINGLE_TUNNEL |\
658 VIRTCHNL2_CAP_TX_CSUM_L4_SINGLE_TUNNEL)
659
660/**
661 * idpf_get_reserved_vecs - Get reserved vectors
662 * @adapter: private data struct
663 */
664static inline u16 idpf_get_reserved_vecs(struct idpf_adapter *adapter)
665{
666 return le16_to_cpu(adapter->caps.num_allocated_vectors);
667}
668
669/**
670 * idpf_get_default_vports - Get default number of vports
671 * @adapter: private data struct
672 */
673static inline u16 idpf_get_default_vports(struct idpf_adapter *adapter)
674{
675 return le16_to_cpu(adapter->caps.default_num_vports);
676}
677
678/**
679 * idpf_get_max_vports - Get max number of vports
680 * @adapter: private data struct
681 */
682static inline u16 idpf_get_max_vports(struct idpf_adapter *adapter)
683{
684 return le16_to_cpu(adapter->caps.max_vports);
685}
686
687/**
688 * idpf_get_max_tx_bufs - Get max scatter-gather buffers supported by the device
689 * @adapter: private data struct
690 */
691static inline unsigned int idpf_get_max_tx_bufs(struct idpf_adapter *adapter)
692{
693 return adapter->caps.max_sg_bufs_per_tx_pkt;
694}
695
696/**
697 * idpf_get_min_tx_pkt_len - Get min packet length supported by the device
698 * @adapter: private data struct
699 */
700static inline u8 idpf_get_min_tx_pkt_len(struct idpf_adapter *adapter)
701{
702 u8 pkt_len = adapter->caps.min_sso_packet_len;
703
704 return pkt_len ? pkt_len : IDPF_TX_MIN_PKT_LEN;
705}
706
707/**
708 * idpf_get_reg_addr - Get BAR0 register address
709 * @adapter: private data struct
710 * @reg_offset: register offset value
711 *
712 * Based on the register offset, return the actual BAR0 register address
713 */
714static inline void __iomem *idpf_get_reg_addr(struct idpf_adapter *adapter,
715 resource_size_t reg_offset)
716{
717 return (void __iomem *)(adapter->hw.hw_addr + reg_offset);
718}
719
720/**
721 * idpf_is_reset_detected - check if we were reset at some point
722 * @adapter: driver specific private structure
723 *
724 * Returns true if we are either in reset currently or were previously reset.
725 */
726static inline bool idpf_is_reset_detected(struct idpf_adapter *adapter)
727{
728 if (!adapter->hw.arq)
729 return true;
730
731 return !(readl(idpf_get_reg_addr(adapter, adapter->hw.arq->reg.len)) &
732 adapter->hw.arq->reg.len_mask);
733}
734
735/**
736 * idpf_is_reset_in_prog - check if reset is in progress
737 * @adapter: driver specific private structure
738 *
739 * Returns true if hard reset is in progress, false otherwise
740 */
741static inline bool idpf_is_reset_in_prog(struct idpf_adapter *adapter)
742{
743 return (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags) ||
744 test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||
745 test_bit(IDPF_HR_DRV_LOAD, adapter->flags));
746}
747
748/**
749 * idpf_netdev_to_vport - get a vport handle from a netdev
750 * @netdev: network interface device structure
751 */
752static inline struct idpf_vport *idpf_netdev_to_vport(struct net_device *netdev)
753{
754 struct idpf_netdev_priv *np = netdev_priv(netdev);
755
756 return np->vport;
757}
758
759/**
760 * idpf_netdev_to_adapter - Get adapter handle from a netdev
761 * @netdev: Network interface device structure
762 */
763static inline struct idpf_adapter *idpf_netdev_to_adapter(struct net_device *netdev)
764{
765 struct idpf_netdev_priv *np = netdev_priv(netdev);
766
767 return np->adapter;
768}
769
770/**
771 * idpf_is_feature_ena - Determine if a particular feature is enabled
772 * @vport: Vport to check
773 * @feature: Netdev flag to check
774 *
775 * Returns true or false if a particular feature is enabled.
776 */
777static inline bool idpf_is_feature_ena(const struct idpf_vport *vport,
778 netdev_features_t feature)
779{
780 return vport->netdev->features & feature;
781}
782
783/**
784 * idpf_get_max_tx_hdr_size -- get the size of tx header
785 * @adapter: Driver specific private structure
786 */
787static inline u16 idpf_get_max_tx_hdr_size(struct idpf_adapter *adapter)
788{
789 return le16_to_cpu(adapter->caps.max_tx_hdr_size);
790}
791
792/**
793 * idpf_vport_ctrl_lock - Acquire the vport control lock
794 * @netdev: Network interface device structure
795 *
796 * This lock should be used by non-datapath code to protect against vport
797 * destruction.
798 */
799static inline void idpf_vport_ctrl_lock(struct net_device *netdev)
800{
801 struct idpf_netdev_priv *np = netdev_priv(netdev);
802
803 mutex_lock(&np->adapter->vport_ctrl_lock);
804}
805
806/**
807 * idpf_vport_ctrl_unlock - Release the vport control lock
808 * @netdev: Network interface device structure
809 */
810static inline void idpf_vport_ctrl_unlock(struct net_device *netdev)
811{
812 struct idpf_netdev_priv *np = netdev_priv(netdev);
813
814 mutex_unlock(&np->adapter->vport_ctrl_lock);
815}
816
817void idpf_statistics_task(struct work_struct *work);
818void idpf_init_task(struct work_struct *work);
819void idpf_service_task(struct work_struct *work);
820void idpf_mbx_task(struct work_struct *work);
821void idpf_vc_event_task(struct work_struct *work);
822void idpf_dev_ops_init(struct idpf_adapter *adapter);
823void idpf_vf_dev_ops_init(struct idpf_adapter *adapter);
824int idpf_intr_req(struct idpf_adapter *adapter);
825void idpf_intr_rel(struct idpf_adapter *adapter);
826u16 idpf_get_max_tx_hdr_size(struct idpf_adapter *adapter);
827int idpf_initiate_soft_reset(struct idpf_vport *vport,
828 enum idpf_vport_reset_cause reset_cause);
829void idpf_deinit_task(struct idpf_adapter *adapter);
830int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,
831 u16 *q_vector_idxs,
832 struct idpf_vector_info *vec_info);
833void idpf_set_ethtool_ops(struct net_device *netdev);
834void idpf_vport_intr_write_itr(struct idpf_q_vector *q_vector,
835 u16 itr, bool tx);
836int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs);
837
838u8 idpf_vport_get_hsplit(const struct idpf_vport *vport);
839bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val);
840
841#endif /* !_IDPF_H_ */
1/* SPDX-License-Identifier: GPL-2.0-only */
2/* Copyright (C) 2023 Intel Corporation */
3
4#ifndef _IDPF_H_
5#define _IDPF_H_
6
7/* Forward declaration */
8struct idpf_adapter;
9struct idpf_vport;
10struct idpf_vport_max_q;
11
12#include <net/pkt_sched.h>
13#include <linux/aer.h>
14#include <linux/etherdevice.h>
15#include <linux/pci.h>
16#include <linux/bitfield.h>
17#include <linux/sctp.h>
18#include <linux/ethtool_netlink.h>
19#include <net/gro.h>
20#include <linux/dim.h>
21
22#include "virtchnl2.h"
23#include "idpf_lan_txrx.h"
24#include "idpf_txrx.h"
25#include "idpf_controlq.h"
26
27#define GETMAXVAL(num_bits) GENMASK((num_bits) - 1, 0)
28
29#define IDPF_NO_FREE_SLOT 0xffff
30
31/* Default Mailbox settings */
32#define IDPF_NUM_FILTERS_PER_MSG 20
33#define IDPF_NUM_DFLT_MBX_Q 2 /* includes both TX and RX */
34#define IDPF_DFLT_MBX_Q_LEN 64
35#define IDPF_DFLT_MBX_ID -1
36/* maximum number of times to try before resetting mailbox */
37#define IDPF_MB_MAX_ERR 20
38#define IDPF_NUM_CHUNKS_PER_MSG(struct_sz, chunk_sz) \
39 ((IDPF_CTLQ_MAX_BUF_LEN - (struct_sz)) / (chunk_sz))
40#define IDPF_WAIT_FOR_EVENT_TIMEO_MIN 2000
41#define IDPF_WAIT_FOR_EVENT_TIMEO 60000
42
43#define IDPF_MAX_WAIT 500
44
45/* available message levels */
46#define IDPF_AVAIL_NETIF_M (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
47
48#define IDPF_DIM_PROFILE_SLOTS 5
49
50#define IDPF_VIRTCHNL_VERSION_MAJOR VIRTCHNL2_VERSION_MAJOR_2
51#define IDPF_VIRTCHNL_VERSION_MINOR VIRTCHNL2_VERSION_MINOR_0
52
53/**
54 * struct idpf_mac_filter
55 * @list: list member field
56 * @macaddr: MAC address
57 * @remove: filter should be removed (virtchnl)
58 * @add: filter should be added (virtchnl)
59 */
60struct idpf_mac_filter {
61 struct list_head list;
62 u8 macaddr[ETH_ALEN];
63 bool remove;
64 bool add;
65};
66
67/**
68 * enum idpf_state - State machine to handle bring up
69 * @__IDPF_STARTUP: Start the state machine
70 * @__IDPF_VER_CHECK: Negotiate virtchnl version
71 * @__IDPF_GET_CAPS: Negotiate capabilities
72 * @__IDPF_INIT_SW: Init based on given capabilities
73 * @__IDPF_STATE_LAST: Must be last, used to determine size
74 */
75enum idpf_state {
76 __IDPF_STARTUP,
77 __IDPF_VER_CHECK,
78 __IDPF_GET_CAPS,
79 __IDPF_INIT_SW,
80 __IDPF_STATE_LAST,
81};
82
83/**
84 * enum idpf_flags - Hard reset causes.
85 * @IDPF_HR_FUNC_RESET: Hard reset when TxRx timeout
86 * @IDPF_HR_DRV_LOAD: Set on driver load for a clean HW
87 * @IDPF_HR_RESET_IN_PROG: Reset in progress
88 * @IDPF_REMOVE_IN_PROG: Driver remove in progress
89 * @IDPF_MB_INTR_MODE: Mailbox in interrupt mode
90 * @IDPF_FLAGS_NBITS: Must be last
91 */
92enum idpf_flags {
93 IDPF_HR_FUNC_RESET,
94 IDPF_HR_DRV_LOAD,
95 IDPF_HR_RESET_IN_PROG,
96 IDPF_REMOVE_IN_PROG,
97 IDPF_MB_INTR_MODE,
98 IDPF_FLAGS_NBITS,
99};
100
101/**
102 * enum idpf_cap_field - Offsets into capabilities struct for specific caps
103 * @IDPF_BASE_CAPS: generic base capabilities
104 * @IDPF_CSUM_CAPS: checksum offload capabilities
105 * @IDPF_SEG_CAPS: segmentation offload capabilities
106 * @IDPF_RSS_CAPS: RSS offload capabilities
107 * @IDPF_HSPLIT_CAPS: Header split capabilities
108 * @IDPF_RSC_CAPS: RSC offload capabilities
109 * @IDPF_OTHER_CAPS: miscellaneous offloads
110 *
111 * Used when checking for a specific capability flag since different capability
112 * sets are not mutually exclusive numerically, the caller must specify which
113 * type of capability they are checking for.
114 */
115enum idpf_cap_field {
116 IDPF_BASE_CAPS = -1,
117 IDPF_CSUM_CAPS = offsetof(struct virtchnl2_get_capabilities,
118 csum_caps),
119 IDPF_SEG_CAPS = offsetof(struct virtchnl2_get_capabilities,
120 seg_caps),
121 IDPF_RSS_CAPS = offsetof(struct virtchnl2_get_capabilities,
122 rss_caps),
123 IDPF_HSPLIT_CAPS = offsetof(struct virtchnl2_get_capabilities,
124 hsplit_caps),
125 IDPF_RSC_CAPS = offsetof(struct virtchnl2_get_capabilities,
126 rsc_caps),
127 IDPF_OTHER_CAPS = offsetof(struct virtchnl2_get_capabilities,
128 other_caps),
129};
130
131/**
132 * enum idpf_vport_state - Current vport state
133 * @__IDPF_VPORT_DOWN: Vport is down
134 * @__IDPF_VPORT_UP: Vport is up
135 * @__IDPF_VPORT_STATE_LAST: Must be last, number of states
136 */
137enum idpf_vport_state {
138 __IDPF_VPORT_DOWN,
139 __IDPF_VPORT_UP,
140 __IDPF_VPORT_STATE_LAST,
141};
142
143/**
144 * struct idpf_netdev_priv - Struct to store vport back pointer
145 * @adapter: Adapter back pointer
146 * @vport: Vport back pointer
147 * @vport_id: Vport identifier
148 * @vport_idx: Relative vport index
149 * @state: See enum idpf_vport_state
150 * @netstats: Packet and byte stats
151 * @stats_lock: Lock to protect stats update
152 */
153struct idpf_netdev_priv {
154 struct idpf_adapter *adapter;
155 struct idpf_vport *vport;
156 u32 vport_id;
157 u16 vport_idx;
158 enum idpf_vport_state state;
159 struct rtnl_link_stats64 netstats;
160 spinlock_t stats_lock;
161};
162
163/**
164 * struct idpf_reset_reg - Reset register offsets/masks
165 * @rstat: Reset status register
166 * @rstat_m: Reset status mask
167 */
168struct idpf_reset_reg {
169 void __iomem *rstat;
170 u32 rstat_m;
171};
172
173/**
174 * struct idpf_vport_max_q - Queue limits
175 * @max_rxq: Maximum number of RX queues supported
176 * @max_txq: Maixmum number of TX queues supported
177 * @max_bufq: In splitq, maximum number of buffer queues supported
178 * @max_complq: In splitq, maximum number of completion queues supported
179 */
180struct idpf_vport_max_q {
181 u16 max_rxq;
182 u16 max_txq;
183 u16 max_bufq;
184 u16 max_complq;
185};
186
187/**
188 * struct idpf_reg_ops - Device specific register operation function pointers
189 * @ctlq_reg_init: Mailbox control queue register initialization
190 * @intr_reg_init: Traffic interrupt register initialization
191 * @mb_intr_reg_init: Mailbox interrupt register initialization
192 * @reset_reg_init: Reset register initialization
193 * @trigger_reset: Trigger a reset to occur
194 */
195struct idpf_reg_ops {
196 void (*ctlq_reg_init)(struct idpf_ctlq_create_info *cq);
197 int (*intr_reg_init)(struct idpf_vport *vport);
198 void (*mb_intr_reg_init)(struct idpf_adapter *adapter);
199 void (*reset_reg_init)(struct idpf_adapter *adapter);
200 void (*trigger_reset)(struct idpf_adapter *adapter,
201 enum idpf_flags trig_cause);
202};
203
204/**
205 * struct idpf_dev_ops - Device specific operations
206 * @reg_ops: Register operations
207 */
208struct idpf_dev_ops {
209 struct idpf_reg_ops reg_ops;
210};
211
212/* These macros allow us to generate an enum and a matching char * array of
213 * stringified enums that are always in sync. Checkpatch issues a bogus warning
214 * about this being a complex macro; but it's wrong, these are never used as a
215 * statement and instead only used to define the enum and array.
216 */
217#define IDPF_FOREACH_VPORT_VC_STATE(STATE) \
218 STATE(IDPF_VC_CREATE_VPORT) \
219 STATE(IDPF_VC_CREATE_VPORT_ERR) \
220 STATE(IDPF_VC_ENA_VPORT) \
221 STATE(IDPF_VC_ENA_VPORT_ERR) \
222 STATE(IDPF_VC_DIS_VPORT) \
223 STATE(IDPF_VC_DIS_VPORT_ERR) \
224 STATE(IDPF_VC_DESTROY_VPORT) \
225 STATE(IDPF_VC_DESTROY_VPORT_ERR) \
226 STATE(IDPF_VC_CONFIG_TXQ) \
227 STATE(IDPF_VC_CONFIG_TXQ_ERR) \
228 STATE(IDPF_VC_CONFIG_RXQ) \
229 STATE(IDPF_VC_CONFIG_RXQ_ERR) \
230 STATE(IDPF_VC_ENA_QUEUES) \
231 STATE(IDPF_VC_ENA_QUEUES_ERR) \
232 STATE(IDPF_VC_DIS_QUEUES) \
233 STATE(IDPF_VC_DIS_QUEUES_ERR) \
234 STATE(IDPF_VC_MAP_IRQ) \
235 STATE(IDPF_VC_MAP_IRQ_ERR) \
236 STATE(IDPF_VC_UNMAP_IRQ) \
237 STATE(IDPF_VC_UNMAP_IRQ_ERR) \
238 STATE(IDPF_VC_ADD_QUEUES) \
239 STATE(IDPF_VC_ADD_QUEUES_ERR) \
240 STATE(IDPF_VC_DEL_QUEUES) \
241 STATE(IDPF_VC_DEL_QUEUES_ERR) \
242 STATE(IDPF_VC_ALLOC_VECTORS) \
243 STATE(IDPF_VC_ALLOC_VECTORS_ERR) \
244 STATE(IDPF_VC_DEALLOC_VECTORS) \
245 STATE(IDPF_VC_DEALLOC_VECTORS_ERR) \
246 STATE(IDPF_VC_SET_SRIOV_VFS) \
247 STATE(IDPF_VC_SET_SRIOV_VFS_ERR) \
248 STATE(IDPF_VC_GET_RSS_LUT) \
249 STATE(IDPF_VC_GET_RSS_LUT_ERR) \
250 STATE(IDPF_VC_SET_RSS_LUT) \
251 STATE(IDPF_VC_SET_RSS_LUT_ERR) \
252 STATE(IDPF_VC_GET_RSS_KEY) \
253 STATE(IDPF_VC_GET_RSS_KEY_ERR) \
254 STATE(IDPF_VC_SET_RSS_KEY) \
255 STATE(IDPF_VC_SET_RSS_KEY_ERR) \
256 STATE(IDPF_VC_GET_STATS) \
257 STATE(IDPF_VC_GET_STATS_ERR) \
258 STATE(IDPF_VC_ADD_MAC_ADDR) \
259 STATE(IDPF_VC_ADD_MAC_ADDR_ERR) \
260 STATE(IDPF_VC_DEL_MAC_ADDR) \
261 STATE(IDPF_VC_DEL_MAC_ADDR_ERR) \
262 STATE(IDPF_VC_GET_PTYPE_INFO) \
263 STATE(IDPF_VC_GET_PTYPE_INFO_ERR) \
264 STATE(IDPF_VC_LOOPBACK_STATE) \
265 STATE(IDPF_VC_LOOPBACK_STATE_ERR) \
266 STATE(IDPF_VC_NBITS)
267
268#define IDPF_GEN_ENUM(ENUM) ENUM,
269#define IDPF_GEN_STRING(STRING) #STRING,
270
271enum idpf_vport_vc_state {
272 IDPF_FOREACH_VPORT_VC_STATE(IDPF_GEN_ENUM)
273};
274
275extern const char * const idpf_vport_vc_state_str[];
276
277/**
278 * enum idpf_vport_reset_cause - Vport soft reset causes
279 * @IDPF_SR_Q_CHANGE: Soft reset queue change
280 * @IDPF_SR_Q_DESC_CHANGE: Soft reset descriptor change
281 * @IDPF_SR_MTU_CHANGE: Soft reset MTU change
282 * @IDPF_SR_RSC_CHANGE: Soft reset RSC change
283 */
284enum idpf_vport_reset_cause {
285 IDPF_SR_Q_CHANGE,
286 IDPF_SR_Q_DESC_CHANGE,
287 IDPF_SR_MTU_CHANGE,
288 IDPF_SR_RSC_CHANGE,
289};
290
291/**
292 * enum idpf_vport_flags - Vport flags
293 * @IDPF_VPORT_DEL_QUEUES: To send delete queues message
294 * @IDPF_VPORT_SW_MARKER: Indicate TX pipe drain software marker packets
295 * processing is done
296 * @IDPF_VPORT_FLAGS_NBITS: Must be last
297 */
298enum idpf_vport_flags {
299 IDPF_VPORT_DEL_QUEUES,
300 IDPF_VPORT_SW_MARKER,
301 IDPF_VPORT_FLAGS_NBITS,
302};
303
304struct idpf_port_stats {
305 struct u64_stats_sync stats_sync;
306 u64_stats_t rx_hw_csum_err;
307 u64_stats_t rx_hsplit;
308 u64_stats_t rx_hsplit_hbo;
309 u64_stats_t rx_bad_descs;
310 u64_stats_t tx_linearize;
311 u64_stats_t tx_busy;
312 u64_stats_t tx_drops;
313 u64_stats_t tx_dma_map_errs;
314 struct virtchnl2_vport_stats vport_stats;
315};
316
317/**
318 * struct idpf_vport - Handle for netdevices and queue resources
319 * @num_txq: Number of allocated TX queues
320 * @num_complq: Number of allocated completion queues
321 * @txq_desc_count: TX queue descriptor count
322 * @complq_desc_count: Completion queue descriptor count
323 * @compln_clean_budget: Work budget for completion clean
324 * @num_txq_grp: Number of TX queue groups
325 * @txq_grps: Array of TX queue groups
326 * @txq_model: Split queue or single queue queuing model
327 * @txqs: Used only in hotpath to get to the right queue very fast
328 * @crc_enable: Enable CRC insertion offload
329 * @num_rxq: Number of allocated RX queues
330 * @num_bufq: Number of allocated buffer queues
331 * @rxq_desc_count: RX queue descriptor count. *MUST* have enough descriptors
332 * to complete all buffer descriptors for all buffer queues in
333 * the worst case.
334 * @num_bufqs_per_qgrp: Buffer queues per RX queue in a given grouping
335 * @bufq_desc_count: Buffer queue descriptor count
336 * @bufq_size: Size of buffers in ring (e.g. 2K, 4K, etc)
337 * @num_rxq_grp: Number of RX queues in a group
338 * @rxq_grps: Total number of RX groups. Number of groups * number of RX per
339 * group will yield total number of RX queues.
340 * @rxq_model: Splitq queue or single queue queuing model
341 * @rx_ptype_lkup: Lookup table for ptypes on RX
342 * @adapter: back pointer to associated adapter
343 * @netdev: Associated net_device. Each vport should have one and only one
344 * associated netdev.
345 * @flags: See enum idpf_vport_flags
346 * @vport_type: Default SRIOV, SIOV, etc.
347 * @vport_id: Device given vport identifier
348 * @idx: Software index in adapter vports struct
349 * @default_vport: Use this vport if one isn't specified
350 * @base_rxd: True if the driver should use base descriptors instead of flex
351 * @num_q_vectors: Number of IRQ vectors allocated
352 * @q_vectors: Array of queue vectors
353 * @q_vector_idxs: Starting index of queue vectors
354 * @max_mtu: device given max possible MTU
355 * @default_mac_addr: device will give a default MAC to use
356 * @rx_itr_profile: RX profiles for Dynamic Interrupt Moderation
357 * @tx_itr_profile: TX profiles for Dynamic Interrupt Moderation
358 * @port_stats: per port csum, header split, and other offload stats
359 * @link_up: True if link is up
360 * @link_speed_mbps: Link speed in mbps
361 * @vc_msg: Virtchnl message buffer
362 * @vc_state: Virtchnl message state
363 * @vchnl_wq: Wait queue for virtchnl messages
364 * @sw_marker_wq: workqueue for marker packets
365 * @vc_buf_lock: Lock to protect virtchnl buffer
366 */
367struct idpf_vport {
368 u16 num_txq;
369 u16 num_complq;
370 u32 txq_desc_count;
371 u32 complq_desc_count;
372 u32 compln_clean_budget;
373 u16 num_txq_grp;
374 struct idpf_txq_group *txq_grps;
375 u32 txq_model;
376 struct idpf_queue **txqs;
377 bool crc_enable;
378
379 u16 num_rxq;
380 u16 num_bufq;
381 u32 rxq_desc_count;
382 u8 num_bufqs_per_qgrp;
383 u32 bufq_desc_count[IDPF_MAX_BUFQS_PER_RXQ_GRP];
384 u32 bufq_size[IDPF_MAX_BUFQS_PER_RXQ_GRP];
385 u16 num_rxq_grp;
386 struct idpf_rxq_group *rxq_grps;
387 u32 rxq_model;
388 struct idpf_rx_ptype_decoded rx_ptype_lkup[IDPF_RX_MAX_PTYPE];
389
390 struct idpf_adapter *adapter;
391 struct net_device *netdev;
392 DECLARE_BITMAP(flags, IDPF_VPORT_FLAGS_NBITS);
393 u16 vport_type;
394 u32 vport_id;
395 u16 idx;
396 bool default_vport;
397 bool base_rxd;
398
399 u16 num_q_vectors;
400 struct idpf_q_vector *q_vectors;
401 u16 *q_vector_idxs;
402 u16 max_mtu;
403 u8 default_mac_addr[ETH_ALEN];
404 u16 rx_itr_profile[IDPF_DIM_PROFILE_SLOTS];
405 u16 tx_itr_profile[IDPF_DIM_PROFILE_SLOTS];
406 struct idpf_port_stats port_stats;
407
408 bool link_up;
409 u32 link_speed_mbps;
410
411 char vc_msg[IDPF_CTLQ_MAX_BUF_LEN];
412 DECLARE_BITMAP(vc_state, IDPF_VC_NBITS);
413
414 wait_queue_head_t vchnl_wq;
415 wait_queue_head_t sw_marker_wq;
416 struct mutex vc_buf_lock;
417};
418
419/**
420 * enum idpf_user_flags
421 * @__IDPF_USER_FLAG_HSPLIT: header split state
422 * @__IDPF_PROMISC_UC: Unicast promiscuous mode
423 * @__IDPF_PROMISC_MC: Multicast promiscuous mode
424 * @__IDPF_USER_FLAGS_NBITS: Must be last
425 */
426enum idpf_user_flags {
427 __IDPF_USER_FLAG_HSPLIT = 0U,
428 __IDPF_PROMISC_UC = 32,
429 __IDPF_PROMISC_MC,
430
431 __IDPF_USER_FLAGS_NBITS,
432};
433
434/**
435 * struct idpf_rss_data - Associated RSS data
436 * @rss_key_size: Size of RSS hash key
437 * @rss_key: RSS hash key
438 * @rss_lut_size: Size of RSS lookup table
439 * @rss_lut: RSS lookup table
440 * @cached_lut: Used to restore previously init RSS lut
441 */
442struct idpf_rss_data {
443 u16 rss_key_size;
444 u8 *rss_key;
445 u16 rss_lut_size;
446 u32 *rss_lut;
447 u32 *cached_lut;
448};
449
450/**
451 * struct idpf_vport_user_config_data - User defined configuration values for
452 * each vport.
453 * @rss_data: See struct idpf_rss_data
454 * @num_req_tx_qs: Number of user requested TX queues through ethtool
455 * @num_req_rx_qs: Number of user requested RX queues through ethtool
456 * @num_req_txq_desc: Number of user requested TX queue descriptors through
457 * ethtool
458 * @num_req_rxq_desc: Number of user requested RX queue descriptors through
459 * ethtool
460 * @user_flags: User toggled config flags
461 * @mac_filter_list: List of MAC filters
462 *
463 * Used to restore configuration after a reset as the vport will get wiped.
464 */
465struct idpf_vport_user_config_data {
466 struct idpf_rss_data rss_data;
467 u16 num_req_tx_qs;
468 u16 num_req_rx_qs;
469 u32 num_req_txq_desc;
470 u32 num_req_rxq_desc;
471 DECLARE_BITMAP(user_flags, __IDPF_USER_FLAGS_NBITS);
472 struct list_head mac_filter_list;
473};
474
475/**
476 * enum idpf_vport_config_flags - Vport config flags
477 * @IDPF_VPORT_REG_NETDEV: Register netdev
478 * @IDPF_VPORT_UP_REQUESTED: Set if interface up is requested on core reset
479 * @IDPF_VPORT_ADD_MAC_REQ: Asynchronous add ether address in flight
480 * @IDPF_VPORT_DEL_MAC_REQ: Asynchronous delete ether address in flight
481 * @IDPF_VPORT_CONFIG_FLAGS_NBITS: Must be last
482 */
483enum idpf_vport_config_flags {
484 IDPF_VPORT_REG_NETDEV,
485 IDPF_VPORT_UP_REQUESTED,
486 IDPF_VPORT_ADD_MAC_REQ,
487 IDPF_VPORT_DEL_MAC_REQ,
488 IDPF_VPORT_CONFIG_FLAGS_NBITS,
489};
490
491/**
492 * struct idpf_avail_queue_info
493 * @avail_rxq: Available RX queues
494 * @avail_txq: Available TX queues
495 * @avail_bufq: Available buffer queues
496 * @avail_complq: Available completion queues
497 *
498 * Maintain total queues available after allocating max queues to each vport.
499 */
500struct idpf_avail_queue_info {
501 u16 avail_rxq;
502 u16 avail_txq;
503 u16 avail_bufq;
504 u16 avail_complq;
505};
506
507/**
508 * struct idpf_vector_info - Utility structure to pass function arguments as a
509 * structure
510 * @num_req_vecs: Vectors required based on the number of queues updated by the
511 * user via ethtool
512 * @num_curr_vecs: Current number of vectors, must be >= @num_req_vecs
513 * @index: Relative starting index for vectors
514 * @default_vport: Vectors are for default vport
515 */
516struct idpf_vector_info {
517 u16 num_req_vecs;
518 u16 num_curr_vecs;
519 u16 index;
520 bool default_vport;
521};
522
523/**
524 * struct idpf_vector_lifo - Stack to maintain vector indexes used for vector
525 * distribution algorithm
526 * @top: Points to stack top i.e. next available vector index
527 * @base: Always points to start of the free pool
528 * @size: Total size of the vector stack
529 * @vec_idx: Array to store all the vector indexes
530 *
531 * Vector stack maintains all the relative vector indexes at the *adapter*
532 * level. This stack is divided into 2 parts, first one is called as 'default
533 * pool' and other one is called 'free pool'. Vector distribution algorithm
534 * gives priority to default vports in a way that at least IDPF_MIN_Q_VEC
535 * vectors are allocated per default vport and the relative vector indexes for
536 * those are maintained in default pool. Free pool contains all the unallocated
537 * vector indexes which can be allocated on-demand basis. Mailbox vector index
538 * is maintained in the default pool of the stack.
539 */
540struct idpf_vector_lifo {
541 u16 top;
542 u16 base;
543 u16 size;
544 u16 *vec_idx;
545};
546
547/**
548 * struct idpf_vport_config - Vport configuration data
549 * @user_config: see struct idpf_vport_user_config_data
550 * @max_q: Maximum possible queues
551 * @req_qs_chunks: Queue chunk data for requested queues
552 * @mac_filter_list_lock: Lock to protect mac filters
553 * @flags: See enum idpf_vport_config_flags
554 */
555struct idpf_vport_config {
556 struct idpf_vport_user_config_data user_config;
557 struct idpf_vport_max_q max_q;
558 void *req_qs_chunks;
559 spinlock_t mac_filter_list_lock;
560 DECLARE_BITMAP(flags, IDPF_VPORT_CONFIG_FLAGS_NBITS);
561};
562
563/**
564 * struct idpf_adapter - Device data struct generated on probe
565 * @pdev: PCI device struct given on probe
566 * @virt_ver_maj: Virtchnl version major
567 * @virt_ver_min: Virtchnl version minor
568 * @msg_enable: Debug message level enabled
569 * @mb_wait_count: Number of times mailbox was attempted initialization
570 * @state: Init state machine
571 * @flags: See enum idpf_flags
572 * @reset_reg: See struct idpf_reset_reg
573 * @hw: Device access data
574 * @num_req_msix: Requested number of MSIX vectors
575 * @num_avail_msix: Available number of MSIX vectors
576 * @num_msix_entries: Number of entries in MSIX table
577 * @msix_entries: MSIX table
578 * @req_vec_chunks: Requested vector chunk data
579 * @mb_vector: Mailbox vector data
580 * @vector_stack: Stack to store the msix vector indexes
581 * @irq_mb_handler: Handler for hard interrupt for mailbox
582 * @tx_timeout_count: Number of TX timeouts that have occurred
583 * @avail_queues: Device given queue limits
584 * @vports: Array to store vports created by the driver
585 * @netdevs: Associated Vport netdevs
586 * @vport_params_reqd: Vport params requested
587 * @vport_params_recvd: Vport params received
588 * @vport_ids: Array of device given vport identifiers
589 * @vport_config: Vport config parameters
590 * @max_vports: Maximum vports that can be allocated
591 * @num_alloc_vports: Current number of vports allocated
592 * @next_vport: Next free slot in pf->vport[] - 0-based!
593 * @init_task: Initialization task
594 * @init_wq: Workqueue for initialization task
595 * @serv_task: Periodically recurring maintenance task
596 * @serv_wq: Workqueue for service task
597 * @mbx_task: Task to handle mailbox interrupts
598 * @mbx_wq: Workqueue for mailbox responses
599 * @vc_event_task: Task to handle out of band virtchnl event notifications
600 * @vc_event_wq: Workqueue for virtchnl events
601 * @stats_task: Periodic statistics retrieval task
602 * @stats_wq: Workqueue for statistics task
603 * @caps: Negotiated capabilities with device
604 * @vchnl_wq: Wait queue for virtchnl messages
605 * @vc_state: Virtchnl message state
606 * @vc_msg: Virtchnl message buffer
607 * @dev_ops: See idpf_dev_ops
608 * @num_vfs: Number of allocated VFs through sysfs. PF does not directly talk
609 * to VFs but is used to initialize them
610 * @crc_enable: Enable CRC insertion offload
611 * @req_tx_splitq: TX split or single queue model to request
612 * @req_rx_splitq: RX split or single queue model to request
613 * @vport_ctrl_lock: Lock to protect the vport control flow
614 * @vector_lock: Lock to protect vector distribution
615 * @queue_lock: Lock to protect queue distribution
616 * @vc_buf_lock: Lock to protect virtchnl buffer
617 */
618struct idpf_adapter {
619 struct pci_dev *pdev;
620 u32 virt_ver_maj;
621 u32 virt_ver_min;
622
623 u32 msg_enable;
624 u32 mb_wait_count;
625 enum idpf_state state;
626 DECLARE_BITMAP(flags, IDPF_FLAGS_NBITS);
627 struct idpf_reset_reg reset_reg;
628 struct idpf_hw hw;
629 u16 num_req_msix;
630 u16 num_avail_msix;
631 u16 num_msix_entries;
632 struct msix_entry *msix_entries;
633 struct virtchnl2_alloc_vectors *req_vec_chunks;
634 struct idpf_q_vector mb_vector;
635 struct idpf_vector_lifo vector_stack;
636 irqreturn_t (*irq_mb_handler)(int irq, void *data);
637
638 u32 tx_timeout_count;
639 struct idpf_avail_queue_info avail_queues;
640 struct idpf_vport **vports;
641 struct net_device **netdevs;
642 struct virtchnl2_create_vport **vport_params_reqd;
643 struct virtchnl2_create_vport **vport_params_recvd;
644 u32 *vport_ids;
645
646 struct idpf_vport_config **vport_config;
647 u16 max_vports;
648 u16 num_alloc_vports;
649 u16 next_vport;
650
651 struct delayed_work init_task;
652 struct workqueue_struct *init_wq;
653 struct delayed_work serv_task;
654 struct workqueue_struct *serv_wq;
655 struct delayed_work mbx_task;
656 struct workqueue_struct *mbx_wq;
657 struct delayed_work vc_event_task;
658 struct workqueue_struct *vc_event_wq;
659 struct delayed_work stats_task;
660 struct workqueue_struct *stats_wq;
661 struct virtchnl2_get_capabilities caps;
662
663 wait_queue_head_t vchnl_wq;
664 DECLARE_BITMAP(vc_state, IDPF_VC_NBITS);
665 char vc_msg[IDPF_CTLQ_MAX_BUF_LEN];
666 struct idpf_dev_ops dev_ops;
667 int num_vfs;
668 bool crc_enable;
669 bool req_tx_splitq;
670 bool req_rx_splitq;
671
672 struct mutex vport_ctrl_lock;
673 struct mutex vector_lock;
674 struct mutex queue_lock;
675 struct mutex vc_buf_lock;
676};
677
678/**
679 * idpf_is_queue_model_split - check if queue model is split
680 * @q_model: queue model single or split
681 *
682 * Returns true if queue model is split else false
683 */
684static inline int idpf_is_queue_model_split(u16 q_model)
685{
686 return q_model == VIRTCHNL2_QUEUE_MODEL_SPLIT;
687}
688
689#define idpf_is_cap_ena(adapter, field, flag) \
690 idpf_is_capability_ena(adapter, false, field, flag)
691#define idpf_is_cap_ena_all(adapter, field, flag) \
692 idpf_is_capability_ena(adapter, true, field, flag)
693
694bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all,
695 enum idpf_cap_field field, u64 flag);
696
697#define IDPF_CAP_RSS (\
698 VIRTCHNL2_CAP_RSS_IPV4_TCP |\
699 VIRTCHNL2_CAP_RSS_IPV4_TCP |\
700 VIRTCHNL2_CAP_RSS_IPV4_UDP |\
701 VIRTCHNL2_CAP_RSS_IPV4_SCTP |\
702 VIRTCHNL2_CAP_RSS_IPV4_OTHER |\
703 VIRTCHNL2_CAP_RSS_IPV6_TCP |\
704 VIRTCHNL2_CAP_RSS_IPV6_TCP |\
705 VIRTCHNL2_CAP_RSS_IPV6_UDP |\
706 VIRTCHNL2_CAP_RSS_IPV6_SCTP |\
707 VIRTCHNL2_CAP_RSS_IPV6_OTHER)
708
709#define IDPF_CAP_RSC (\
710 VIRTCHNL2_CAP_RSC_IPV4_TCP |\
711 VIRTCHNL2_CAP_RSC_IPV6_TCP)
712
713#define IDPF_CAP_HSPLIT (\
714 VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V4 |\
715 VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V6)
716
717#define IDPF_CAP_RX_CSUM_L4V4 (\
718 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP |\
719 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP)
720
721#define IDPF_CAP_RX_CSUM_L4V6 (\
722 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP |\
723 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP)
724
725#define IDPF_CAP_RX_CSUM (\
726 VIRTCHNL2_CAP_RX_CSUM_L3_IPV4 |\
727 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP |\
728 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP |\
729 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP |\
730 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP)
731
732#define IDPF_CAP_SCTP_CSUM (\
733 VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_SCTP |\
734 VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_SCTP |\
735 VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_SCTP |\
736 VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_SCTP)
737
738#define IDPF_CAP_TUNNEL_TX_CSUM (\
739 VIRTCHNL2_CAP_TX_CSUM_L3_SINGLE_TUNNEL |\
740 VIRTCHNL2_CAP_TX_CSUM_L4_SINGLE_TUNNEL)
741
742/**
743 * idpf_get_reserved_vecs - Get reserved vectors
744 * @adapter: private data struct
745 */
746static inline u16 idpf_get_reserved_vecs(struct idpf_adapter *adapter)
747{
748 return le16_to_cpu(adapter->caps.num_allocated_vectors);
749}
750
751/**
752 * idpf_get_default_vports - Get default number of vports
753 * @adapter: private data struct
754 */
755static inline u16 idpf_get_default_vports(struct idpf_adapter *adapter)
756{
757 return le16_to_cpu(adapter->caps.default_num_vports);
758}
759
760/**
761 * idpf_get_max_vports - Get max number of vports
762 * @adapter: private data struct
763 */
764static inline u16 idpf_get_max_vports(struct idpf_adapter *adapter)
765{
766 return le16_to_cpu(adapter->caps.max_vports);
767}
768
769/**
770 * idpf_get_max_tx_bufs - Get max scatter-gather buffers supported by the device
771 * @adapter: private data struct
772 */
773static inline unsigned int idpf_get_max_tx_bufs(struct idpf_adapter *adapter)
774{
775 return adapter->caps.max_sg_bufs_per_tx_pkt;
776}
777
778/**
779 * idpf_get_min_tx_pkt_len - Get min packet length supported by the device
780 * @adapter: private data struct
781 */
782static inline u8 idpf_get_min_tx_pkt_len(struct idpf_adapter *adapter)
783{
784 u8 pkt_len = adapter->caps.min_sso_packet_len;
785
786 return pkt_len ? pkt_len : IDPF_TX_MIN_PKT_LEN;
787}
788
789/**
790 * idpf_get_reg_addr - Get BAR0 register address
791 * @adapter: private data struct
792 * @reg_offset: register offset value
793 *
794 * Based on the register offset, return the actual BAR0 register address
795 */
796static inline void __iomem *idpf_get_reg_addr(struct idpf_adapter *adapter,
797 resource_size_t reg_offset)
798{
799 return (void __iomem *)(adapter->hw.hw_addr + reg_offset);
800}
801
802/**
803 * idpf_is_reset_detected - check if we were reset at some point
804 * @adapter: driver specific private structure
805 *
806 * Returns true if we are either in reset currently or were previously reset.
807 */
808static inline bool idpf_is_reset_detected(struct idpf_adapter *adapter)
809{
810 if (!adapter->hw.arq)
811 return true;
812
813 return !(readl(idpf_get_reg_addr(adapter, adapter->hw.arq->reg.len)) &
814 adapter->hw.arq->reg.len_mask);
815}
816
817/**
818 * idpf_is_reset_in_prog - check if reset is in progress
819 * @adapter: driver specific private structure
820 *
821 * Returns true if hard reset is in progress, false otherwise
822 */
823static inline bool idpf_is_reset_in_prog(struct idpf_adapter *adapter)
824{
825 return (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags) ||
826 test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||
827 test_bit(IDPF_HR_DRV_LOAD, adapter->flags));
828}
829
830/**
831 * idpf_netdev_to_vport - get a vport handle from a netdev
832 * @netdev: network interface device structure
833 */
834static inline struct idpf_vport *idpf_netdev_to_vport(struct net_device *netdev)
835{
836 struct idpf_netdev_priv *np = netdev_priv(netdev);
837
838 return np->vport;
839}
840
841/**
842 * idpf_netdev_to_adapter - Get adapter handle from a netdev
843 * @netdev: Network interface device structure
844 */
845static inline struct idpf_adapter *idpf_netdev_to_adapter(struct net_device *netdev)
846{
847 struct idpf_netdev_priv *np = netdev_priv(netdev);
848
849 return np->adapter;
850}
851
852/**
853 * idpf_is_feature_ena - Determine if a particular feature is enabled
854 * @vport: Vport to check
855 * @feature: Netdev flag to check
856 *
857 * Returns true or false if a particular feature is enabled.
858 */
859static inline bool idpf_is_feature_ena(const struct idpf_vport *vport,
860 netdev_features_t feature)
861{
862 return vport->netdev->features & feature;
863}
864
865/**
866 * idpf_get_max_tx_hdr_size -- get the size of tx header
867 * @adapter: Driver specific private structure
868 */
869static inline u16 idpf_get_max_tx_hdr_size(struct idpf_adapter *adapter)
870{
871 return le16_to_cpu(adapter->caps.max_tx_hdr_size);
872}
873
874/**
875 * idpf_vport_ctrl_lock - Acquire the vport control lock
876 * @netdev: Network interface device structure
877 *
878 * This lock should be used by non-datapath code to protect against vport
879 * destruction.
880 */
881static inline void idpf_vport_ctrl_lock(struct net_device *netdev)
882{
883 struct idpf_netdev_priv *np = netdev_priv(netdev);
884
885 mutex_lock(&np->adapter->vport_ctrl_lock);
886}
887
888/**
889 * idpf_vport_ctrl_unlock - Release the vport control lock
890 * @netdev: Network interface device structure
891 */
892static inline void idpf_vport_ctrl_unlock(struct net_device *netdev)
893{
894 struct idpf_netdev_priv *np = netdev_priv(netdev);
895
896 mutex_unlock(&np->adapter->vport_ctrl_lock);
897}
898
899void idpf_statistics_task(struct work_struct *work);
900void idpf_init_task(struct work_struct *work);
901void idpf_service_task(struct work_struct *work);
902void idpf_mbx_task(struct work_struct *work);
903void idpf_vc_event_task(struct work_struct *work);
904void idpf_dev_ops_init(struct idpf_adapter *adapter);
905void idpf_vf_dev_ops_init(struct idpf_adapter *adapter);
906int idpf_vport_adjust_qs(struct idpf_vport *vport);
907int idpf_init_dflt_mbx(struct idpf_adapter *adapter);
908void idpf_deinit_dflt_mbx(struct idpf_adapter *adapter);
909int idpf_vc_core_init(struct idpf_adapter *adapter);
910void idpf_vc_core_deinit(struct idpf_adapter *adapter);
911int idpf_intr_req(struct idpf_adapter *adapter);
912void idpf_intr_rel(struct idpf_adapter *adapter);
913int idpf_get_reg_intr_vecs(struct idpf_vport *vport,
914 struct idpf_vec_regs *reg_vals);
915u16 idpf_get_max_tx_hdr_size(struct idpf_adapter *adapter);
916int idpf_send_delete_queues_msg(struct idpf_vport *vport);
917int idpf_send_add_queues_msg(const struct idpf_vport *vport, u16 num_tx_q,
918 u16 num_complq, u16 num_rx_q, u16 num_rx_bufq);
919int idpf_initiate_soft_reset(struct idpf_vport *vport,
920 enum idpf_vport_reset_cause reset_cause);
921int idpf_send_enable_vport_msg(struct idpf_vport *vport);
922int idpf_send_disable_vport_msg(struct idpf_vport *vport);
923int idpf_send_destroy_vport_msg(struct idpf_vport *vport);
924int idpf_send_get_rx_ptype_msg(struct idpf_vport *vport);
925int idpf_send_ena_dis_loopback_msg(struct idpf_vport *vport);
926int idpf_send_get_set_rss_key_msg(struct idpf_vport *vport, bool get);
927int idpf_send_get_set_rss_lut_msg(struct idpf_vport *vport, bool get);
928int idpf_send_dealloc_vectors_msg(struct idpf_adapter *adapter);
929int idpf_send_alloc_vectors_msg(struct idpf_adapter *adapter, u16 num_vectors);
930void idpf_deinit_task(struct idpf_adapter *adapter);
931int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,
932 u16 *q_vector_idxs,
933 struct idpf_vector_info *vec_info);
934int idpf_vport_alloc_vec_indexes(struct idpf_vport *vport);
935int idpf_send_get_stats_msg(struct idpf_vport *vport);
936int idpf_get_vec_ids(struct idpf_adapter *adapter,
937 u16 *vecids, int num_vecids,
938 struct virtchnl2_vector_chunks *chunks);
939int idpf_recv_mb_msg(struct idpf_adapter *adapter, u32 op,
940 void *msg, int msg_size);
941int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op,
942 u16 msg_size, u8 *msg);
943void idpf_set_ethtool_ops(struct net_device *netdev);
944int idpf_vport_alloc_max_qs(struct idpf_adapter *adapter,
945 struct idpf_vport_max_q *max_q);
946void idpf_vport_dealloc_max_qs(struct idpf_adapter *adapter,
947 struct idpf_vport_max_q *max_q);
948int idpf_add_del_mac_filters(struct idpf_vport *vport,
949 struct idpf_netdev_priv *np,
950 bool add, bool async);
951int idpf_set_promiscuous(struct idpf_adapter *adapter,
952 struct idpf_vport_user_config_data *config_data,
953 u32 vport_id);
954int idpf_send_disable_queues_msg(struct idpf_vport *vport);
955void idpf_vport_init(struct idpf_vport *vport, struct idpf_vport_max_q *max_q);
956u32 idpf_get_vport_id(struct idpf_vport *vport);
957int idpf_vport_queue_ids_init(struct idpf_vport *vport);
958int idpf_queue_reg_init(struct idpf_vport *vport);
959int idpf_send_config_queues_msg(struct idpf_vport *vport);
960int idpf_send_enable_queues_msg(struct idpf_vport *vport);
961int idpf_send_create_vport_msg(struct idpf_adapter *adapter,
962 struct idpf_vport_max_q *max_q);
963int idpf_check_supported_desc_ids(struct idpf_vport *vport);
964void idpf_vport_intr_write_itr(struct idpf_q_vector *q_vector,
965 u16 itr, bool tx);
966int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map);
967int idpf_send_set_sriov_vfs_msg(struct idpf_adapter *adapter, u16 num_vfs);
968int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs);
969
970u8 idpf_vport_get_hsplit(const struct idpf_vport *vport);
971bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val);
972
973#endif /* !_IDPF_H_ */