├── COPYING
├── README
├── SUMS
├── i40e.7
├── i40e.spec
├── pci.updates
├── scripts
    ├── check_aux_bus
    ├── dump_tables
    ├── set_irq_affinity
    └── virt_perf_default
└── src
    ├── Makefile
    ├── Module.supported
    ├── auxiliary.c
    ├── auxiliary_compat.h
    ├── common.mk
    ├── i40e.h
    ├── i40e_adminq.c
    ├── i40e_adminq.h
    ├── i40e_adminq_cmd.h
    ├── i40e_alloc.h
    ├── i40e_client.c
    ├── i40e_client.h
    ├── i40e_common.c
    ├── i40e_dcb.c
    ├── i40e_dcb.h
    ├── i40e_dcb_nl.c
    ├── i40e_ddp.c
    ├── i40e_debugfs.c
    ├── i40e_devids.h
    ├── i40e_diag.c
    ├── i40e_diag.h
    ├── i40e_ethtool.c
    ├── i40e_ethtool_stats.h
    ├── i40e_filters.c
    ├── i40e_filters.h
    ├── i40e_helper.h
    ├── i40e_hmc.c
    ├── i40e_hmc.h
    ├── i40e_lan_hmc.c
    ├── i40e_lan_hmc.h
    ├── i40e_main.c
    ├── i40e_nvm.c
    ├── i40e_osdep.h
    ├── i40e_prototype.h
    ├── i40e_ptp.c
    ├── i40e_register.h
    ├── i40e_status.h
    ├── i40e_trace.h
    ├── i40e_txrx.c
    ├── i40e_txrx.h
    ├── i40e_txrx_common.h
    ├── i40e_type.h
    ├── i40e_virtchnl_pf.c
    ├── i40e_virtchnl_pf.h
    ├── i40e_xsk.c
    ├── i40e_xsk.h
    ├── kcompat-generator.sh
    ├── kcompat-lib.sh
    ├── kcompat.c
    ├── kcompat.h
    ├── kcompat_defs.h
    ├── kcompat_gcc.h
    ├── kcompat_impl.h
    ├── kcompat_overflow.h
    ├── kcompat_rhel_defs.h
    ├── kcompat_sles_defs.h
    ├── kcompat_std_defs.h
    ├── kcompat_ubuntu_defs.h
    ├── kcompat_vfd.c
    ├── kcompat_vfd.h
    ├── linux
        └── auxiliary_bus.h
    └── virtchnl.h


/SUMS:
--------------------------------------------------------------------------------
 1 | 08419     4 i40e-2.23.17/i40e.7
 2 | 12529    18 i40e-2.23.17/COPYING
 3 | 42001     5 i40e-2.23.17/scripts/virt_perf_default
 4 | 58887     9 i40e-2.23.17/scripts/set_irq_affinity
 5 | 21632     8 i40e-2.23.17/scripts/check_aux_bus
 6 | 60555     2 i40e-2.23.17/scripts/dump_tables
 7 | 42011     8 i40e-2.23.17/pci.updates
 8 | 58831    96 i40e-2.23.17/README
 9 | 37503    12 i40e-2.23.17/i40e.spec
10 | 59020     4 i40e-2.23.17/src/linux/auxiliary_bus.h
11 | 07430    22 i40e-2.23.17/src/i40e_client.c
12 | 39892     4 i40e-2.23.17/src/kcompat_gcc.h
13 | 02850     6 i40e-2.23.17/src/i40e_txrx_common.h
14 | 51639     1 i40e-2.23.17/src/kcompat_defs.h
15 | 30163    78 i40e-2.23.17/src/i40e_debugfs.c
16 | 09004     1 i40e-2.23.17/src/i40e_diag.h
17 | 40479     1 i40e-2.23.17/src/i40e_filters.h
18 | 28000     3 i40e-2.23.17/src/i40e_status.h
19 | 52122    14 i40e-2.23.17/src/kcompat-generator.sh
20 | 37033     8 i40e-2.23.17/src/kcompat-lib.sh
21 | 20294     7 i40e-2.23.17/src/Makefile
22 | 47574    10 i40e-2.23.17/src/kcompat_overflow.h
23 | 43934    19 i40e-2.23.17/src/common.mk
24 | 31117     7 i40e-2.23.17/src/i40e_virtchnl_pf.h
25 | 19880   134 i40e-2.23.17/src/i40e_txrx.c
26 | 45798   224 i40e-2.23.17/src/i40e_ethtool.c
27 | 34250     2 i40e-2.23.17/src/kcompat_ubuntu_defs.h
28 | 38939    74 i40e-2.23.17/src/kcompat.c
29 | 46463     3 i40e-2.23.17/src/i40e_xsk.h
30 | 37051     5 i40e-2.23.17/src/i40e_lan_hmc.h
31 | 31652    34 i40e-2.23.17/src/i40e_lan_hmc.c
32 | 20417     6 i40e-2.23.17/src/i40e_trace.h
33 | 18182     1 i40e-2.23.17/src/Module.supported
34 | 57162     3 i40e-2.23.17/src/i40e_osdep.h
35 | 35753    58 i40e-2.23.17/src/i40e_dcb.c
36 | 23438     2 i40e-2.23.17/src/i40e_devids.h
37 | 03635    38 i40e-2.23.17/src/i40e_xsk.c
38 | 02635    14 i40e-2.23.17/src/i40e_ddp.c
39 | 09035     8 i40e-2.23.17/src/kcompat_vfd.h
40 | 63420     5 i40e-2.23.17/src/auxiliary_compat.h
41 | 15921     8 i40e-2.23.17/src/auxiliary.c
42 | 45633     4 i40e-2.23.17/src/i40e_diag.c
43 | 19713     8 i40e-2.23.17/src/i40e_hmc.h
44 | 57391    49 i40e-2.23.17/src/i40e_nvm.c
45 | 34091     7 i40e-2.23.17/src/i40e_client.h
46 | 09692    10 i40e-2.23.17/src/i40e_hmc.c
47 | 62300    91 i40e-2.23.17/src/i40e_adminq_cmd.h
48 | 24127     4 i40e-2.23.17/src/i40e_helper.h
49 | 14398    76 i40e-2.23.17/src/kcompat_vfd.c
50 | 08193    55 i40e-2.23.17/src/i40e_ptp.c
51 | 41714     8 i40e-2.23.17/src/kcompat_sles_defs.h
52 | 60127    10 i40e-2.23.17/src/i40e_ethtool_stats.h
53 | 43576     2 i40e-2.23.17/src/i40e_alloc.h
54 | 46067    10 i40e-2.23.17/src/kcompat_std_defs.h
55 | 22763   216 i40e-2.23.17/src/kcompat.h
56 | 53759    30 i40e-2.23.17/src/i40e_dcb_nl.c
57 | 10266    26 i40e-2.23.17/src/i40e_prototype.h
58 | 58182    22 i40e-2.23.17/src/i40e_txrx.h
59 | 36726     6 i40e-2.23.17/src/kcompat_rhel_defs.h
60 | 10641    74 i40e-2.23.17/src/virtchnl.h
61 | 31584   523 i40e-2.23.17/src/i40e_main.c
62 | 02089     9 i40e-2.23.17/src/i40e_dcb.h
63 | 46314   245 i40e-2.23.17/src/i40e_virtchnl_pf.c
64 | 58911    50 i40e-2.23.17/src/i40e_type.h
65 | 26033     4 i40e-2.23.17/src/i40e_adminq.h
66 | 60492     2 i40e-2.23.17/src/i40e_filters.c
67 | 39407    61 i40e-2.23.17/src/kcompat_impl.h
68 | 54262    50 i40e-2.23.17/src/i40e.h
69 | 11111   214 i40e-2.23.17/src/i40e_common.c
70 | 42075    34 i40e-2.23.17/src/i40e_adminq.c
71 | 25109   369 i40e-2.23.17/src/i40e_register.h
72 | 


--------------------------------------------------------------------------------
/i40e.7:
--------------------------------------------------------------------------------
 1 | .\" LICENSE
 2 | .\"
 3 | .\" This software program is released under the terms of a license agreement between you ('Licensee') and Intel. Do not use or load this software or any associated materials (collectively, the 'Software') until you have carefully read the full terms and conditions of the LICENSE located in this software package. By loading or using the Software, you agree to the terms of this Agreement. If you do not agree with the terms of this Agreement, do not install or use the Software.
 4 | .\"
 5 | .\" * Other names and brands may be claimed as the property of others.
 6 | .\"
 7 | .
 8 | .TH i40e 1 "February 24, 2022"
 9 | .SH NAME
10 | i40e \-This file describes the Linux* Base Driver
11 | for the Intel Ethernet Controller XL710 Family of Controllers.
12 | .SH SYNOPSIS
13 | .PD 0.4v
14 | modprobe i40e [<option>=<VAL1>,<VAL2>,...]
15 | .PD 1v
16 | .SH DESCRIPTION
17 | This driver is intended for \fB2.6.32\fR and newer kernels. A version of the driver may already be included by your distribution and/or the kernel.org kernel.
18 | 
19 | This driver includes support for any 64 bit Linux supported system, x86_64, PPC64, ARM, etc.
20 | .LP
21 | This driver is only supported as a loadable module at this time. Intel is not supplying patches against the kernel source to allow for static linking of the drivers.
22 | 
23 | 
24 | For questions related to hardware requirements, refer to the documentation
25 | supplied with your Intel adapter. All hardware requirements listed apply to
26 | use with Linux.
27 | .LP
28 | .B Jumbo Frames
29 | .IP
30 | Jumbo Frames support is enabled by changing the Maximum Transmission Unit (MTU) to a value larger than the default value of 1500.
31 | 
32 | .IP
33 | Use the ip command to increase the MTU size. For example, enter the following where <ethX> is the interface number:
34 | 
35 | .IP
36 | # ip link set mtu 9000 dev <ethX>
37 | .IP
38 | # ip link set up dev <ethX>
39 | 
40 | .LP
41 | NOTE: The maximum MTU setting for jumbo frames is 9702. This corresponds to the maximum jumbo frame size of 9728 bytes.
42 | 
43 | NOTE: This driver will attempt to use multiple page sized buffers to receive each jumbo packet. This should help to avoid buffer starvation issues when allocating receive packets.
44 | 
45 | NOTE: Packet loss may have a greater impact on throughput when you use jumbo frames. If you observe a drop in performance after enabling jumbo frames, enabling flow control may mitigate the issue.
46 | See the section "Jumbo Frames" in the Readme.
47 | .LP
48 | .B EEE (Energy Efficient Ethernet)
49 | .IP
50 | .B Valid Range: 0-1
51 | .IP
52 | 0 = Disables EEE
53 | .IP
54 | 1 = Enables EEE
55 | .IP
56 | 
57 | A link between two EEE-compliant devices will result in periodic bursts of data followed by periods where the link is in an idle state. This Low Power Idle (LPI) state is supported at 2.5 Gbps and 5 Gbps link speeds.
58 | 
59 | NOTES:
60 | - EEE support requires auto-negotiation.
61 | - Both link partners must support EEE.
62 | - EEE is not supported on all Intel(R) Ethernet Network devices or at all link speeds.
63 | 
64 | Example:
65 | 
66 | # ethtool --show-eee <ethX>
67 | # ethtool --set-eee <ethX> [eee on|off]
68 | .SH SUPPORT
69 | .LP
70 | For additional information regarding building and installation, see the
71 | README
72 | included with the driver.
73 | For general information, go to the Intel support website at:
74 | .B http://www.intel.com/support/
75 | 
76 | .LP
77 | If an issue is identified with the released source code on a supported kernel with a supported adapter, email the specific information related to the issue to e1000-devel@lists.sf.net.
78 | .LP
79 | 


--------------------------------------------------------------------------------
/pci.updates:
--------------------------------------------------------------------------------
  1 | # SPDX-License-Identifier: GPL-2.0-only
  2 | # Copyright (C) 2013-2023 Intel Corporation
  3 | 
  4 | # updates for the system pci.ids file
  5 | #
  6 | # IMPORTANT!  Entries in this list must be sorted as they
  7 | #             would appear in the system pci.ids file.  Entries
  8 | #             are sorted by ven, dev, subven, subdev
  9 | #             (numerical order). Also, no OEM names in strings.
 10 | #             The oem vendor id will sub into the name when
 11 | #             the string is consumed by the tools using it.
 12 | #
 13 | 8086  Intel Corporation
 14 | 	0dd2  Ethernet Network Adapter I710
 15 | 		1137 0000  I710T4LG 4x1 GbE RJ45 PCIe NIC
 16 | 		1137 02e3  I710T4LG 4x1 GbE RJ45 PCIe NIC
 17 | 		8086 0000  Ethernet Network Adapter I710-T4L
 18 | 		8086 000d  Ethernet Network Adapter I710-T4L
 19 | 		8086 0010  Ethernet Network Adapter I710-T4L for OCP 3.0
 20 | 		8086 401a  Ethernet Network Adapter I710-T4L
 21 | 		8086 401b  Ethernet Network Adapter I710-T4L for OCP 3.0
 22 | 	0dda  Ethernet Connection X722 for 10GbE SFP+
 23 | 		1bd4 0076  Ethernet Connection F102IX722 for 10GbE SFP
 24 | 	1572  Ethernet Controller X710 for 10GbE SFP+
 25 | 		1028 0000  Ethernet 10G X710 rNDC
 26 | 		1028 1f99  Ethernet 10G 4P X710/I350 rNDC
 27 | 		1028 1f9c  Ethernet 10G 4P X710 SFP+ rNDC
 28 | 		103c 0000  Ethernet 10Gb 562SFP+ Adapter
 29 | 		103c 22fc  Ethernet 10Gb 2-port 562FLR-SFP+ Adapter
 30 | 		103c 22fd  Ethernet 10Gb 2-port 562SFP+ Adapter
 31 | 		1137 0000  Ethernet Converged NIC X710-DA
 32 | 		1137 013b  Ethernet Converged NIC X710-DA4
 33 | 		1137 020a  Ethernet Converged NIC X710-DA2
 34 | 		17aa 0000  ThinkServer X710 AnyFabric for 10GbE SFP+
 35 | 		17aa 4001  ThinkServer X710-4 AnyFabric for 10GbE SFP+
 36 | 		17aa 4002  ThinkServer X710-2 AnyFabric for 10GbE SFP+
 37 | 		8086 0000  Ethernet Converged Network Adapter X710
 38 | 		8086 0001  Ethernet Converged Network Adapter X710-4
 39 | 		8086 0002  Ethernet Converged Network Adapter X710-4
 40 | 		8086 0004  Ethernet Converged Network Adapter X710-4
 41 | 		8086 0005  Ethernet Converged Network Adapter X710
 42 | 		8086 0006  Ethernet Converged Network Adapter X710
 43 | 		8086 0007  Ethernet Converged Network Adapter X710-2
 44 | 		8086 0008  Ethernet Converged Network Adapter X710-2
 45 | 		8086 0009  Ethernet Controller X710 for 10GbE SFP+
 46 | 		8086 000a  Ethernet Controller X710 for 10GbE SFP+
 47 | 		8086 000b  Ethernet Server Adapter X710-DA2 for OCP
 48 | 		8086 000d  Ethernet Controller X710 for 10GbE SFP+
 49 | 		8086 000e  Ethernet Server Adapter OCP X710-2
 50 | 		8086 000f  Ethernet Server Adapter OCP X710-2
 51 | 		8086 4005  Ethernet Controller X710 for 10GbE SFP+
 52 | 		8086 4006  Ethernet Controller X710 for 10GbE SFP+
 53 | 		8086 4007  Ethernet Controller X710 for 10GbE SFP+
 54 | 	1574  Ethernet Controller XL710 Emulation
 55 | 	1580  Ethernet Controller XL710 for 40GbE backplane
 56 | 	1581  Ethernet Controller X710 for 10GbE backplane
 57 | 		1028 0000  Ethernet 10G X710-k bNDC
 58 | 		1028 1f98  Ethernet 10G 4P X710-k bNDC
 59 | 		1028 1f9e  Ethernet 10G 2P X710-k bNDC
 60 | 		1590 0000  Ethernet 10Gb 2-port 563i Adapter
 61 | 		1590 00f8  Ethernet 10Gb 2-port 563i Adapter
 62 | 		8086 0000  Ethernet Converged Network Adapter XL710-Q2
 63 | 	1583  Ethernet Controller XL710 for 40GbE QSFP+
 64 | 		1028 0000  Ethernet 40G 2P XL710 QSFP+ rNDC
 65 | 		1028 1f9f  Ethernet 40G 2P XL710 QSFP+ rNDC
 66 | 		108e 0000  10Gb/40Gb Ethernet Adapter
 67 | 		108e 7b1d  10Gb/40Gb Ethernet Adapter
 68 | 		1137 0000  Ethernet Converged NIC XL710-QDA2
 69 | 		1137 013c  Ethernet Converged NIC XL710-QDA2
 70 | 		8086 0000  Ethernet Converged Network Adapter XL710-Q2
 71 | 		8086 0001  Ethernet Converged Network Adapter XL710-Q2
 72 | 		8086 0002  Ethernet Converged Network Adapter XL710-Q2
 73 | 		8086 0003  Ethernet I/O Module XL710-Q2
 74 | 		8086 0004  Ethernet Server Adapter XL710-Q2OCP
 75 | 		8086 0006  Ethernet Converged Network Adapter XL710-Q2
 76 | 	1584  Ethernet Controller XL710 for 40GbE QSFP+
 77 | 		8086 0000  Ethernet Converged Network Adapter XL710-Q1
 78 | 		8086 0001  Ethernet Converged Network Adapter XL710-Q1
 79 | 		8086 0002  Ethernet Converged Network Adapter XL710-Q1
 80 | 		8086 0003  Ethernet I/O Module XL710-Q1
 81 | 		8086 0004  Ethernet Server Adapter XL710-Q1OCP
 82 | 	1585  Ethernet Controller X710 for 10GbE QSFP+
 83 | 	1586  Ethernet Controller X710 for 10GBASE-T
 84 | 		108e 0000  Ethernet Controller X710 for 10GBASE-T
 85 | 		108e 4857  Ethernet Controller X710 for 10GBASE-T
 86 | 	1587  Ethernet Controller XL710 for 20GbE backplane
 87 | 		103c 0000  Eth 10/20Gb 2p 660FLB Adptr
 88 | 		103c 22fe  Eth 10/20Gb 2p 660FLB Adptr
 89 | 	1588  Ethernet Controller XL710 for 20GbE backplane
 90 | 		103c 0000  Eth 10/20Gb 2p 660M Adptr
 91 | 		103c 22ff  Eth 10/20Gb 2p 660M Adptr
 92 | 	1589  Ethernet Controller X710/X557-AT 10GBASE-T
 93 | 		108e 0000  Quad Port 10GBase-T Adapter
 94 | 		108e 7b1c  Quad Port 10GBase-T Adapter
 95 | 		8086 0000  Ethernet Converged Network Adapter X710-T
 96 | 		8086 0001  Ethernet Converged Network Adapter X710-T4
 97 | 		8086 0002  Ethernet Converged Network Adapter X710-T4
 98 | 		8086 0003  Ethernet Converged Network Adapter X710-T
 99 | 		8086 00a0  Ethernet Converged Network Adapter X710-T4
100 | 	158a  Ethernet Controller XXV710 for 25GbE backplane
101 | 		1590 0000  10/25Gb Ethernet Adapter
102 | 		1590 0286  Synergy 4610C 10/25Gb Ethernet Adapter
103 | 		8086 0000  Ethernet Controller XXV710 for 25GbE backplane
104 | 		8086 000a  Ethernet 25G 2P XXV710 Mezz
105 | 	158b  Ethernet Controller XXV710 for 25GbE SFP28
106 | 		1590 0000  Ethernet Network Adapter XXV710-2
107 | 		1590 0253  Ethernet 10/25/Gb 2-port 661SFP28 Adapter
108 | 		8086 0000  Ethernet Network Adapter XXV710
109 | 		8086 0001  Ethernet Network Adapter XXV710-2
110 | 		8086 0002  Ethernet Network Adapter XXV710-2
111 | 		8086 0003  Ethernet Network Adapter XXV710-1
112 | 		8086 0004  Ethernet Network Adapter XXV710-1
113 | 		8086 0005  Ethernet Network Adapter OCP XXV710-2
114 | 		8086 0006  Ethernet Network Adapter OCP XXV710-2
115 | 		8086 0007  Ethernet Network Adapter OCP XXV710-1
116 | 		8086 0008  Ethernet Network Adapter OCP XXV710-1
117 | 		8086 0009  Ethernet 25G 2P XXV710 Adapter
118 | 		8086 000c  Ethernet Network Adapter XXV710-DA2 for OCP 3.0
119 | 		8086 000d  Ethernet 25G 2P XXV710 OCP
120 | 		8086 4001  Ethernet Network Adapter XXV710-2
121 | 	15ff  Ethernet Controller X710 for 10GBASE-T
122 | 		1137 02c1  Ethernet Network Adapter X710-T2L
123 | 		8086 0000  Ethernet Network Adapter X710-TL
124 | 		8086 0001  Ethernet Network Adapter X710-T4L
125 | 		8086 0002  Ethernet Network Adapter X710-T4L
126 | 		8086 0003  Ethernet Network Adapter X710-T2L
127 | 		8086 0004  Ethernet Network Adapter X710-T2L
128 | 		8086 0005  Ethernet 10G 2P X710-T2L-t Adapter
129 | 		8086 0006  Ethernet 10G 4P X710-T4L-t Adapter
130 | 		8086 0007  Ethernet 10G 2P X710-T2L-t OCP
131 | 		8086 0008  Ethernet 10G 4P X710-T4L-t OCP
132 | 		8086 0009  Ethernet Network Adapter X710-T4L for OCP 3.0
133 | 		8086 000a  Ethernet Network Adapter X710-T4L for OCP 3.0
134 | 		8086 000b  Ethernet Network Adapter X710-T2L for OCP 3.0
135 | 		8086 000c  Ethernet Network Adapter X710-T2L for OCP 3.0
136 | 		8086 000d  Ethernet 10G 2P X710-T2L-t OCP
137 | 		8086 000f  Ethernet Network Adapter X710-T2L for OCP 3.0
138 | 		8086 4009  Ethernet Network Adapter X710-T2L
139 | 		8086 4012  Ethernet Network Adapter X710-T4L for OCP 3.0
140 | 		8086 4018  Ethernet Network Adapter X710-T2L for OCP 3.0
141 | 		8086 4019  Ethernet Network Adapter X710-T4L
142 | 	37ce  Ethernet Connection X722 for 10GbE backplane
143 | 		1590 0215  Ethernet 10Gb 2-port 568i Adapter
144 | 		17aa 4023  Ethernet Connection X722 for 10GbE backplane
145 | 	37cf  Ethernet Connection X722 for 10GbE QSFP+
146 | 	37d0  Ethernet Connection X722 for 10GbE SFP+
147 | 		8086 0001  Ethernet Network Adapter X722-2
148 | 		8086 0002  Ethernet Network Adapter X722-2
149 | 		8086 0003  Ethernet Network Adapter X722-4
150 | 		8086 0004  Ethernet Network Adapter X722-4
151 | 	37d1  Ethernet Connection X722 for 1GbE
152 | 		1590 0216  Ethernet 1Gb 2-port 368i Adapter
153 | 		1590 0217  Ethernet 1Gb 2-port 368FLR-MMT Adapter
154 | 		1590 0247  Ethernet 1Gb 4-port 369i Adapter
155 | 		17aa 4020  Ethernet Connection X722 for 1GbE
156 | 		17aa 4021  Ethernet Connection X722 for 1GbE
157 | 		17aa 4022  Ethernet Connection X722 for 1GbE
158 | 		17aa 4024  Ethernet Connection X722 for 1GbE
159 | 	37d2  Ethernet Connection X722 for 10GBASE-T
160 | 		1590 0218  Ethernet 10Gb 2-port 568FLR-MMT Adapter
161 | 		17aa 4020  Ethernet Connection X722 for 10GBASE-T
162 | 		17aa 4021  Ethernet Connection X722 for 10GBASE-T
163 | 		17aa 4024  Ethernet Connection X722 for 10GBASE-T
164 | 	37d3  Ethernet Connection X722 for 10GbE SFP+
165 | 		1590 0219  Ethernet 10Gb 2-port 568FLR-MMSFP+ Adapter
166 | 		17aa 4020  Ethernet Connection X722 for 10GbE SFP+
167 | 		17aa 4021  Ethernet Connection X722 for 10GbE SFP+
168 | 


--------------------------------------------------------------------------------
/scripts/check_aux_bus:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # SPDX-License-Identifier: BSD-3-Clause
  3 | # Copyright (C) 2021 - 2023 Intel Corporation
  4 | #
  5 | # Helper script to detect if auxiliary bus support. This script
  6 | #
  7 | # returns 0 when:
  8 | # - CONFIG_AUXILIARY_BUS=y
  9 | # - auxiliary_bus.h was found
 10 | #
 11 | # Returning 0 means the driver build/install doesn't need OOT
 12 | # auxiliary bus
 13 | #
 14 | # returns 1 when:
 15 | #	- CONFIG_AUXILIARY_BUS=n (or any value that's not "=y")
 16 | #	- kernel configuration was incorrect
 17 | #	- kernel configuration file was not found
 18 | #
 19 | # Returning 1 means something bad/unexpected happened and the
 20 | # driver build/install should treat this as a failure
 21 | #
 22 | # returns 2 when:
 23 | #	-  When OOT auxiliary is needed regardless if a previous OOT
 24 | #	   auxiliary was already. This is done because the driver
 25 | #	   always needs to build against auxiliary.o to avoid
 26 | #	   warnings/errors since auxiliary.o is built-in to the
 27 | #	   driver's makefile
 28 | #
 29 | # Returning 2 means the driver build/install needs OOT auxiliary
 30 | # bus
 31 | #
 32 | # returns 3 when:
 33 | #	- A file and/or directory does not exist
 34 | #
 35 | # Returning 3 means something bad/unexpected happened and the
 36 | # driver build/install should treat this as a failure
 37 | #
 38 | # Note: when ksrc and build-kernel are both specified on the
 39 | # command line and build-kernel is not in the same location
 40 | # as ksrc, then ksrc takes precedence. For example:
 41 | # 	./check_aux_bus --ksrc=/lib/modules/5.8.0/source --build-kernel=5.10.0
 42 | #
 43 | # In this case the kernel config file won't be searched for and
 44 | # the script will only check to see if the in-tree/OOT auxiliary_bus.h
 45 | # file exists at ksrc.
 46 | 
 47 | msg()
 48 | {
 49 | 	if [ $verbose == 1 ]; then
 50 | 		echo -e $1
 51 | 	fi
 52 | }
 53 | 
 54 | exit_builtin_auxiliary_enabled() { exit 0; }
 55 | exit_kconfig_invalid() { exit 1; }
 56 | exit_need_oot_auxiliary() { exit 2; }
 57 | exit_not_found_failure() { exit 3; }
 58 | 
 59 | find_aux_bus_inc()
 60 | {
 61 | 	aux_bus_inc=$(find -L ${ksrc} -name "auxiliary_bus.h")
 62 | 	msg "auxiliary_bus.h location: ${aux_bus_inc}"
 63 | }
 64 | 
 65 | LINUX_INCLUDE_DIR="include/linux"
 66 | 
 67 | set_build_kernel()
 68 | {
 69 | 	build_kernel=$(uname -r)
 70 | }
 71 | 
 72 | find_kernel_source()
 73 | {
 74 | 	# All the default places to look for kernel source
 75 | 	test_dirs=(/lib/modules/${build_kernel}/source \
 76 | 		   /lib/modules/${build_kernel}/build \
 77 | 		   /usr/src/linux-${build_kernel} \
 78 | 		   /usr/src/linux-$(echo ${build_kernel} | sed 's/-.*//') \
 79 | 		   /usr/src/kernel-headers-${build_kernel} \
 80 | 		   /usr/src/kernel-source-${build_kernel} \
 81 | 		   /usr/src/linux-$(echo ${build_kernel} | sed 's/\([0-9]*\.[0-9]*\)\..*/\1/') \
 82 | 		   /usr/src/linux \
 83 | 		   /usr/src/kernels/${build_kernel} \
 84 | 		   /usr/src/kernels)
 85 | 
 86 | 	# Save the first valid kernel source path
 87 | 	for dir in "${test_dirs[@]}"; do
 88 | 		if [ -d ${dir}/${LINUX_INCLUDE_DIR} ]; then
 89 | 			ksrc=${dir}
 90 | 			break
 91 | 		fi
 92 | 	done
 93 | 
 94 | 	if [ -z ${ksrc} ]; then
 95 | 		echo "*** Kernel header files not in any of the expected locations."
 96 | 		echo "*** Install the appropriate kernel development package, e.g."
 97 | 		echo "kernel-devel, for building kernel modules and try again"
 98 | 		exit_not_found_failure
 99 | 	fi
100 | }
101 | 
102 | find_config_file()
103 | {
104 | 	# only search for kernel .config file if build_kernel is pointing
105 | 	# in the same tree as ksrc (see not about ksrc and build_kernel
106 | 	# both set in the scripts header comment)
107 | 	if [[ "$ksrc" != *"/lib/modules/${build_kernel}"* ]]; then
108 | 		msg "ksrc=$ksrc not the same as location generated from build_kernel=\"/lib/modules/${build_kernel}\", not searching for kernel .config file"
109 | 	else
110 | 		kbuild_dir="/lib/modules/${build_kernel}/build"
111 | 
112 | 		file_locations=(${kbuild_dir}/include/generated/autoconf.h \
113 | 				${kbuild_dir}/include/linux/autoconf.h \
114 | 				/boot/bmlinux.autoconf.h)
115 | 
116 | 		for file in "${file_locations[@]}"; do
117 | 			if [ -f ${file} ]; then
118 | 				kconfig=${file}
119 | 				break
120 | 			fi
121 | 		done
122 | 
123 | 		if [ -z ${kconfig} ]; then
124 | 			msg "Kernel config file not found at any of the expected locations."
125 | 		fi
126 | 	fi
127 | }
128 | 
129 | get_config_auxiliary_bus()
130 | {
131 | 	# CONFIG_AUXILIARY_BUS=0 corresponds to CONFIG_AUXILIARY_BUS=n
132 | 	# CONFIG_AUXILIARY_BUS=1 corresponds to CONFIG_AUXILIARY_BUS=y
133 | 	# CONFIG_AUXILIARY_BUS= corresponds to CONFIG_AUXILIARY_BUS not available in the kernel
134 | 	CONFIG_AUXILIARY_BUS=$(grep CONFIG_AUXILIARY_BUS ${kconfig} | awk -F" " '{print $3}')
135 | 	msg "CONFIG_AUXILIARY_BUS=${CONFIG_AUXILIARY_BUS}"
136 | }
137 | 
138 | ksrc=""
139 | build_kernel=""
140 | verbose=0
141 | 
142 | usage()
143 | {
144 | 	script=$(basename $0)
145 | 	echo -e "usage:"
146 | 	echo -e "\t$script [options]"
147 | 	echo -e "\n\toptions:"
148 | 	echo -e "\t -v, --verbose"
149 | 	echo -e "\t -h, --help"
150 | 	echo -e "\n\trun script against specified kernel source"
151 | 	echo -e "\t -k, --ksrc \"/lib/modules/5.12.0/source\""
152 | 	echo -e "\n\trun script with kernel version (kernel version used to find kernel source programatically)"
153 | 	echo -e "\t -b, --build-kernel \"5.8.0\""
154 | }
155 | 
156 | options=$(getopt -o "k:b:vh" --long ksrc:,build-kernel:,verbose,help -- "$@")
157 | eval set -- "$options"
158 | while :; do
159 | 	case $1 in
160 | 	-k|--ksrc) ksrc=$2; shift;;
161 | 	-b|--build-kernel) build_kernel=$2; shift;;
162 | 	-v|--verbose) verbose=1 ;;
163 | 	-h|--help) usage && exit 0;;
164 | 	--) shift; break;;
165 | 	 esac
166 | 	 shift
167 | done
168 | 
169 | if [ $verbose == 1 ]; then
170 | 	set -x
171 | fi
172 | 
173 | # both build_kernel and ksrc are unset so programatically determine build_kernel
174 | if [ -z $build_kernel ] && [ -z $ksrc ]; then
175 | 	set_build_kernel
176 | fi
177 | 
178 | # only programatically search for kernel source if ksrc not set on command line
179 | if [ -z $ksrc ]; then
180 | 	find_kernel_source
181 | fi
182 | 
183 | find_config_file
184 | 
185 | if [ ! -z $kconfig ]; then
186 | 	# if we found the kernel .config file then exit the script based on various
187 | 	# conditions that depend on the CONFIG_AUXILIARY_BUS string being found
188 | 	get_config_auxiliary_bus
189 | 
190 | 	if [ -z "$CONFIG_AUXILIARY_BUS" ]; then
191 | 		msg "CONFIG_AUXILIARY_BUS not found in ${kconfig}."
192 | 		# CONFIG_AUXILIARY_BUS string was not found, so OOT auxiliary is needed
193 | 		exit_need_oot_auxiliary
194 | 	elif [ "$CONFIG_AUXILIARY_BUS" = "1" ]; then
195 | 		msg "CONFIG_AUXILIARY_BUS=y in ${kconfig}."
196 | 		# CONFIG_AUXILIARY_BUS=y, so OOT auxiliary is not needed
197 | 		exit_builtin_auxiliary_enabled
198 | 	else
199 | 		msg ""
200 | 		msg "kernel $build_kernel supports auxiliary bus, but CONFIG_AUXILIARY_BUS"
201 | 		msg "is not set in ${kconfig}. Rebuild your kernel with"
202 | 		msg "CONFIG_AUXILIARY_BUS=y"
203 | 		msg ""
204 | 		# CONFIG_AUXILIARY_BUS is not "=y", but the string was found, so report
205 | 		# the failure so it can be used to fail build/install
206 | 		exit_kconfig_invalid
207 | 	fi
208 | else
209 | 	if [ ! -d ${ksrc}/${LINUX_INCLUDE_DIR} ] && [ ! -d ${ksrc}/source/${LINUX_INCLUDE_DIR} ]; then
210 | 		echo "${ksrc}/${LINUX_INCLUDE_DIR} and ${ksrc}/source/${LINUX_INCLUDE_DIR} do not exist"
211 | 		exit_not_found_failure
212 | 	fi
213 | 
214 | 	# We didn't find a kernel .config file, so check to see if auxiliary_bus.h
215 | 	# is found in the kernel source include directory
216 | 	find_aux_bus_inc
217 | 
218 | 	if [ -f "$aux_bus_inc" ]; then
219 | 		# AUXILIARY_MODULE_PREFIX is defined only in out-of-tree auxiliary bus
220 | 		if [ $(grep -c AUXILIARY_MODULE_PREFIX $aux_bus_inc) -eq 0 ]; then
221 | 			msg "in-tree auxiliary_bus.h found at ${ksrc}/${LINUX_INCLUDE_DIR}"
222 | 			# If auxiliary_bus.h is included at ${ksrc} and it isn't our OOT version, then
223 | 			# don't build OOT auxiliary as part of the driver makefile
224 | 			exit_builtin_auxiliary_enabled
225 | 		else
226 | 			msg "OOT auxiliary_bus.h found at ${ksrc}/${LINUX_INCLUDE_DIR}"
227 | 			# If auxiliary bus is included at ${ksrc} and it is our OOT version, then
228 | 			# build OOT auxiliary as part of the driver makefile
229 | 			exit_need_oot_auxiliary
230 | 		fi
231 | 	else
232 | 		msg "auxiliary_bus.h not found at ${ksrc}/${LINUX_INCLUDE_DIR}"
233 | 		exit_need_oot_auxiliary
234 | 	fi
235 | fi
236 | 


--------------------------------------------------------------------------------
/scripts/dump_tables:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Dump Tables script
 3 | # Copyright (C) 2015 - 2023 Intel Corporation
 4 | #
 5 | # This script is used to generate a dump of the hardware state for
 6 | # sending to linux.nics@intel.com for debugging purposes.  This
 7 | # script will generate a dump_tables.gz output file that can be
 8 | # uploaded or emailed.
 9 | 
10 | # Usage: dump_tables eth1
11 | 
12 | DEV=$1
13 | . /sys/class/net/$DEV/device/uevent
14 | # DRIVER=i40e
15 | # PCI_CLASS=20000
16 | # PCI_ID=8086:1583
17 | # PCI_SUBSYS_ID=8086:0002
18 | # PCI_SLOT_NAME=0000:06:00.0
19 | # MODALIAS=pci:v00008086d00001583sv00008086sd00000002bc02sc00i00
20 | 
21 | if [ "$DEV" == "" ]; then
22 | 	echo Usage: $0 "<i40e ethernet interface>"
23 | 	exit -1
24 | fi
25 | 
26 | if [ "$PCI_SLOT_NAME" == "" ]; then
27 | 	echo kernel version `uname -r` is not supported, please report the bug at e1000.sourceforge.net
28 | 	exit -2
29 | fi
30 | 
31 | CLUSTER=1
32 | TABLE=0
33 | INDEX=0
34 | 
35 | OUTFILE=`mktemp`
36 | TMPFILE=`mktemp`
37 | 
38 | # check for the debugfs directory being mounted
39 | if [ -d "/sys/kernel/debug/i40e" ]; then
40 | 	echo debugfs found
41 | else
42 | 	echo -n "mounting debugfs as /sys/kernel/debug: "
43 | 	mount -t debugfs none /sys/kernel/debug && echo Success || (echo Failure ; exit -3)
44 | fi
45 | 
46 | dmesg -c > /dev/null
47 | until [ "$TABLE" == "0xff" ]; do
48 | 	until [ "$INDEX" == "0xffffffff" ]; do
49 | 		echo dump debug fwdata $CLUSTER $TABLE $INDEX > /sys/kernel/debug/i40e/$PCI_SLOT_NAME/command
50 | 		# check output, exit if no good
51 | 		dmesg | grep -q unknown && (echo error encountered, see log; exit -4)
52 | 		# store it, without modification
53 | 		dmesg >> $OUTFILE
54 | 		# erase it and prepare for parse
55 | 		dmesg -c > $TMPFILE
56 | 		TABLE=`grep rlen $TMPFILE | sed -e 's/.*next_table=\(.*\) .*\$/\1/'`
57 | 		INDEX=`grep rlen $TMPFILE | sed -e 's/.*next_index=\(.*\)\$/\1/'`
58 | 		echo -n .
59 | 	done
60 | 	INDEX=0
61 | done
62 | 
63 | gzip $OUTFILE
64 | cp $OUTFILE.gz dump_tables.gz
65 | 
66 | rm $OUTFILE.gz
67 | rm $TMPFILE
68 | 
69 | echo Please send the file dump_tables.gz to linux.nics@intel.com or your Intel Support representative.
70 | 


--------------------------------------------------------------------------------
/scripts/set_irq_affinity:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # SPDX-License-Identifier: BSD-3-Clause
  3 | # Copyright (C) 2015 - 2023 Intel Corporation
  4 | #
  5 | # Affinitize interrupts to cores
  6 | #
  7 | # typical usage is (as root):
  8 | # set_irq_affinity -x local eth1 <eth2> <eth3>
  9 | # set_irq_affinity -s eth1
 10 | #
 11 | # to get help:
 12 | # set_irq_affinity
 13 | 
 14 | usage()
 15 | {
 16 | 	echo
 17 | 	echo "Usage: option -s <interface> to show current settings only"
 18 | 	echo "Usage: $0 [-x|-X] [all|local|remote [<node>]|one <core>|custom|<cores>] <interface> ..."
 19 | 	echo "	Options: "
 20 | 	echo "	  -s		Shows current affinity settings"
 21 | 	echo "	  -x		Configure XPS as well as smp_affinity"
 22 | 	echo "	  -X		Disable XPS but set smp_affinity"
 23 | 	echo "	  [all] is the default value"
 24 | 	echo "	  [remote [<node>]] can be followed by a specific node number"
 25 | 	echo "	Examples:"
 26 | 	echo "	  $0 -s eth1            # Show settings on eth1"
 27 | 
 28 | 	echo "	  $0 all eth1 eth2      # eth1 and eth2 to all cores"
 29 | 	echo "	  $0 one 2 eth1         # eth1 to core 2 only"
 30 | 	echo "	  $0 local eth1         # eth1 to local cores only"
 31 | 	echo "	  $0 remote eth1        # eth1 to remote cores only"
 32 | 	echo "	  $0 custom eth1        # prompt for eth1 interface"
 33 | 	echo "	  $0 0-7,16-23 eth0     # eth1 to cores 0-7 and 16-23"
 34 | 	echo
 35 | 	exit 1
 36 | }
 37 | 
 38 | usageX()
 39 | {
 40 | 	echo "options -x and -X cannot both be specified, pick one"
 41 | 	exit 1
 42 | }
 43 | 
 44 | if [ "$1" == "-x" ]; then
 45 | 	XPS_ENA=1
 46 | 	shift
 47 | fi
 48 | 
 49 | if [ "$1" == "-s" ]; then
 50 | 	SHOW=1
 51 | 	echo Show affinity settings
 52 | 	shift
 53 | fi
 54 | 
 55 | if [ "$1" == "-X" ]; then
 56 | 	if [ -n "$XPS_ENA" ]; then
 57 | 		usageX
 58 | 	fi
 59 | 	XPS_DIS=2
 60 | 	shift
 61 | fi
 62 | 
 63 | if [ "$1" == -x ]; then
 64 | 	usageX
 65 | fi
 66 | 
 67 | if [ -n "$XPS_ENA" ] && [ -n "$XPS_DIS" ]; then
 68 | 	usageX
 69 | fi
 70 | 
 71 | if [ -z "$XPS_ENA" ]; then
 72 | 	XPS_ENA=$XPS_DIS
 73 | fi
 74 | 
 75 | SED=`which sed`
 76 | if [[ ! -x $SED ]]; then
 77 | 	echo " $0: ERROR: sed not found in path, this script requires sed"
 78 | 	exit 1
 79 | fi
 80 | 
 81 | num='^[0-9]+$'
 82 | 
 83 | # search helpers
 84 | NOZEROCOMMA="s/^[0,]*//"
 85 | # Vars
 86 | AFF=$1
 87 | shift
 88 | 
 89 | case "$AFF" in
 90 |     remote)	[[ $1 =~ $num ]] && rnode=$1 && shift ;;
 91 |     one)	[[ $1 =~ $num ]] && cnt=$1 && shift ;;
 92 |     all)	;;
 93 |     local)	;;
 94 |     custom)	;;
 95 |     [0-9]*)	;;
 96 |     -h|--help)	usage ;;
 97 |     "")		usage ;;
 98 |     *)		IFACES=$AFF && AFF=all ;;	# Backwards compat mode
 99 | esac
100 | 
101 | # append the interfaces listed to the string with spaces
102 | while [ "$#" -ne "0" ] ; do
103 | 	IFACES+=" $1"
104 | 	shift
105 | done
106 | 
107 | # for now the user must specify interfaces
108 | if [ -z "$IFACES" ]; then
109 | 	usage
110 | 	exit 2
111 | fi
112 | 
113 | notfound()
114 | {
115 | 	echo $MYIFACE: not found
116 | 	exit 15
117 | }
118 | 
119 | # check the interfaces exist
120 | for MYIFACE in $IFACES; do
121 | 	grep -q $MYIFACE /proc/net/dev || notfound
122 | done
123 | 
124 | # support functions
125 | 
126 | build_mask()
127 | {
128 | 	VEC=$core
129 | 	if [ $VEC -ge 32 ]
130 | 	then
131 | 		MASK_FILL=""
132 | 		MASK_ZERO="00000000"
133 | 		let "IDX = $VEC / 32"
134 | 		for ((i=1; i<=$IDX;i++))
135 | 		do
136 | 			MASK_FILL="${MASK_FILL},${MASK_ZERO}"
137 | 		done
138 | 
139 | 		let "VEC -= 32 * $IDX"
140 | 		MASK_TMP=$((1<<$VEC))
141 | 		MASK=$(printf "%X%s" $MASK_TMP $MASK_FILL)
142 | 	else
143 | 		MASK_TMP=$((1<<$VEC))
144 | 		MASK=$(printf "%X" $MASK_TMP)
145 | 	fi
146 | }
147 | 
148 | show_affinity()
149 | {
150 | 	# returns the MASK variable
151 | 	build_mask
152 | 
153 | 	SMP_I=`sed -E "${NOZEROCOMMA}" /proc/irq/$IRQ/smp_affinity`
154 | 	HINT=`sed -E "${NOZEROCOMMA}" /proc/irq/$IRQ/affinity_hint`
155 | 	printf "ACTUAL	%s %d %s <- /proc/irq/$IRQ/smp_affinity\n" $IFACE $core $SMP_I
156 | 	printf "HINT 	%s %d %s <- /proc/irq/$IRQ/affinity_hint\n" $IFACE $core $HINT
157 | 	IRQ_CHECK=`grep '[-,]' /proc/irq/$IRQ/smp_affinity_list`
158 | 	if [ ! -z $IRQ_CHECK ]; then
159 | 		printf " WARNING -- SMP_AFFINITY is assigned to multiple cores $IRQ_CHECK\n"
160 | 	fi
161 | 	if [ "$SMP_I" != "$HINT" ]; then
162 | 		printf " WARNING -- SMP_AFFINITY VALUE does not match AFFINITY_HINT \n"
163 | 	fi
164 | 	printf "NODE 	%s %d %s <- /proc/irq/$IRQ/node\n" $IFACE $core `cat /proc/irq/$IRQ/node`
165 | 	printf "LIST	%s %d [%s] <- /proc/irq/$IRQ/smp_affinity_list\n" $IFACE $core `cat /proc/irq/$IRQ/smp_affinity_list`
166 | 	printf "XPS	%s %d %s <- /sys/class/net/%s/queues/tx-%d/xps_cpus\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_cpus` $IFACE $((n-1))
167 | 	if [ -z `ls /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_rxqs` ]; then
168 | 		echo "WARNING: xps rxqs not supported on $IFACE"
169 | 	else
170 | 		printf "XPSRXQs	%s %d %s <- /sys/class/net/%s/queues/tx-%d/xps_rxqs\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_rxqs` $IFACE $((n-1))
171 | 	fi
172 | 	printf "TX_MAX	%s %d %s <- /sys/class/net/%s/queues/tx-%d/tx_maxrate\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/tx_maxrate` $IFACE $((n-1))
173 | 	printf "BQLIMIT	%s %d %s <- /sys/class/net/%s/queues/tx-%d/byte_queue_limits/limit\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/byte_queue_limits/limit` $IFACE $((n-1))
174 | 	printf "BQL_MAX	%s %d %s <- /sys/class/net/%s/queues/tx-%d/byte_queue_limits/limit_max\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/byte_queue_limits/limit_max` $IFACE $((n-1))
175 | 	printf "BQL_MIN	%s %d %s <- /sys/class/net/%s/queues/tx-%d/byte_queue_limits/limit_min\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/tx-$((n-1))/byte_queue_limits/limit_min` $IFACE $((n-1))
176 | 	if [ -z `ls /sys/class/net/$IFACE/queues/rx-$((n-1))/rps_flow_cnt` ]; then
177 | 		echo "WARNING: aRFS is not supported on $IFACE"
178 | 	else
179 | 		printf "RPSFCNT	%s %d %s <- /sys/class/net/%s/queues/rx-%d/rps_flow_cnt\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/rx-$((n-1))/rps_flow_cnt` $IFACE $((n-1))
180 | 	fi
181 | 	if [ -z `ls /sys/class/net/$IFACE/queues/rx-$((n-1))/rps_cpus` ]; then
182 | 		echo "WARNING: rps_cpus is not available on $IFACE"
183 | 	else
184 | 		printf "RPSCPU	%s %d %s <- /sys/class/net/%s/queues/rx-%d/rps_cpus\n" $IFACE $core `cat /sys/class/net/$IFACE/queues/rx-$((n-1))/rps_cpus` $IFACE $((n-1))
185 | 	fi
186 | 	echo
187 | }
188 | 
189 | set_affinity()
190 | {
191 | 	# returns the MASK variable
192 | 	build_mask
193 | 
194 | 	printf "%s" $MASK > /proc/irq/$IRQ/smp_affinity
195 | 	printf "%s %d %s -> /proc/irq/$IRQ/smp_affinity\n" $IFACE $core $MASK
196 | 	SMP_I=`sed -E "${NOZEROCOMMA}" /proc/irq/$IRQ/smp_affinity`
197 | 	if [ "$SMP_I" != "$MASK" ]; then
198 | 		printf " ACTUAL\t%s %d %s <- /proc/irq/$IRQ/smp_affinity\n" $IFACE $core $SMP_I
199 | 		printf " WARNING -- SMP_AFFINITY setting failed\n"
200 | 	fi
201 | 	case "$XPS_ENA" in
202 | 	1)
203 | 		printf "%s %d %s -> /sys/class/net/%s/queues/tx-%d/xps_cpus\n" $IFACE $core $MASK $IFACE $((n-1))
204 | 		printf "%s" $MASK > /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_cpus
205 | 	;;
206 | 	2)
207 | 		MASK=0
208 | 		printf "%s %d %s -> /sys/class/net/%s/queues/tx-%d/xps_cpus\n" $IFACE $core $MASK $IFACE $((n-1))
209 | 		printf "%s" $MASK > /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_cpus
210 | 	;;
211 | 	*)
212 | 	esac
213 | }
214 | 
215 | # Allow usage of , or -
216 | #
217 | parse_range () {
218 |         RANGE=${@//,/ }
219 |         RANGE=${RANGE//-/..}
220 |         LIST=""
221 |         for r in $RANGE; do
222 | 		# eval lets us use vars in {#..#} range
223 |                 [[ $r =~ '..' ]] && r="$(eval echo {$r})"
224 | 		LIST+=" $r"
225 |         done
226 | 	echo $LIST
227 | }
228 | 
229 | # Affinitize interrupts
230 | #
231 | doaff()
232 | {
233 | 	CORES=$(parse_range $CORES)
234 | 	ncores=$(echo $CORES | wc -w)
235 | 	n=1
236 | 
237 | 	# this script only supports interrupt vectors in pairs,
238 | 	# modification would be required to support a single Tx or Rx queue
239 | 	# per interrupt vector
240 | 
241 | 	queues="${IFACE}-.*TxRx"
242 | 
243 | 	irqs=$(grep "$queues" /proc/interrupts | cut -f1 -d:)
244 | 	[ -z "$irqs" ] && irqs=$(grep $IFACE /proc/interrupts | cut -f1 -d:)
245 | 	[ -z "$irqs" ] && irqs=$(for i in `ls -1 /sys/class/net/${IFACE}/device/msi_irqs | sort -n` ;do grep -w $i: /proc/interrupts | egrep -v 'fdir|async|misc|ctrl' | cut -f 1 -d :; done)
246 | 	[ -z "$irqs" ] && echo "Error: Could not find interrupts for $IFACE"
247 | 
248 | 	if [ "$SHOW" == "1" ] ; then
249 | 		echo "TYPE IFACE CORE MASK -> FILE"
250 | 		echo "============================"
251 | 	else
252 | 		echo "IFACE CORE MASK -> FILE"
253 | 		echo "======================="
254 | 	fi
255 | 
256 | 	for IRQ in $irqs; do
257 | 		[ "$n" -gt "$ncores" ] && n=1
258 | 		j=1
259 | 		# much faster than calling cut for each
260 | 		for i in $CORES; do
261 | 			[ $((j++)) -ge $n ] && break
262 | 		done
263 | 		core=$i
264 | 		if [ "$SHOW" == "1" ] ; then
265 | 			show_affinity
266 | 		else
267 | 			set_affinity
268 | 		fi
269 | 		((n++))
270 | 	done
271 | }
272 | 
273 | # these next 2 lines would allow script to auto-determine interfaces
274 | #[ -z "$IFACES" ] && IFACES=$(ls /sys/class/net)
275 | #[ -z "$IFACES" ] && echo "Error: No interfaces up" && exit 1
276 | 
277 | # echo IFACES is $IFACES
278 | 
279 | CORES=$(</sys/devices/system/cpu/online)
280 | [ "$CORES" ] || CORES=$(grep ^proc /proc/cpuinfo | cut -f2 -d:)
281 | 
282 | # Core list for each node from sysfs
283 | node_dir=/sys/devices/system/node
284 | for i in $(ls -d $node_dir/node*); do
285 | 	i=${i/*node/}
286 | 	corelist[$i]=$(<$node_dir/node${i}/cpulist)
287 | done
288 | 
289 | for IFACE in $IFACES; do
290 | 	# echo $IFACE being modified
291 | 
292 | 	dev_dir=/sys/class/net/$IFACE/device
293 | 	[ -e $dev_dir/numa_node ] && node=$(<$dev_dir/numa_node)
294 | 	[ "$node" ] && [ "$node" -gt 0 ] || node=0
295 | 
296 | 	case "$AFF" in
297 | 	local)
298 | 		CORES=${corelist[$node]}
299 | 	;;
300 | 	remote)
301 | 		[ "$rnode" ] || { [ $node -eq 0 ] && rnode=1 || rnode=0; }
302 | 		CORES=${corelist[$rnode]}
303 | 	;;
304 | 	one)
305 | 		[ -n "$cnt" ] || cnt=0
306 | 		CORES=$cnt
307 | 	;;
308 | 	all)
309 | 		CORES=$CORES
310 | 	;;
311 | 	custom)
312 | 		echo -n "Input cores for $IFACE (ex. 0-7,15-23): "
313 | 		read CORES
314 | 	;;
315 | 	[0-9]*)
316 | 		CORES=$AFF
317 | 	;;
318 | 	*)
319 | 		usage
320 | 		exit 1
321 | 	;;
322 | 	esac
323 | 
324 | 	# call the worker function
325 | 	doaff
326 | done
327 | 
328 | # check for irqbalance running
329 | IRQBALANCE_ON=`ps ax | grep -v grep | grep -q irqbalance; echo $?`
330 | if [ "$IRQBALANCE_ON" == "0" ] ; then
331 | 	echo " WARNING: irqbalance is running and will"
332 | 	echo "          likely override this script's affinitization."
333 | 	echo "          Please stop the irqbalance service and/or execute"
334 | 	echo "          'killall irqbalance'"
335 | 	exit 2
336 | fi
337 | 


--------------------------------------------------------------------------------
/scripts/virt_perf_default:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | #
  3 | # Copyright (c) 2016 - 2023, Intel Corporation
  4 | #
  5 | # Redistribution and use in source and binary forms, with or without
  6 | # modification, are permitted provided that the following conditions are met:
  7 | #
  8 | #     * Redistributions of source code must retain the above copyright notice,
  9 | #       this list of conditions and the following disclaimer.
 10 | #     * Redistributions in binary form must reproduce the above copyright
 11 | #       notice, this list of conditions and the following disclaimer in the
 12 | #       documentation and/or other materials provided with the distribution.
 13 | #     * Neither the name of Intel Corporation nor the names of its contributors
 14 | #       may be used to endorse or promote products derived from this software
 15 | #       without specific prior written permission.
 16 | #
 17 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 18 | # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 19 | # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 20 | # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 21 | # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 22 | # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 23 | # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 24 | # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 25 | # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 26 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27 | #
 28 | # to get help:
 29 | # virt-perf-default
 30 | 
 31 | usage()
 32 | {
 33 | 	echo
 34 | 	echo "Usage: $0 [ethX] <[ethY]>"
 35 | 	echo "	Ex: $0 eth0"
 36 | 	echo
 37 | 	exit 1
 38 | }
 39 | 
 40 | num='^[0-9]+$'
 41 | # Vars
 42 | AFF=$1
 43 | shift
 44 | 
 45 | case "$AFF" in
 46 |     [0-9]*)	;;
 47 |     -h|--help)	usage ;;
 48 |     "")		usage ;;
 49 |     *)		IFACES=$AFF && AFF=all ;;	# Backwards compat mode
 50 | esac
 51 | 
 52 | # append the interfaces listed to the string with spaces
 53 | while [ "$#" -ne "0" ] ; do
 54 | 	IFACES+=" $1"
 55 | 	shift
 56 | done
 57 | 
 58 | # for now the user must specify interfaces
 59 | if [ -z "$IFACES" ]; then
 60 | 	usage
 61 | 	exit 1
 62 | fi
 63 | 
 64 | # support functions
 65 | 
 66 | disable_xps()
 67 | {
 68 | 	VEC=$core
 69 | 	if [ $VEC -ge 32 ]
 70 | 	then
 71 | 		MASK_FILL=""
 72 | 		MASK_ZERO="00000000"
 73 | 		let "IDX = $VEC / 32"
 74 | 		for ((i=1; i<=$IDX;i++))
 75 | 		do
 76 | 			MASK_FILL="${MASK_FILL},${MASK_ZERO}"
 77 | 		done
 78 | 
 79 | 		let "VEC -= 32 * $IDX"
 80 | 		MASK_TMP=$((1<<$VEC))
 81 | 		MASK=$(printf "%X%s" $MASK_TMP $MASK_FILL)
 82 | 	else
 83 | 		MASK_TMP=$((1<<$VEC))
 84 | 		MASK=$(printf "%X" $MASK_TMP)
 85 | 	fi
 86 | 
 87 | 	MASK=0
 88 | 	printf "%s %d %s -> /sys/class/net/%s/queues/tx-%d/xps_cpus\n" $IFACE $core $MASK $IFACE $((n-1))
 89 | 	printf "%s" $MASK > /sys/class/net/$IFACE/queues/tx-$((n-1))/xps_cpus
 90 | }
 91 | 
 92 | # Allow usage of , or -
 93 | #
 94 | parse_range () {
 95 |         RANGE=${@//,/ }
 96 |         RANGE=${RANGE//-/..}
 97 |         LIST=""
 98 |         for r in $RANGE; do
 99 | 		# eval lets us use vars in {#..#} range
100 |                 [[ $r =~ '..' ]] && r="$(eval echo {$r})"
101 | 		LIST+=" $r"
102 |         done
103 | 	echo $LIST
104 | }
105 | 
106 | # Affinitize interrupts
107 | #
108 | setaff()
109 | {
110 | 	CORES=$(parse_range $CORES)
111 | 	ncores=$(echo $CORES | wc -w)
112 | 	n=1
113 | 
114 | 	# this script only supports interrupt vectors in pairs,
115 | 	# modification would be required to support a single Tx or Rx queue
116 | 	# per interrupt vector
117 | 
118 | 	queues="${IFACE}-.*TxRx"
119 | 
120 | 	irqs=$(grep "$queues" /proc/interrupts | cut -f1 -d:)
121 | 	[ -z "$irqs" ] && irqs=$(grep $IFACE /proc/interrupts | cut -f1 -d:)
122 | 	[ -z "$irqs" ] && irqs=$(for i in `ls -Ux /sys/class/net/$IFACE/device/msi_irqs` ;\
123 | 	                         do grep "$i:.*TxRx" /proc/interrupts | grep -v fdir | cut -f 1 -d : ;\
124 | 	                         done)
125 | 	[ -z "$irqs" ] && echo "Error: Could not find interrupts for $IFACE"
126 | 
127 | 	echo "IFACE CORE MASK -> FILE"
128 | 	echo "======================="
129 | 	for IRQ in $irqs; do
130 | 		[ "$n" -gt "$ncores" ] && n=1
131 | 		j=1
132 | 		# much faster than calling cut for each
133 | 		for i in $CORES; do
134 | 			[ $((j++)) -ge $n ] && break
135 | 		done
136 | 		core=$i
137 | 		disable_xps
138 | 		((n++))
139 | 	done
140 | }
141 | 
142 | # now the actual useful bits of code
143 | 
144 | # these next 2 lines would allow script to auto-determine interfaces
145 | #[ -z "$IFACES" ] && IFACES=$(ls /sys/class/net)
146 | #[ -z "$IFACES" ] && echo "Error: No interfaces up" && exit 1
147 | 
148 | # echo IFACES is $IFACES
149 | 
150 | CORES=$(</sys/devices/system/cpu/online)
151 | [ "$CORES" ] || CORES=$(grep ^proc /proc/cpuinfo | cut -f2 -d:)
152 | 
153 | # Core list for each node from sysfs
154 | node_dir=/sys/devices/system/node
155 | for i in $(ls -d $node_dir/node*); do
156 | 	i=${i/*node/}
157 | 	corelist[$i]=$(<$node_dir/node${i}/cpulist)
158 | done
159 | 
160 | for IFACE in $IFACES; do
161 | 	# echo $IFACE being modified
162 | 
163 | 	dev_dir=/sys/class/net/$IFACE/device
164 | 	[ -e $dev_dir/numa_node ] && node=$(<$dev_dir/numa_node)
165 | 	[ "$node" ] && [ "$node" -gt 0 ] || node=0
166 | 
167 | 	case "$AFF" in
168 | 	local)
169 | 		CORES=${corelist[$node]}
170 | 	;;
171 | 	remote)
172 | 		[ "$rnode" ] || { [ $node -eq 0 ] && rnode=1 || rnode=0; }
173 | 		CORES=${corelist[$rnode]}
174 | 	;;
175 | 	one)
176 | 		[ -n "$cnt" ] || cnt=0
177 | 		CORES=$cnt
178 | 	;;
179 | 	all)
180 | 		CORES=$CORES
181 | 	;;
182 | 	custom)
183 | 		echo -n "Input cores for $IFACE (ex. 0-7,15-23): "
184 | 		read CORES
185 | 	;;
186 | 	[0-9]*)
187 | 		CORES=$AFF
188 | 	;;
189 | 	*)
190 | 		usage
191 | 		exit 1
192 | 	;;
193 | 	esac
194 | 
195 | 	# call the worker function
196 | 	setaff
197 | done
198 | 


--------------------------------------------------------------------------------
/src/Makefile:
--------------------------------------------------------------------------------
  1 | # SPDX-License-Identifier: GPL-2.0-only
  2 | # Copyright (C) 2013-2023 Intel Corporation
  3 | 
  4 | ifneq ($(KERNELRELEASE),)
  5 | # kbuild part of makefile
  6 | #
  7 | # Makefile for the Intel(R) 40-10 Gigabit Ethernet Connection Network Driver
  8 | #
  9 | 
 10 | ccflags-y += -I$(src)
 11 | subdir-ccflags-y += -I$(src)
 12 | 
 13 | obj-m += i40e.o
 14 | 
 15 | i40e-y := i40e_main.o \
 16 | 	i40e_ethtool.o \
 17 | 	i40e_xsk.o \
 18 | 	i40e_adminq.o \
 19 | 	i40e_common.o \
 20 | 	i40e_hmc.o \
 21 | 	i40e_lan_hmc.o \
 22 | 	i40e_nvm.o \
 23 | 	i40e_debugfs.o \
 24 | 	i40e_diag.o \
 25 | 	i40e_txrx.o \
 26 | 	i40e_ptp.o \
 27 | 	i40e_filters.o \
 28 | 	i40e_ddp.o \
 29 | 	i40e_client.o \
 30 | 	i40e_virtchnl_pf.o
 31 | 
 32 | i40e-$(CONFIG_DCB) += i40e_dcb.o i40e_dcb_nl.o
 33 | i40e-y += kcompat.o
 34 | i40e-y += kcompat_vfd.o
 35 | 
 36 | ifeq (${NEED_AUX_BUS},2)
 37 | intel_auxiliary-objs := auxiliary.o
 38 | obj-m += intel_auxiliary.o
 39 | $(warning ${NEED_AUX_BUS})
 40 | endif
 41 | 
 42 | else	# ifneq($(KERNELRELEASE),)
 43 | # normal makefile
 44 | 
 45 | DRIVER := i40e
 46 | 
 47 | # If the user just wants to print the help output, don't include common.mk or
 48 | # perform any other checks. This ensures that running "make help" will always
 49 | # work even if kernel-devel is not installed, or if the common.mk fails under
 50 | # any other error condition.
 51 | ifneq ($(MAKECMDGOALS),help)
 52 | include common.mk
 53 | 
 54 | # i40e does not support building on kernels older than 2.6.32
 55 | $(call minimum_kver_check,2,6,32)
 56 | endif
 57 | 
 58 | # Command to update initramfs or display a warning message
 59 | ifeq (${cmd_initrd},)
 60 | define cmd_initramfs
 61 | @echo "Unable to update initramfs. You may need to do this manaully."
 62 | endef
 63 | else
 64 | define cmd_initramfs
 65 | @echo "Updating initramfs..."
 66 | -@$(call cmd_initrd)
 67 | endef
 68 | endif
 69 | 
 70 | ###############
 71 | # Build rules #
 72 | ###############
 73 | 
 74 | # Standard compilation, with regular output
 75 | default:
 76 | 	@+$(call kernelbuild,modules)
 77 | 
 78 | # Noisy output, for extra debugging
 79 | noisy:
 80 | 	@+$(call kernelbuild,modules,V=1)
 81 | 
 82 | # Silence any output generated
 83 | silent:
 84 | 	@+$(call kernelbuild,modules,>/dev/null)
 85 | 
 86 | # Enable higher warning level
 87 | checkwarnings: clean
 88 | 	@+$(call kernelbuild,modules,W=1)
 89 | 
 90 | # Run sparse static analyzer
 91 | sparse: clean
 92 | 	@+$(call kernelbuild,modules,C=2 CF="-D__CHECK_ENDIAN__ -Wbitwise -Wcontext")
 93 | 
 94 | # Run coccicheck static analyzer
 95 | ccc: clean
 96 | 	@+$(call kernelbuild,modules,coccicheck MODE=report)
 97 | 
 98 | # Build manfiles
 99 | manfile:
100 | 	@gzip -c ../${DRIVER}.${MANSECTION} > ${DRIVER}.${MANSECTION}.gz
101 | 
102 | # Clean the module subdirectories
103 | clean:
104 | 	@+$(call kernelbuild,clean)
105 | 	@-rm -rf *.${MANSECTION}.gz *.ko
106 | 
107 | sign:
108 | 	@echo "Signing driver..."
109 | 	@$(call info_signed_modules)
110 | 	@$(call sign_driver)
111 | 
112 | mandocs_install: manfile
113 | 	@echo "Copying manpages..."
114 | 	@install -D -m 644 ${DRIVER}.${MANSECTION}.gz ${INSTALL_MOD_PATH}${MANDIR}/man${MANSECTION}/${DRIVER}.${MANSECTION}.gz
115 | 
116 | # Install kernel module files. It is not expected to modify files outside of
117 | # the build root. Thus, it must not update initramfs, or run depmod.
118 | modules_install: default
119 | 	@echo "Installing modules..."
120 | 	@+$(call kernelbuild,modules_install)
121 | 	$(MAKE) auxiliary_install
122 | 
123 | # Install kernel module files without auxiliary. This target is called by the
124 | # RPM specfile when  generating binary RPMs, and is not expected to modify
125 | # files outside of the build root. Thus, it must not update initramfs, or run depmod.
126 | modules_install_no_aux:
127 | 	@echo "Installing modules..."
128 | 	@+$(call kernelbuild,modules_install)
129 | 
130 | # After installing all the files, perform necessary work to ensure the system
131 | # will use the new modules. This includes running depmod to update module
132 | # dependencies and updating the initramfs image in case the module is loaded
133 | # during early boot.
134 | install: modules_install
135 | 	$(call cmd_depmod)
136 | 	$(call cmd_initramfs)
137 | 	$(MAKE) mandocs_install
138 | 
139 | # Target used by rpmbuild spec file
140 | rpm: modules_install
141 | 	$(MAKE) mandocs_install
142 | 
143 | mandocs_uninstall:
144 | 	if [ -e ${INSTALL_MOD_PATH}${MANDIR}/man${MANSECTION}/${DRIVER}.${MANSECTION}.gz ] ; then \
145 | 		rm -f ${INSTALL_MOD_PATH}${MANDIR}/man${MANSECTION}/${DRIVER}.${MANSECTION}.gz ; \
146 | 	fi;
147 | 
148 | # Remove installed module files. This target is called by the RPM specfile when
149 | # generating binary RPMs, and is not expected to modify files outside of the
150 | # build root. Thus, it must not update the initramfs image or run depmod.
151 | modules_uninstall:
152 | 	rm -f ${INSTALL_MOD_PATH}/lib/modules/${KVER}/${INSTALL_MOD_DIR}/${DRIVER}.ko;
153 | 	$(MAKE) auxiliary_uninstall
154 | 
155 | # After uninstalling all the files, perform necessary work to restore the
156 | # system back to using the default kernel modules. This includes running depmod
157 | # to update module dependencies and updating the initramfs image.
158 | uninstall: modules_uninstall mandocs_uninstall
159 | 	$(call cmd_depmod)
160 | 	$(call cmd_initramfs)
161 | 
162 | auxiliary_info:
163 | 	@../scripts/check_aux_bus --verbose --ksrc="${KSRC}" --build-kernel="${BUILD_KERNEL}"
164 | 
165 | auxiliary_install:
166 | 	@echo "Installing auxiliary..."
167 | 	${auxiliary_post_install}
168 | 
169 | auxiliary_uninstall:
170 | 	${auxiliary_post_uninstall}
171 | 
172 | 
173 | ifeq (${NEED_AUX_BUS},1)
174 | default: auxiliary_info
175 | endif
176 | ########
177 | # Help #
178 | ########
179 | help:
180 | 	@echo 'Build targets:'
181 | 	@echo '  default             - Build module(s) with standard verbosity'
182 | 	@echo '  noisy               - Build module(s) with V=1 verbosity -- very noisy'
183 | 	@echo '  silent              - Build module(s), squelching all output'
184 | 	@echo ''
185 | 	@echo 'Static Analysis:'
186 | 	@echo '  checkwarnings       - Clean, then build module(s) with W=1 warnings enabled'
187 | 	@echo '  sparse              - Clean, then check module(s) using sparse'
188 | 	@echo '  ccc                 - Clean, then check module(s) using coccicheck'
189 | 	@echo ''
190 | 	@echo 'Cleaning targets:'
191 | 	@echo '  clean               - Clean files generated by kernel module build'
192 | 	@echo ''
193 | 	@echo 'Other targets:'
194 | 	@echo '  manfile             - Generate a gzipped manpage'
195 | 	@echo '  modules_install     - install the module(s) only'
196 | 	@echo '  mandocs_install     - install the manpage only'
197 | 	@echo '  install             - Build then install the module(s) and manpage, and update initramfs'
198 | 	@echo '  modules_uninstall   - uninstall the module(s) only'
199 | 	@echo '  mandocs_uninstall   - uninstall the manpage only'
200 | 	@echo '  uninstall           - Uninstall the module(s) and manpage, and update initramfs'
201 | 	@echo '  auxiliary_info      - Print information about the auxiliary module'
202 | 	@echo '  auxiliary_install   - Install compiled auxiliary module'
203 | 	@echo '  auxiliary_uninstall - Uninstall auxiliary module'
204 | 	@echo '  help                - Display this help message'
205 | 	@echo ''
206 | 	@echo 'Variables:'
207 | 	@echo '  LINUX_VERSION       - Debug tool to force kernel LINUX_VERSION_CODE. Use at your own risk.'
208 | 	@echo '  W=N                 - Kernel variable for setting warning levels'
209 | 	@echo '  V=N                 - Kernel variable for setting output verbosity'
210 | 	@echo '  INSTALL_MOD_PATH    - Add prefix for the module and manpage installation path'
211 | 	@echo '  INSTALL_MOD_DIR     - Use module directory other than updates/drivers/net/ethernet/intel/${DRIVER}'
212 | 	@echo '  KSRC                - Specifies the full path to the kernel tree to build against'
213 | 	@echo ' Other variables may be available for tuning make process, see'
214 | 	@echo ' Kernel Kbuild documentation for more information'
215 | 
216 | .PHONY: default noisy clean manfile silent sparse ccc install uninstall help auxiliary_info
217 | 
218 | endif	# ifneq($(KERNELRELEASE),)
219 | 


--------------------------------------------------------------------------------
/src/Module.supported:
--------------------------------------------------------------------------------
1 | i40e.ko external
2 | intel_auxiliary.ko external
3 | 


--------------------------------------------------------------------------------
/src/auxiliary.c:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #define pr_fmt(fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__
  5 | 
  6 | #include <linux/device.h>
  7 | #include <linux/init.h>
  8 | #include <linux/slab.h>
  9 | #include <linux/module.h>
 10 | #include <linux/pm_domain.h>
 11 | #include <linux/pm_runtime.h>
 12 | #include <linux/string.h>
 13 | #include "linux/auxiliary_bus.h"
 14 | #include "auxiliary_compat.h"
 15 | 
 16 | static const struct auxiliary_device_id *auxiliary_match_id(const struct auxiliary_device_id *id,
 17 | 							    const struct auxiliary_device *auxdev)
 18 | {
 19 | 	for (; id->name[0]; id++) {
 20 | 		const char *p = strrchr(dev_name(&auxdev->dev), '.');
 21 | 		size_t match_size;
 22 | 
 23 | 		if (!p)
 24 | 			continue;
 25 | 		match_size = p - dev_name(&auxdev->dev);
 26 | 
 27 | 		/* use dev_name(&auxdev->dev) prefix before last '.' char to match to */
 28 | 		if (strlen(id->name) == match_size &&
 29 | 		    !strncmp(dev_name(&auxdev->dev), id->name, match_size))
 30 | 			return id;
 31 | 	}
 32 | 	return NULL;
 33 | }
 34 | 
 35 | static int auxiliary_match(struct device *dev, struct device_driver *drv)
 36 | {
 37 | 	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
 38 | 	struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv);
 39 | 
 40 | 	return !!auxiliary_match_id(auxdrv->id_table, auxdev);
 41 | }
 42 | 
 43 | static int auxiliary_uevent(struct device *dev, struct kobj_uevent_env *env)
 44 | {
 45 | 	const char *name, *p;
 46 | 
 47 | 	name = dev_name(dev);
 48 | 	p = strrchr(name, '.');
 49 | 
 50 | 	return add_uevent_var(env, "MODALIAS=%s%.*s", AUXILIARY_MODULE_PREFIX,
 51 | 			      (int)(p - name), name);
 52 | }
 53 | 
 54 | static const struct dev_pm_ops auxiliary_dev_pm_ops = {
 55 | 	SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend, pm_generic_runtime_resume, NULL)
 56 | 	SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume)
 57 | };
 58 | 
 59 | static int auxiliary_bus_probe(struct device *dev)
 60 | {
 61 | 	struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
 62 | 	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
 63 | 	int ret;
 64 | 
 65 | 	ret = dev_pm_domain_attach(dev, true);
 66 | 	if (ret != -EPROBE_DEFER) {
 67 | 		if (auxdrv->probe) {
 68 | 			ret = auxdrv->probe(auxdev,
 69 | 					    auxiliary_match_id(auxdrv->id_table,
 70 | 							       auxdev));
 71 | 			if (ret)
 72 | 				dev_pm_domain_detach(dev, true);
 73 | 		} else {
 74 | 			/* don't fail if just dev_pm_domain_attach failed */
 75 | 			ret = 0;
 76 | 		}
 77 | 	}
 78 | 
 79 | 	return ret;
 80 | }
 81 | 
 82 | static int auxiliary_bus_remove(struct device *dev)
 83 | {
 84 | 	struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
 85 | 	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
 86 | 
 87 | 	if (auxdrv->remove)
 88 | 		auxdrv->remove(auxdev);
 89 | 	dev_pm_domain_detach(dev, true);
 90 | 
 91 | 	return 0;
 92 | }
 93 | 
 94 | static void auxiliary_bus_shutdown(struct device *dev)
 95 | {
 96 | 	struct auxiliary_driver *auxdrv = NULL;
 97 | 	struct auxiliary_device *auxdev;
 98 | 
 99 | 	if (dev->driver) {
100 | 		auxdrv = to_auxiliary_drv(dev->driver);
101 | 		auxdev = to_auxiliary_dev(dev);
102 | 	}
103 | 
104 | 	if (auxdrv && auxdrv->shutdown)
105 | 		auxdrv->shutdown(auxdev);
106 | }
107 | 
108 | static struct bus_type auxiliary_bus_type = {
109 | 	.name = "intel_auxiliary",
110 | 	.probe = auxiliary_bus_probe,
111 | 	.remove = auxiliary_bus_remove,
112 | 	.shutdown = auxiliary_bus_shutdown,
113 | 	.match = auxiliary_match,
114 | 	.uevent = auxiliary_uevent,
115 | 	.pm = &auxiliary_dev_pm_ops,
116 | };
117 | 
118 | /**
119 |  * auxiliary_device_init - check auxiliary_device and initialize
120 |  * @auxdev: auxiliary device struct
121 |  *
122 |  * This is the first step in the two-step process to register an
123 |  * auxiliary_device.
124 |  *
125 |  * When this function returns an error code, then the device_initialize will
126 |  * *not* have been performed, and the caller will be responsible to free any
127 |  * memory allocated for the auxiliary_device in the error path directly.
128 |  *
129 |  * It returns 0 on success.  On success, the device_initialize has been
130 |  * performed.  After this point any error unwinding will need to include a call
131 |  * to auxiliary_device_uninit().  In this post-initialize error scenario, a call
132 |  * to the device's .release callback will be triggered, and all memory clean-up
133 |  * is expected to be handled there.
134 |  */
135 | int auxiliary_device_init(struct auxiliary_device *auxdev)
136 | {
137 | 	struct device *dev = &auxdev->dev;
138 | 
139 | 	if (!dev->parent) {
140 | 		pr_err("auxiliary_device has a NULL dev->parent\n");
141 | 		return -EINVAL;
142 | 	}
143 | 
144 | 	if (!auxdev->name) {
145 | 		pr_err("auxiliary_device has a NULL name\n");
146 | 		return -EINVAL;
147 | 	}
148 | 
149 | 	dev->bus = &auxiliary_bus_type;
150 | 	device_initialize(&auxdev->dev);
151 | 	return 0;
152 | }
153 | EXPORT_SYMBOL_GPL(auxiliary_device_init);
154 | 
155 | /**
156 |  * __auxiliary_device_add - add an auxiliary bus device
157 |  * @auxdev: auxiliary bus device to add to the bus
158 |  * @modname: name of the parent device's driver module
159 |  *
160 |  * This is the second step in the two-step process to register an
161 |  * auxiliary_device.
162 |  *
163 |  * This function must be called after a successful call to
164 |  * auxiliary_device_init(), which will perform the device_initialize.  This
165 |  * means that if this returns an error code, then a call to
166 |  * auxiliary_device_uninit() must be performed so that the .release callback
167 |  * will be triggered to free the memory associated with the auxiliary_device.
168 |  *
169 |  * The expectation is that users will call the "auxiliary_device_add" macro so
170 |  * that the caller's KBUILD_MODNAME is automatically inserted for the modname
171 |  * parameter.  Only if a user requires a custom name would this version be
172 |  * called directly.
173 |  */
174 | int __auxiliary_device_add(struct auxiliary_device *auxdev, const char *modname)
175 | {
176 | 	struct device *dev = &auxdev->dev;
177 | 	int ret;
178 | 
179 | 	if (!modname) {
180 | 		dev_err(dev, "auxiliary device modname is NULL\n");
181 | 		return -EINVAL;
182 | 	}
183 | 
184 | 	ret = dev_set_name(dev, "%s.%s.%d", modname, auxdev->name, auxdev->id);
185 | 	if (ret) {
186 | 		dev_err(dev, "auxiliary device dev_set_name failed: %d\n", ret);
187 | 		return ret;
188 | 	}
189 | 
190 | 	ret = device_add(dev);
191 | 	if (ret)
192 | 		dev_err(dev, "adding auxiliary device failed!: %d\n", ret);
193 | 
194 | 	return ret;
195 | }
196 | EXPORT_SYMBOL_GPL(__auxiliary_device_add);
197 | 
198 | /**
199 |  * auxiliary_find_device - auxiliary device iterator for locating a particular device.
200 |  * @start: Device to begin with
201 |  * @data: Data to pass to match function
202 |  * @match: Callback function to check device
203 |  *
204 |  * This function returns a reference to a device that is 'found'
205 |  * for later use, as determined by the @match callback.
206 |  *
207 |  * The callback should return 0 if the device doesn't match and non-zero
208 |  * if it does.  If the callback returns non-zero, this function will
209 |  * return to the caller and not iterate over any more devices.
210 |  */
211 | struct auxiliary_device *auxiliary_find_device(struct device *start,
212 | 					       const void *data,
213 | 					       int (*match)(struct device *dev, const void *data))
214 | {
215 | 	struct device *dev;
216 | 
217 | 	dev = bus_find_device(&auxiliary_bus_type, start, data, match);
218 | 	if (!dev)
219 | 		return NULL;
220 | 
221 | 	return to_auxiliary_dev(dev);
222 | }
223 | EXPORT_SYMBOL_GPL(auxiliary_find_device);
224 | 
225 | /**
226 |  * __auxiliary_driver_register - register a driver for auxiliary bus devices
227 |  * @auxdrv: auxiliary_driver structure
228 |  * @owner: owning module/driver
229 |  * @modname: KBUILD_MODNAME for parent driver
230 |  */
231 | int __auxiliary_driver_register(struct auxiliary_driver *auxdrv,
232 | 				struct module *owner, const char *modname)
233 | {
234 | 	int ret;
235 | 
236 | 	if (WARN_ON(!auxdrv->probe) || WARN_ON(!auxdrv->id_table))
237 | 		return -EINVAL;
238 | 
239 | 	if (auxdrv->name)
240 | 		auxdrv->driver.name = kasprintf(GFP_KERNEL, "%s.%s", modname,
241 | 						auxdrv->name);
242 | 	else
243 | 		auxdrv->driver.name = kasprintf(GFP_KERNEL, "%s", modname);
244 | 	if (!auxdrv->driver.name)
245 | 		return -ENOMEM;
246 | 
247 | 	auxdrv->driver.owner = owner;
248 | 	auxdrv->driver.bus = &auxiliary_bus_type;
249 | 	auxdrv->driver.mod_name = modname;
250 | 
251 | 	ret = driver_register(&auxdrv->driver);
252 | 	if (ret)
253 | 		kfree(auxdrv->driver.name);
254 | 
255 | 	return ret;
256 | }
257 | EXPORT_SYMBOL_GPL(__auxiliary_driver_register);
258 | 
259 | /**
260 |  * auxiliary_driver_unregister - unregister a driver
261 |  * @auxdrv: auxiliary_driver structure
262 |  */
263 | void auxiliary_driver_unregister(struct auxiliary_driver *auxdrv)
264 | {
265 | 	driver_unregister(&auxdrv->driver);
266 | 	kfree(auxdrv->driver.name);
267 | }
268 | EXPORT_SYMBOL_GPL(auxiliary_driver_unregister);
269 | 
270 | static int __init auxiliary_bus_init(void)
271 | {
272 | 	return bus_register(&auxiliary_bus_type);
273 | }
274 | 
275 | static void __exit auxiliary_bus_exit(void)
276 | {
277 | 	bus_unregister(&auxiliary_bus_type);
278 | }
279 | 
280 | module_init(auxiliary_bus_init);
281 | module_exit(auxiliary_bus_exit);
282 | 
283 | MODULE_LICENSE("GPL v2");
284 | MODULE_DESCRIPTION("Auxiliary Bus Standalone");
285 | MODULE_AUTHOR("linux.nics@intel.com");
286 | 


--------------------------------------------------------------------------------
/src/auxiliary_compat.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _AUXILIARY_COMPAT_H_
  5 | #define _AUXILIARY_COMPAT_H_
  6 | 
  7 | /* This file contains only the minimal set of kernel compatibility backports
  8 |  * required by auxiliary.c to build. It is similar to the kcompat.h file, but
  9 |  * reduced to an absolute minimum in order to reduce the risk of generating
 10 |  * different kernel symbol CRC values at build time.
 11 |  *
 12 |  * For a detailed discussion of kernel symbol CRCs, please read:
 13 |  *
 14 |  *    Documentation/kernel-symbol-crc.rst
 15 |  *
 16 |  * Include only the minimum required kernel compatibility implementations from
 17 |  * kcompat_generated_defs.h and kcompat_impl.h. If a new fix is required,
 18 |  * please first implement it as part of the kcompat project before porting it
 19 |  * to this file.
 20 |  *
 21 |  * The current list of required implementations is:
 22 |  *
 23 |  *  NEED_BUS_FIND_DEVICE_CONST_DATA
 24 |  *  NEED_DEV_PM_DOMAIN_ATTACH
 25 |  *  NEED_DEV_PM_DOMAIN_DETACH
 26 |  *
 27 |  * Note that kernels since v5.11 support auxiliary as a built-in config
 28 |  * option. Using this is always preferred to using an out-of-tree module when
 29 |  * available.
 30 |  */
 31 | 
 32 | #include "kcompat_generated_defs.h"
 33 | 
 34 | /****************************
 35 |  * Backport implementations *
 36 |  ****************************/
 37 | 
 38 | #ifdef NEED_BUS_FIND_DEVICE_CONST_DATA
 39 | /* NEED_BUS_FIND_DEVICE_CONST_DATA
 40 |  *
 41 |  * bus_find_device() was updated in upstream commit 418e3ea157ef
 42 |  * ("bus_find_device: Unify the match callback with class_find_device")
 43 |  * to take a const void *data parameter and also have the match() function
 44 |  * passed in take a const void *data parameter.
 45 |  *
 46 |  * all of the kcompat below makes it so the caller can always just call
 47 |  * bus_find_device() according to the upstream kernel without having to worry
 48 |  * about const vs. non-const arguments.
 49 |  */
 50 | struct _kc_bus_find_device_custom_data {
 51 | 	const void *real_data;
 52 | 	int (*real_match)(struct device *dev, const void *data);
 53 | };
 54 | 
 55 | static inline int _kc_bus_find_device_wrapped_match(struct device *dev, void *data)
 56 | {
 57 | 	struct _kc_bus_find_device_custom_data *custom_data = data;
 58 | 
 59 | 	return custom_data->real_match(dev, custom_data->real_data);
 60 | }
 61 | 
 62 | static inline struct device *
 63 | _kc_bus_find_device(struct bus_type *type, struct device *start,
 64 | 		    const void *data,
 65 | 		    int (*match)(struct device *dev, const void *data))
 66 | {
 67 | 	struct _kc_bus_find_device_custom_data custom_data = {};
 68 | 
 69 | 	custom_data.real_data = data;
 70 | 	custom_data.real_match = match;
 71 | 
 72 | 	return bus_find_device(type, start, &custom_data,
 73 | 			       _kc_bus_find_device_wrapped_match);
 74 | }
 75 | 
 76 | /* force callers of bus_find_device() to call _kc_bus_find_device() on kernels
 77 |  * where NEED_BUS_FIND_DEVICE_CONST_DATA is defined
 78 |  */
 79 | #define bus_find_device(type, start, data, match) \
 80 | 	_kc_bus_find_device(type, start, data, match)
 81 | #endif /* NEED_BUS_FIND_DEVICE_CONST_DATA */
 82 | 
 83 | #if defined(NEED_DEV_PM_DOMAIN_ATTACH) && defined(NEED_DEV_PM_DOMAIN_DETACH)
 84 | #include <linux/acpi.h>
 85 | /* NEED_DEV_PM_DOMAIN_ATTACH and NEED_DEV_PM_DOMAIN_DETACH
 86 |  *
 87 |  * dev_pm_domain_attach() and dev_pm_domain_detach() were added in upstream
 88 |  * commit 46420dd73b80 ("PM / Domains: Add APIs to attach/detach a PM domain for
 89 |  * a device"). To support older kernels and OSVs that don't have these API, just
 90 |  * implement how older versions worked by directly calling acpi_dev_pm_attach()
 91 |  * and acpi_dev_pm_detach().
 92 |  */
 93 | static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 94 | {
 95 | 	if (dev->pm_domain)
 96 | 		return 0;
 97 | 
 98 | 	if (ACPI_HANDLE(dev))
 99 | 		return acpi_dev_pm_attach(dev, true);
100 | 
101 | 	return 0;
102 | }
103 | 
104 | static inline void dev_pm_domain_detach(struct device *dev, bool power_off)
105 | {
106 | 	if (ACPI_HANDLE(dev))
107 | 		acpi_dev_pm_detach(dev, true);
108 | }
109 | #else /* NEED_DEV_PM_DOMAIN_ATTACH && NEED_DEV_PM_DOMAIN_DETACH */
110 | /* it doesn't make sense to compat only one of these functions, and it is
111 |  * likely either a failure in kcompat-generator.sh or a failed distribution
112 |  * backport if this occurs. Don't try to support it.
113 |  */
114 | #ifdef NEED_DEV_PM_DOMAIN_ATTACH
115 | #error "NEED_DEV_PM_DOMAIN_ATTACH defined but NEED_DEV_PM_DOMAIN_DETACH not defined???"
116 | #endif /* NEED_DEV_PM_DOMAIN_ATTACH */
117 | #ifdef NEED_DEV_PM_DOMAIN_DETACH
118 | #error "NEED_DEV_PM_DOMAIN_DETACH defined but NEED_DEV_PM_DOMAIN_ATTACH not defined???"
119 | #endif /* NEED_DEV_PM_DOMAIN_DETACH */
120 | #endif /* NEED_DEV_PM_DOMAIN_ATTACH && NEED_DEV_PM_DOMAIN_DETACH */
121 | 
122 | #endif /* _AUXILIARY_COMPAT_H_ */
123 | 


--------------------------------------------------------------------------------
/src/i40e_adminq.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_ADMINQ_H_
  5 | #define _I40E_ADMINQ_H_
  6 | 
  7 | #include "i40e_osdep.h"
  8 | #include "i40e_status.h"
  9 | #include "i40e_adminq_cmd.h"
 10 | 
 11 | #define I40E_ADMINQ_DESC(R, i)   \
 12 | 	(&(((struct i40e_aq_desc *)((R).desc_buf.va))[i]))
 13 | 
 14 | #define I40E_ADMINQ_DESC_ALIGNMENT 4096
 15 | 
 16 | struct i40e_adminq_ring {
 17 | 	struct i40e_virt_mem dma_head;	/* space for dma structures */
 18 | 	struct i40e_dma_mem desc_buf;	/* descriptor ring memory */
 19 | 	struct i40e_virt_mem cmd_buf;	/* command buffer memory */
 20 | 
 21 | 	union {
 22 | 		struct i40e_dma_mem *asq_bi;
 23 | 		struct i40e_dma_mem *arq_bi;
 24 | 	} r;
 25 | 
 26 | 	u16 count;		/* Number of descriptors */
 27 | 	u16 rx_buf_len;		/* Admin Receive Queue buffer length */
 28 | 
 29 | 	/* used for interrupt processing */
 30 | 	u16 next_to_use;
 31 | 	u16 next_to_clean;
 32 | 
 33 | 	/* used for queue tracking */
 34 | 	u32 head;
 35 | 	u32 tail;
 36 | 	u32 len;
 37 | 	u32 bah;
 38 | 	u32 bal;
 39 | };
 40 | 
 41 | /* ASQ transaction details */
 42 | struct i40e_asq_cmd_details {
 43 | 	void *callback; /* cast from type I40E_ADMINQ_CALLBACK */
 44 | 	u64 cookie;
 45 | 	u16 flags_ena;
 46 | 	u16 flags_dis;
 47 | 	bool async;
 48 | 	bool postpone;
 49 | 	struct i40e_aq_desc *wb_desc;
 50 | };
 51 | 
 52 | #define I40E_ADMINQ_DETAILS(R, i)   \
 53 | 	(&(((struct i40e_asq_cmd_details *)((R).cmd_buf.va))[i]))
 54 | 
 55 | /* ARQ event information */
 56 | struct i40e_arq_event_info {
 57 | 	struct i40e_aq_desc desc;
 58 | 	u16 msg_len;
 59 | 	u16 buf_len;
 60 | 	u8 *msg_buf;
 61 | };
 62 | 
 63 | /* Admin Queue information */
 64 | struct i40e_adminq_info {
 65 | 	struct i40e_adminq_ring arq;    /* receive queue */
 66 | 	struct i40e_adminq_ring asq;    /* send queue */
 67 | 	u32 asq_cmd_timeout;            /* send queue cmd write back timeout*/
 68 | 	u16 num_arq_entries;            /* receive queue depth */
 69 | 	u16 num_asq_entries;            /* send queue depth */
 70 | 	u16 arq_buf_size;               /* receive queue buffer size */
 71 | 	u16 asq_buf_size;               /* send queue buffer size */
 72 | 	u16 fw_maj_ver;                 /* firmware major version */
 73 | 	u16 fw_min_ver;                 /* firmware minor version */
 74 | 	u32 fw_build;                   /* firmware build number */
 75 | 	u16 api_maj_ver;                /* api major version */
 76 | 	u16 api_min_ver;                /* api minor version */
 77 | 
 78 | 	struct i40e_spinlock asq_spinlock; /* Send queue spinlock */
 79 | 	struct i40e_spinlock arq_spinlock; /* Receive queue spinlock */
 80 | 
 81 | 	/* last status values on send and receive queues */
 82 | 	enum i40e_admin_queue_err asq_last_status;
 83 | 	enum i40e_admin_queue_err arq_last_status;
 84 | };
 85 | 
 86 | /**
 87 |  * i40e_aq_rc_to_posix - convert errors to user-land codes
 88 |  * aq_ret: AdminQ handler error code can override aq_rc
 89 |  * aq_rc: AdminQ firmware error code to convert
 90 |  **/
 91 | static INLINE int i40e_aq_rc_to_posix(int aq_ret, int aq_rc)
 92 | {
 93 | 	int aq_to_posix[] = {
 94 | 		0,           /* I40E_AQ_RC_OK */
 95 | 		-EPERM,      /* I40E_AQ_RC_EPERM */
 96 | 		-ENOENT,     /* I40E_AQ_RC_ENOENT */
 97 | 		-ESRCH,      /* I40E_AQ_RC_ESRCH */
 98 | 		-EINTR,      /* I40E_AQ_RC_EINTR */
 99 | 		-EIO,        /* I40E_AQ_RC_EIO */
100 | 		-ENXIO,      /* I40E_AQ_RC_ENXIO */
101 | 		-E2BIG,      /* I40E_AQ_RC_E2BIG */
102 | 		-EAGAIN,     /* I40E_AQ_RC_EAGAIN */
103 | 		-ENOMEM,     /* I40E_AQ_RC_ENOMEM */
104 | 		-EACCES,     /* I40E_AQ_RC_EACCES */
105 | 		-EFAULT,     /* I40E_AQ_RC_EFAULT */
106 | 		-EBUSY,      /* I40E_AQ_RC_EBUSY */
107 | 		-EEXIST,     /* I40E_AQ_RC_EEXIST */
108 | 		-EINVAL,     /* I40E_AQ_RC_EINVAL */
109 | 		-ENOTTY,     /* I40E_AQ_RC_ENOTTY */
110 | 		-ENOSPC,     /* I40E_AQ_RC_ENOSPC */
111 | 		-ENOSYS,     /* I40E_AQ_RC_ENOSYS */
112 | 		-ERANGE,     /* I40E_AQ_RC_ERANGE */
113 | 		-EPIPE,      /* I40E_AQ_RC_EFLUSHED */
114 | 		-ESPIPE,     /* I40E_AQ_RC_BAD_ADDR */
115 | 		-EROFS,      /* I40E_AQ_RC_EMODE */
116 | 		-EFBIG,      /* I40E_AQ_RC_EFBIG */
117 | 	};
118 | 
119 | 	/* aq_rc is invalid if AQ timed out */
120 | 	if (aq_ret == I40E_ERR_ADMIN_QUEUE_TIMEOUT)
121 | 		return -EAGAIN;
122 | 
123 | 	if (!((u32)aq_rc < (sizeof(aq_to_posix) / sizeof((aq_to_posix)[0]))))
124 | 		return -ERANGE;
125 | 
126 | 	return aq_to_posix[aq_rc];
127 | }
128 | 
129 | /* general information */
130 | #define I40E_AQ_LARGE_BUF	512
131 | #define I40E_ASQ_CMD_TIMEOUT	250000  /* usecs */
132 | 
133 | void i40e_fill_default_direct_cmd_desc(struct i40e_aq_desc *desc,
134 | 				       u16 opcode);
135 | 
136 | #endif /* _I40E_ADMINQ_H_ */
137 | 


--------------------------------------------------------------------------------
/src/i40e_alloc.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _I40E_ALLOC_H_
 5 | #define _I40E_ALLOC_H_
 6 | 
 7 | struct i40e_hw;
 8 | 
 9 | /* Memory allocation types */
10 | enum i40e_memory_type {
11 | 	i40e_mem_arq_buf = 0,		/* ARQ indirect command buffer */
12 | 	i40e_mem_asq_buf = 1,
13 | 	i40e_mem_atq_buf = 2,		/* ATQ indirect command buffer */
14 | 	i40e_mem_arq_ring = 3,		/* ARQ descriptor ring */
15 | 	i40e_mem_atq_ring = 4,		/* ATQ descriptor ring */
16 | 	i40e_mem_pd = 5,		/* Page Descriptor */
17 | 	i40e_mem_bp = 6,		/* Backing Page - 4KB */
18 | 	i40e_mem_bp_jumbo = 7,		/* Backing Page - > 4KB */
19 | 	i40e_mem_reserved
20 | };
21 | 
22 | /* prototype for functions used for dynamic memory allocation */
23 | i40e_status i40e_allocate_dma_mem(struct i40e_hw *hw,
24 | 					    struct i40e_dma_mem *mem,
25 | 					    enum i40e_memory_type type,
26 | 					    u64 size, u32 alignment);
27 | i40e_status i40e_free_dma_mem(struct i40e_hw *hw,
28 | 					struct i40e_dma_mem *mem);
29 | i40e_status i40e_allocate_virt_mem(struct i40e_hw *hw,
30 | 					     struct i40e_virt_mem *mem,
31 | 					     u32 size);
32 | i40e_status i40e_free_virt_mem(struct i40e_hw *hw,
33 | 					 struct i40e_virt_mem *mem);
34 | 
35 | #endif /* _I40E_ALLOC_H_ */
36 | 


--------------------------------------------------------------------------------
/src/i40e_client.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_CLIENT_H_
  5 | #define _I40E_CLIENT_H_
  6 | 
  7 | #ifdef USE_INTEL_AUX_BUS
  8 | #include "linux/auxiliary_bus.h"
  9 | #else
 10 | #include <linux/auxiliary_bus.h>
 11 | #endif /* USE_INTEL_AUX_BUS */
 12 | 
 13 | #define I40E_PEER_RDMA_NAME    "i40e_rdma"
 14 | #define I40E_PEER_RDMA_ID      PLATFORM_DEVID_AUTO
 15 | 
 16 | #define I40E_CLIENT_STR_LENGTH 10
 17 | /* Client interface version should be updated anytime there is a change in the
 18 |  * existing APIs or data structures.
 19 |  * Note that in-tree i40e has major version of 0 and the structures are not
 20 |  * identical. For example struct i40e_info and i40e_ops are different.
 21 |  */
 22 | #define I40E_CLIENT_VERSION_MAJOR 1
 23 | #define I40E_CLIENT_VERSION_MINOR 01
 24 | #define I40E_CLIENT_VERSION_BUILD 00
 25 | #define I40E_CLIENT_VERSION_STR     \
 26 | 	__stringify(I40E_CLIENT_VERSION_MAJOR) "." \
 27 | 	__stringify(I40E_CLIENT_VERSION_MINOR) "." \
 28 | 	__stringify(I40E_CLIENT_VERSION_BUILD)
 29 | 
 30 | struct i40e_client_version {
 31 | 	u8 major;
 32 | 	u8 minor;
 33 | 	u8 build;
 34 | 	u8 rsvd;
 35 | };
 36 | 
 37 | enum i40e_client_state {
 38 | 	__I40E_CLIENT_NULL,
 39 | 	__I40E_CLIENT_REGISTERED
 40 | };
 41 | 
 42 | enum i40e_client_instance_state {
 43 | 	__I40E_CLIENT_INSTANCE_NONE,
 44 | 	__I40E_CLIENT_INSTANCE_OPENED,
 45 | };
 46 | 
 47 | struct i40e_ops;
 48 | struct i40e_client;
 49 | 
 50 | /* HW does not define a type value for AEQ; only for RX/TX and CEQ.
 51 |  * In order for us to keep the interface simple, SW will define a
 52 |  * unique type value for AEQ.
 53 |  */
 54 | #define I40E_QUEUE_TYPE_PE_AEQ  0x80
 55 | #define I40E_QUEUE_INVALID_IDX	0xFFFF
 56 | 
 57 | struct i40e_qv_info {
 58 | 	u32 v_idx; /* msix_vector */
 59 | 	u16 ceq_idx;
 60 | 	u16 aeq_idx;
 61 | 	u8 itr_idx;
 62 | };
 63 | 
 64 | struct i40e_qvlist_info {
 65 | 	u32 num_vectors;
 66 | 	struct i40e_qv_info qv_info[1];
 67 | };
 68 | 
 69 | #define I40E_CLIENT_MSIX_ALL 0xFFFFFFFF
 70 | 
 71 | /* set of LAN parameters useful for clients managed by LAN */
 72 | 
 73 | /* Struct to hold per priority info */
 74 | struct i40e_prio_qos_params {
 75 | 	u16 qs_handle; /* qs handle for prio */
 76 | 	u8 tc; /* TC mapped to prio */
 77 | 	u8 reserved;
 78 | };
 79 | 
 80 | #define I40E_CLIENT_MAX_USER_PRIORITY        8
 81 | /* Struct to hold Client QoS */
 82 | struct i40e_qos_params {
 83 | 	struct i40e_prio_qos_params prio_qos[I40E_CLIENT_MAX_USER_PRIORITY];
 84 | };
 85 | 
 86 | struct i40e_params {
 87 | 	struct i40e_qos_params qos;
 88 | 	u16 mtu;
 89 | };
 90 | 
 91 | /* Structure to hold Lan device info for a client device */
 92 | struct i40e_info {
 93 | 	struct i40e_client_version version;
 94 | 	u8 lanmac[6];
 95 | 	struct net_device *netdev;
 96 | 	struct pci_dev *pcidev;
 97 | 	struct auxiliary_device *aux_dev;
 98 | 	u8 __iomem *hw_addr;
 99 | 	u8 fid;	/* function id, PF id or VF id */
100 | #define I40E_CLIENT_FTYPE_PF 0
101 | #define I40E_CLIENT_FTYPE_VF 1
102 | 	u8 ftype; /* function type, PF or VF */
103 | 	void *pf;
104 | 
105 | 	/* All L2 params that could change during the life span of the PF
106 | 	 * and needs to be communicated to the client when they change
107 | 	 */
108 | 	struct i40e_qvlist_info *qvlist_info;
109 | 	struct i40e_params params;
110 | 	struct i40e_ops *ops;
111 | 
112 | 	u16 msix_count;	 /* number of msix vectors*/
113 | 	/* Array down below will be dynamically allocated based on msix_count */
114 | 	struct msix_entry *msix_entries;
115 | 	u16 itr_index; /* Which ITR index the PE driver is suppose to use */
116 | 	u16 fw_maj_ver;                 /* firmware major version */
117 | 	u16 fw_min_ver;                 /* firmware minor version */
118 | 	u32 fw_build;                   /* firmware build number */
119 | 	struct i40e_client *client;
120 | };
121 | 
122 | struct i40e_auxiliary_device {
123 | 	struct auxiliary_device aux_dev;
124 | 	struct i40e_info *ldev;
125 | };
126 | 
127 | #define I40E_CLIENT_RESET_LEVEL_PF   1
128 | #define I40E_CLIENT_RESET_LEVEL_CORE 2
129 | #define I40E_CLIENT_VSI_FLAG_TCP_ENABLE  BIT(1)
130 | 
131 | struct i40e_ops {
132 | 	/* setup_q_vector_list enables queues with a particular vector */
133 | 	int (*setup_qvlist)(struct i40e_info *ldev, struct i40e_client *client,
134 | 			    struct i40e_qvlist_info *qv_info);
135 | 
136 | 	int (*virtchnl_send)(struct i40e_info *ldev, struct i40e_client *client,
137 | 			     u32 vf_id, u8 *msg, u16 len);
138 | 
139 | 	/* If the PE Engine is unresponsive, RDMA driver can request a reset.
140 | 	 * The level helps determine the level of reset being requested.
141 | 	 */
142 | 	void (*request_reset)(struct i40e_info *ldev,
143 | 			      struct i40e_client *client, u32 level);
144 | 
145 | 	/* API for the RDMA driver to set certain VSI flags that control
146 | 	 * PE Engine.
147 | 	 */
148 | 	int (*update_vsi_ctxt)(struct i40e_info *ldev,
149 | 			       struct i40e_client *client,
150 | 			       bool is_vf, u32 vf_id,
151 | 			       u32 flag, u32 valid_flag);
152 | 
153 | 	int (*client_device_register)(struct i40e_info *ldev);
154 | 
155 | 	void (*client_device_unregister)(struct i40e_info *ldev);
156 | };
157 | 
158 | struct i40e_client_ops {
159 | 	/* Should be called from register_client() or whenever PF is ready
160 | 	 * to create a specific client instance.
161 | 	 */
162 | 	int (*open)(struct i40e_info *ldev, struct i40e_client *client);
163 | 
164 | 	/* Should be called when netdev is unavailable or when unregister
165 | 	 * call comes in. If the close is happenening due to a reset being
166 | 	 * triggered set the reset bit to true.
167 | 	 */
168 | 	void (*close)(struct i40e_info *ldev, struct i40e_client *client,
169 | 		      bool reset);
170 | 
171 | 	/* called when some l2 managed parameters changes - mtu */
172 | 	void (*l2_param_change)(struct i40e_info *ldev,
173 | 				struct i40e_client *client,
174 | 				struct i40e_params *params);
175 | 
176 | 	int (*virtchnl_receive)(struct i40e_info *ldev,
177 | 				struct i40e_client *client, u32 vf_id,
178 | 				u8 *msg, u16 len);
179 | 
180 | 	/* called when a VF is reset by the PF */
181 | 	void (*vf_reset)(struct i40e_info *ldev,
182 | 			 struct i40e_client *client, u32 vf_id);
183 | 
184 | 	/* called when the number of VFs changes */
185 | 	void (*vf_enable)(struct i40e_info *ldev,
186 | 			  struct i40e_client *client, u32 num_vfs);
187 | 
188 | 	/* returns true if VF is capable of specified offload */
189 | 	int (*vf_capable)(struct i40e_info *ldev,
190 | 			  struct i40e_client *client, u32 vf_id);
191 | };
192 | 
193 | /* Client device */
194 | struct i40e_client_instance {
195 | 	struct list_head list;
196 | 	struct i40e_info lan_info;
197 | 	struct i40e_client *client;
198 | 	unsigned long  state;
199 | };
200 | 
201 | struct i40e_client {
202 | 	struct list_head list;		/* list of registered clients */
203 | 	char name[I40E_CLIENT_STR_LENGTH];
204 | 	struct i40e_client_version version;
205 | 	unsigned long state;		/* client state */
206 | 	atomic_t ref_cnt;  /* Count of all the client devices of this kind */
207 | 	u32 flags;
208 | #define I40E_CLIENT_FLAGS_LAUNCH_ON_PROBE	BIT(0)
209 | #define I40E_TX_FLAGS_NOTIFY_OTHER_EVENTS	BIT(2)
210 | 	u8 type;
211 | #define I40E_CLIENT_IWARP 0
212 | 	/* client ops provided by the client */
213 | 	const struct i40e_client_ops *ops;
214 | };
215 | 
216 | static inline bool i40e_client_is_registered(struct i40e_client *client)
217 | {
218 | 	return test_bit(__I40E_CLIENT_REGISTERED, &client->state);
219 | }
220 | 
221 | #endif /* _I40E_CLIENT_H_ */
222 | 
223 | 


--------------------------------------------------------------------------------
/src/i40e_dcb.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_DCB_H_
  5 | #define _I40E_DCB_H_
  6 | 
  7 | #include "i40e_type.h"
  8 | 
  9 | #define I40E_DCBX_STATUS_NOT_STARTED	0
 10 | #define I40E_DCBX_STATUS_IN_PROGRESS	1
 11 | #define I40E_DCBX_STATUS_DONE		2
 12 | #define I40E_DCBX_STATUS_MULTIPLE_PEERS	3
 13 | #define I40E_DCBX_STATUS_DISABLED	7
 14 | 
 15 | #define I40E_TLV_TYPE_END		0
 16 | #define I40E_TLV_TYPE_ORG		127
 17 | 
 18 | #define I40E_IEEE_8021QAZ_OUI		0x0080C2
 19 | #define I40E_IEEE_SUBTYPE_ETS_CFG	9
 20 | #define I40E_IEEE_SUBTYPE_ETS_REC	10
 21 | #define I40E_IEEE_SUBTYPE_PFC_CFG	11
 22 | #define I40E_IEEE_SUBTYPE_APP_PRI	12
 23 | 
 24 | #define I40E_CEE_DCBX_OUI		0x001b21
 25 | #define I40E_CEE_DCBX_TYPE		2
 26 | 
 27 | #define I40E_CEE_SUBTYPE_CTRL		1
 28 | #define I40E_CEE_SUBTYPE_PG_CFG		2
 29 | #define I40E_CEE_SUBTYPE_PFC_CFG	3
 30 | #define I40E_CEE_SUBTYPE_APP_PRI	4
 31 | 
 32 | #define I40E_CEE_MAX_FEAT_TYPE		3
 33 | #define I40E_LLDP_CURRENT_STATUS_XL710_OFFSET	0x2B
 34 | #define I40E_LLDP_CURRENT_STATUS_X722_OFFSET	0x31
 35 | #define I40E_LLDP_CURRENT_STATUS_OFFSET		1
 36 | #define I40E_LLDP_CURRENT_STATUS_SIZE		1
 37 | 
 38 | /* Defines for LLDP TLV header */
 39 | #define I40E_LLDP_TLV_LEN_SHIFT		0
 40 | #define I40E_LLDP_TLV_LEN_MASK		(0x01FF << I40E_LLDP_TLV_LEN_SHIFT)
 41 | #define I40E_LLDP_TLV_TYPE_SHIFT	9
 42 | #define I40E_LLDP_TLV_TYPE_MASK		(0x7F << I40E_LLDP_TLV_TYPE_SHIFT)
 43 | #define I40E_LLDP_TLV_SUBTYPE_SHIFT	0
 44 | #define I40E_LLDP_TLV_SUBTYPE_MASK	(0xFF << I40E_LLDP_TLV_SUBTYPE_SHIFT)
 45 | #define I40E_LLDP_TLV_OUI_SHIFT		8
 46 | #define I40E_LLDP_TLV_OUI_MASK		(0xFFFFFF << I40E_LLDP_TLV_OUI_SHIFT)
 47 | 
 48 | /* Defines for IEEE ETS TLV */
 49 | #define I40E_IEEE_ETS_MAXTC_SHIFT	0
 50 | #define I40E_IEEE_ETS_MAXTC_MASK	(0x7 << I40E_IEEE_ETS_MAXTC_SHIFT)
 51 | #define I40E_IEEE_ETS_CBS_SHIFT		6
 52 | #define I40E_IEEE_ETS_CBS_MASK		BIT(I40E_IEEE_ETS_CBS_SHIFT)
 53 | #define I40E_IEEE_ETS_WILLING_SHIFT	7
 54 | #define I40E_IEEE_ETS_WILLING_MASK	BIT(I40E_IEEE_ETS_WILLING_SHIFT)
 55 | #define I40E_IEEE_ETS_PRIO_0_SHIFT	0
 56 | #define I40E_IEEE_ETS_PRIO_0_MASK	(0x7 << I40E_IEEE_ETS_PRIO_0_SHIFT)
 57 | #define I40E_IEEE_ETS_PRIO_1_SHIFT	4
 58 | #define I40E_IEEE_ETS_PRIO_1_MASK	(0x7 << I40E_IEEE_ETS_PRIO_1_SHIFT)
 59 | #define I40E_CEE_PGID_PRIO_0_SHIFT	0
 60 | #define I40E_CEE_PGID_PRIO_0_MASK	(0xF << I40E_CEE_PGID_PRIO_0_SHIFT)
 61 | #define I40E_CEE_PGID_PRIO_1_SHIFT	4
 62 | #define I40E_CEE_PGID_PRIO_1_MASK	(0xF << I40E_CEE_PGID_PRIO_1_SHIFT)
 63 | #define I40E_CEE_PGID_STRICT		15
 64 | 
 65 | /* Defines for IEEE TSA types */
 66 | #define I40E_IEEE_TSA_STRICT		0
 67 | #define I40E_IEEE_TSA_ETS		2
 68 | 
 69 | /* Defines for IEEE PFC TLV */
 70 | #define I40E_IEEE_PFC_CAP_SHIFT		0
 71 | #define I40E_IEEE_PFC_CAP_MASK		(0xF << I40E_IEEE_PFC_CAP_SHIFT)
 72 | #define I40E_IEEE_PFC_MBC_SHIFT		6
 73 | #define I40E_IEEE_PFC_MBC_MASK		BIT(I40E_IEEE_PFC_MBC_SHIFT)
 74 | #define I40E_IEEE_PFC_WILLING_SHIFT	7
 75 | #define I40E_IEEE_PFC_WILLING_MASK	BIT(I40E_IEEE_PFC_WILLING_SHIFT)
 76 | 
 77 | /* Defines for IEEE APP TLV */
 78 | #define I40E_IEEE_APP_SEL_SHIFT		0
 79 | #define I40E_IEEE_APP_SEL_MASK		(0x7 << I40E_IEEE_APP_SEL_SHIFT)
 80 | #define I40E_IEEE_APP_PRIO_SHIFT	5
 81 | #define I40E_IEEE_APP_PRIO_MASK		(0x7 << I40E_IEEE_APP_PRIO_SHIFT)
 82 | 
 83 | /* TLV definitions for preparing MIB */
 84 | #define I40E_TLV_ID_CHASSIS_ID		0
 85 | #define I40E_TLV_ID_PORT_ID		1
 86 | #define I40E_TLV_ID_TIME_TO_LIVE	2
 87 | #define I40E_IEEE_TLV_ID_ETS_CFG	3
 88 | #define I40E_IEEE_TLV_ID_ETS_REC	4
 89 | #define I40E_IEEE_TLV_ID_PFC_CFG	5
 90 | #define I40E_IEEE_TLV_ID_APP_PRI	6
 91 | #define I40E_TLV_ID_END_OF_LLDPPDU	7
 92 | #define I40E_TLV_ID_START		I40E_IEEE_TLV_ID_ETS_CFG
 93 | 
 94 | #define I40E_IEEE_ETS_TLV_LENGTH	25
 95 | #define I40E_IEEE_PFC_TLV_LENGTH	6
 96 | #define I40E_IEEE_APP_TLV_LENGTH	11
 97 | 
 98 | /* IEEE 802.1AB LLDP Organization specific TLV */
 99 | struct i40e_lldp_org_tlv {
100 | 	__be16 typelength;
101 | 	__be32 ouisubtype;
102 | 	u8 tlvinfo[1];
103 | } __packed;
104 | 
105 | struct i40e_cee_tlv_hdr {
106 | 	__be16 typelen;
107 | 	u8 operver;
108 | 	u8 maxver;
109 | };
110 | 
111 | struct i40e_cee_ctrl_tlv {
112 | 	struct i40e_cee_tlv_hdr hdr;
113 | 	__be32 seqno;
114 | 	__be32 ackno;
115 | };
116 | 
117 | struct i40e_cee_feat_tlv {
118 | 	struct i40e_cee_tlv_hdr hdr;
119 | 	u8 en_will_err; /* Bits: |En|Will|Err|Reserved(5)| */
120 | #define I40E_CEE_FEAT_TLV_ENABLE_MASK	0x80
121 | #define I40E_CEE_FEAT_TLV_WILLING_MASK	0x40
122 | #define I40E_CEE_FEAT_TLV_ERR_MASK	0x20
123 | 	u8 subtype;
124 | 	u8 tlvinfo[1];
125 | };
126 | 
127 | struct i40e_cee_app_prio {
128 | 	__be16 protocol;
129 | 	u8 upper_oui_sel; /* Bits: |Upper OUI(6)|Selector(2)| */
130 | #define I40E_CEE_APP_SELECTOR_MASK	0x03
131 | 	__be16 lower_oui;
132 | 	u8 prio_map;
133 | } __packed;
134 | 
135 | enum i40e_get_fw_lldp_status_resp {
136 | 	I40E_GET_FW_LLDP_STATUS_DISABLED = 0,
137 | 	I40E_GET_FW_LLDP_STATUS_ENABLED = 1
138 | };
139 | 
140 | /* Data structures to pass for SW DCBX */
141 | struct i40e_rx_pb_config {
142 | 	u32	shared_pool_size;
143 | 	u32	shared_pool_high_wm;
144 | 	u32	shared_pool_low_wm;
145 | 	u32	shared_pool_high_thresh[I40E_MAX_TRAFFIC_CLASS];
146 | 	u32	shared_pool_low_thresh[I40E_MAX_TRAFFIC_CLASS];
147 | 	u32	tc_pool_size[I40E_MAX_TRAFFIC_CLASS];
148 | 	u32	tc_pool_high_wm[I40E_MAX_TRAFFIC_CLASS];
149 | 	u32	tc_pool_low_wm[I40E_MAX_TRAFFIC_CLASS];
150 | };
151 | 
152 | enum i40e_dcb_arbiter_mode {
153 | 	I40E_DCB_ARB_MODE_STRICT_PRIORITY = 0,
154 | 	I40E_DCB_ARB_MODE_ROUND_ROBIN = 1
155 | };
156 | 
157 | #define I40E_DEFAULT_PAUSE_TIME			0xffff
158 | #define I40E_MAX_FRAME_SIZE			4608 /* 4.5 KB */
159 | 
160 | #define I40E_DEVICE_RPB_SIZE			968000 /* 968 KB */
161 | 
162 | /* BitTimes (BT) conversion */
163 | #define I40E_BT2KB(BT) ((BT + (8 * 1024 - 1)) / (8 * 1024))
164 | #define I40E_B2BT(BT) (BT * 8)
165 | #define I40E_BT2B(BT) ((BT + (8 - 1)) / (8))
166 | 
167 | /* Max Frame(TC) = MFS(max) + MFS(TC) */
168 | #define I40E_MAX_FRAME_TC(mfs_max, mfs_tc)	I40E_B2BT(mfs_max + mfs_tc)
169 | 
170 | /* EEE Tx LPI Exit time in Bit Times */
171 | #define I40E_EEE_TX_LPI_EXIT_TIME		142500
172 | 
173 | /* PCI Round Trip Time in Bit Times */
174 | #define I40E_PCIRTT_LINK_SPEED_10G		20000
175 | #define I40E_PCIRTT_BYTE_LINK_SPEED_20G		40000
176 | #define I40E_PCIRTT_BYTE_LINK_SPEED_40G		80000
177 | 
178 | /* PFC Frame Delay Bit Times */
179 | #define I40E_PFC_FRAME_DELAY			672
180 | 
181 | /* Worst case Cable (10GBase-T) Delay Bit Times */
182 | #define I40E_CABLE_DELAY			5556
183 | 
184 | /* Higher Layer Delay @10G Bit Times */
185 | #define I40E_HIGHER_LAYER_DELAY_10G		6144
186 | 
187 | /* Interface Delays in Bit Times */
188 | /* TODO: Add for other link speeds 20G/40G/etc. */
189 | #define I40E_INTERFACE_DELAY_10G_MAC_CONTROL	8192
190 | #define I40E_INTERFACE_DELAY_10G_MAC		8192
191 | #define I40E_INTERFACE_DELAY_10G_RS		8192
192 | 
193 | #define I40E_INTERFACE_DELAY_XGXS		2048
194 | #define I40E_INTERFACE_DELAY_XAUI		2048
195 | 
196 | #define I40E_INTERFACE_DELAY_10G_BASEX_PCS	2048
197 | #define I40E_INTERFACE_DELAY_10G_BASER_PCS	3584
198 | #define I40E_INTERFACE_DELAY_LX4_PMD		512
199 | #define I40E_INTERFACE_DELAY_CX4_PMD		512
200 | #define I40E_INTERFACE_DELAY_SERIAL_PMA		512
201 | #define I40E_INTERFACE_DELAY_PMD		512
202 | 
203 | #define I40E_INTERFACE_DELAY_10G_BASET		25600
204 | 
205 | /* delay values for with 10G BaseT in Bit Times */
206 | #define I40E_INTERFACE_DELAY_10G_COPPER	\
207 | 	(I40E_INTERFACE_DELAY_10G_MAC + (2 * I40E_INTERFACE_DELAY_XAUI) \
208 | 	 + I40E_INTERFACE_DELAY_10G_BASET)
209 | #define I40E_DV_TC(mfs_max, mfs_tc) \
210 | 		((2 * I40E_MAX_FRAME_TC(mfs_max, mfs_tc)) \
211 | 		  + I40E_PFC_FRAME_DELAY \
212 | 		  + (2 * I40E_CABLE_DELAY) \
213 | 		  + (2 * I40E_INTERFACE_DELAY_10G_COPPER) \
214 | 		  + I40E_HIGHER_LAYER_DELAY_10G)
215 | #define I40E_STD_DV_TC(mfs_max, mfs_tc) \
216 | 		(I40E_DV_TC(mfs_max, mfs_tc) + I40E_B2BT(mfs_max))
217 | 
218 | i40e_status i40e_process_lldp_event(struct i40e_hw *hw,
219 | 					      struct i40e_arq_event_info *e);
220 | /* APIs for SW DCBX */
221 | void i40e_dcb_hw_rx_fifo_config(struct i40e_hw *hw,
222 | 				enum i40e_dcb_arbiter_mode ets_mode,
223 | 				enum i40e_dcb_arbiter_mode non_ets_mode,
224 | 				u32 max_exponent, u8 lltc_map);
225 | void i40e_dcb_hw_rx_cmd_monitor_config(struct i40e_hw *hw,
226 | 				       u8 num_tc, u8 num_ports);
227 | void i40e_dcb_hw_pfc_config(struct i40e_hw *hw,
228 | 			    u8 pfc_en, u8 *prio_tc);
229 | void i40e_dcb_hw_set_num_tc(struct i40e_hw *hw, u8 num_tc);
230 | u8 i40e_dcb_hw_get_num_tc(struct i40e_hw *hw);
231 | void i40e_dcb_hw_rx_ets_bw_config(struct i40e_hw *hw, u8 *bw_share,
232 | 				  u8 *mode, u8 *prio_type);
233 | void i40e_dcb_hw_rx_up2tc_config(struct i40e_hw *hw, u8 *prio_tc);
234 | void i40e_dcb_hw_calculate_pool_sizes(struct i40e_hw *hw,
235 | 				      u8 num_ports, bool eee_enabled,
236 | 				      u8 pfc_en, u32 *mfs_tc,
237 | 				      struct i40e_rx_pb_config *pb_cfg);
238 | void i40e_dcb_hw_rx_pb_config(struct i40e_hw *hw,
239 | 			      struct i40e_rx_pb_config *old_pb_cfg,
240 | 			      struct i40e_rx_pb_config *new_pb_cfg);
241 | i40e_status i40e_get_dcbx_status(struct i40e_hw *hw,
242 | 					   u16 *status);
243 | i40e_status i40e_lldp_to_dcb_config(u8 *lldpmib,
244 | 					      struct i40e_dcbx_config *dcbcfg);
245 | i40e_status i40e_aq_get_dcb_config(struct i40e_hw *hw, u8 mib_type,
246 | 					     u8 bridgetype,
247 | 					     struct i40e_dcbx_config *dcbcfg);
248 | i40e_status i40e_get_dcb_config(struct i40e_hw *hw);
249 | i40e_status i40e_init_dcb(struct i40e_hw *hw,
250 | 				    bool enable_mib_change);
251 | enum i40e_status_code
252 | i40e_get_fw_lldp_status(struct i40e_hw *hw,
253 | 			enum i40e_get_fw_lldp_status_resp *lldp_status);
254 | i40e_status i40e_set_dcb_config(struct i40e_hw *hw);
255 | i40e_status i40e_dcb_config_to_lldp(u8 *lldpmib, u16 *miblen,
256 | 					      struct i40e_dcbx_config *dcbcfg);
257 | #endif /* _I40E_DCB_H_ */
258 | 


--------------------------------------------------------------------------------
/src/i40e_devids.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #define _I40E_DEVIDS_H_
 5 | 
 6 | /* Device IDs */
 7 | #define I40E_DEV_ID_X710_N3000		0x0CF8
 8 | #define I40E_DEV_ID_XXV710_N3000	0x0D58
 9 | #define I40E_DEV_ID_SFP_XL710		0x1572
10 | #define I40E_DEV_ID_QEMU		0x1574
11 | #define I40E_DEV_ID_KX_B		0x1580
12 | #define I40E_DEV_ID_KX_C		0x1581
13 | #define I40E_DEV_ID_QSFP_A		0x1583
14 | #define I40E_DEV_ID_QSFP_B		0x1584
15 | #define I40E_DEV_ID_QSFP_C		0x1585
16 | #define I40E_DEV_ID_10G_BASE_T		0x1586
17 | #define I40E_DEV_ID_20G_KR2		0x1587
18 | #define I40E_DEV_ID_20G_KR2_A		0x1588
19 | #define I40E_DEV_ID_10G_BASE_T4		0x1589
20 | #define I40E_DEV_ID_25G_B		0x158A
21 | #define I40E_DEV_ID_25G_SFP28		0x158B
22 | #define I40E_DEV_ID_10G_BASE_T_BC	0x15FF
23 | #define I40E_DEV_ID_10G_B		0x104F
24 | #define I40E_DEV_ID_10G_SFP		0x104E
25 | #define I40E_DEV_ID_5G_BASE_T_BC	0x101F
26 | #define I40E_DEV_ID_1G_BASE_T_BC	0x0DD2
27 | #define I40E_IS_X710TL_DEVICE(d) \
28 | 	(((d) == I40E_DEV_ID_10G_BASE_T_BC) || \
29 | 	((d) == I40E_DEV_ID_5G_BASE_T_BC) || \
30 | 	((d) == I40E_DEV_ID_1G_BASE_T_BC))
31 | #define I40E_DEV_ID_KX_X722		0x37CE
32 | #define I40E_DEV_ID_QSFP_X722		0x37CF
33 | #define I40E_DEV_ID_SFP_X722		0x37D0
34 | #define I40E_DEV_ID_1G_BASE_T_X722	0x37D1
35 | #define I40E_DEV_ID_10G_BASE_T_X722	0x37D2
36 | #define I40E_DEV_ID_SFP_I_X722		0x37D3
37 | #define I40E_DEV_ID_SFP_X722_A		0x0DDA
38 | 
39 | #define i40e_is_40G_device(d)		((d) == I40E_DEV_ID_QSFP_A  || \
40 | 					 (d) == I40E_DEV_ID_QSFP_B  || \
41 | 					 (d) == I40E_DEV_ID_QSFP_C)
42 | 
43 | #define i40e_is_25G_device(d)		((d) == I40E_DEV_ID_25G_B  || \
44 | 					 (d) == I40E_DEV_ID_25G_SFP28  || \
45 | 					 (d) == I40E_DEV_ID_XXV710_N3000)
46 | 
47 | 


--------------------------------------------------------------------------------
/src/i40e_diag.c:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #include "i40e_diag.h"
  5 | #include "i40e_prototype.h"
  6 | 
  7 | /**
  8 |  * i40e_diag_reg_pattern_test
  9 |  * @hw: pointer to the hw struct
 10 |  * @reg: reg to be tested
 11 |  * @mask: bits to be touched
 12 |  **/
 13 | static i40e_status i40e_diag_reg_pattern_test(struct i40e_hw *hw,
 14 | 							u32 reg, u32 mask)
 15 | {
 16 | 	const u32 patterns[] = {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
 17 | 	u32 pat, val, orig_val;
 18 | 	int i;
 19 | 
 20 | 	orig_val = rd32(hw, reg);
 21 | 	for (i = 0; i < ARRAY_SIZE(patterns); i++) {
 22 | 		pat = patterns[i];
 23 | 		wr32(hw, reg, (pat & mask));
 24 | 		val = rd32(hw, reg);
 25 | 		if ((val & mask) != (pat & mask)) {
 26 | #ifdef ETHTOOL_TEST
 27 | 			i40e_debug(hw, I40E_DEBUG_DIAG,
 28 | 				   "%s: reg pattern test failed - reg 0x%08x pat 0x%08x val 0x%08x\n",
 29 | 				   __func__, reg, pat, val);
 30 | #endif
 31 | 			return I40E_ERR_DIAG_TEST_FAILED;
 32 | 		}
 33 | 	}
 34 | 
 35 | 	wr32(hw, reg, orig_val);
 36 | 	val = rd32(hw, reg);
 37 | 	if (val != orig_val) {
 38 | #ifdef ETHTOOL_TEST
 39 | 		i40e_debug(hw, I40E_DEBUG_DIAG,
 40 | 			   "%s: reg restore test failed - reg 0x%08x orig_val 0x%08x val 0x%08x\n",
 41 | 			   __func__, reg, orig_val, val);
 42 | #endif
 43 | 		return I40E_ERR_DIAG_TEST_FAILED;
 44 | 	}
 45 | 
 46 | 	return I40E_SUCCESS;
 47 | }
 48 | 
 49 | const struct i40e_diag_reg_test_info i40e_reg_list[] = {
 50 | 	/* offset               mask         elements   stride */
 51 | 	{I40E_QTX_CTL(0),       0x0000FFBF, 1, I40E_QTX_CTL(1) - I40E_QTX_CTL(0)},
 52 | 	{I40E_PFINT_ITR0(0),    0x00000FFF, 3, I40E_PFINT_ITR0(1) - I40E_PFINT_ITR0(0)},
 53 | 	{I40E_PFINT_ITRN(0, 0), 0x00000FFF, 1, I40E_PFINT_ITRN(0, 1) - I40E_PFINT_ITRN(0, 0)},
 54 | 	{I40E_PFINT_ITRN(1, 0), 0x00000FFF, 1, I40E_PFINT_ITRN(1, 1) - I40E_PFINT_ITRN(1, 0)},
 55 | 	{I40E_PFINT_ITRN(2, 0), 0x00000FFF, 1, I40E_PFINT_ITRN(2, 1) - I40E_PFINT_ITRN(2, 0)},
 56 | 	{I40E_PFINT_STAT_CTL0,  0x0000000C, 1, 0},
 57 | 	{I40E_PFINT_LNKLST0,    0x00001FFF, 1, 0},
 58 | 	{I40E_PFINT_LNKLSTN(0), 0x000007FF, 1, I40E_PFINT_LNKLSTN(1) - I40E_PFINT_LNKLSTN(0)},
 59 | 	{I40E_QINT_TQCTL(0),    0x000000FF, 1, I40E_QINT_TQCTL(1) - I40E_QINT_TQCTL(0)},
 60 | 	{I40E_QINT_RQCTL(0),    0x000000FF, 1, I40E_QINT_RQCTL(1) - I40E_QINT_RQCTL(0)},
 61 | 	{I40E_PFINT_ICR0_ENA,   0xF7F20000, 1, 0},
 62 | 	{ 0 }
 63 | };
 64 | 
 65 | /**
 66 |  * i40e_diag_reg_test
 67 |  * @hw: pointer to the hw struct
 68 |  *
 69 |  * Perform registers diagnostic test
 70 |  **/
 71 | i40e_status i40e_diag_reg_test(struct i40e_hw *hw)
 72 | {
 73 | 	i40e_status ret_code = I40E_SUCCESS;
 74 | 	u32 reg, mask;
 75 | 	u32 elements;
 76 | 	u32 i, j;
 77 | 
 78 | 	for (i = 0; i40e_reg_list[i].offset != 0 &&
 79 | 					     ret_code == I40E_SUCCESS; i++) {
 80 | 
 81 | 		elements = i40e_reg_list[i].elements;
 82 | 		/* set actual reg range for dynamically allocated resources */
 83 | 		if (i40e_reg_list[i].offset == I40E_QTX_CTL(0) &&
 84 | 		    hw->func_caps.num_tx_qp != 0)
 85 | 			elements = hw->func_caps.num_tx_qp;
 86 | 		if ((i40e_reg_list[i].offset == I40E_PFINT_ITRN(0, 0) ||
 87 | 		     i40e_reg_list[i].offset == I40E_PFINT_ITRN(1, 0) ||
 88 | 		     i40e_reg_list[i].offset == I40E_PFINT_ITRN(2, 0) ||
 89 | 		     i40e_reg_list[i].offset == I40E_QINT_TQCTL(0) ||
 90 | 		     i40e_reg_list[i].offset == I40E_QINT_RQCTL(0)) &&
 91 | 		    hw->func_caps.num_msix_vectors != 0)
 92 | 			elements = hw->func_caps.num_msix_vectors - 1;
 93 | 
 94 | 		/* test register access */
 95 | 		mask = i40e_reg_list[i].mask;
 96 | 		for (j = 0; j < elements && ret_code == I40E_SUCCESS; j++) {
 97 | 			reg = i40e_reg_list[i].offset
 98 | 				+ (j * i40e_reg_list[i].stride);
 99 | 			ret_code = i40e_diag_reg_pattern_test(hw, reg, mask);
100 | 		}
101 | 	}
102 | 
103 | 	return ret_code;
104 | }
105 | 
106 | /**
107 |  * i40e_diag_eeprom_test
108 |  * @hw: pointer to the hw struct
109 |  *
110 |  * Perform EEPROM diagnostic test
111 |  **/
112 | i40e_status i40e_diag_eeprom_test(struct i40e_hw *hw)
113 | {
114 | 	i40e_status ret_code;
115 | 	u16 reg_val;
116 | 
117 | 	/* read NVM control word and if NVM valid, validate EEPROM checksum*/
118 | 	ret_code = i40e_read_nvm_word(hw, I40E_SR_NVM_CONTROL_WORD, &reg_val);
119 | 	if ((ret_code == I40E_SUCCESS) &&
120 | 	    ((reg_val & I40E_SR_CONTROL_WORD_1_MASK) ==
121 | 	     BIT(I40E_SR_CONTROL_WORD_1_SHIFT)))
122 | 		return i40e_validate_nvm_checksum(hw, NULL);
123 | 	else
124 | 		return I40E_ERR_DIAG_TEST_FAILED;
125 | }
126 | 
127 | 


--------------------------------------------------------------------------------
/src/i40e_diag.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _I40E_DIAG_H_
 5 | #define _I40E_DIAG_H_
 6 | 
 7 | #include "i40e_type.h"
 8 | 
 9 | enum i40e_lb_mode {
10 | 	I40E_LB_MODE_NONE       = 0x0,
11 | 	I40E_LB_MODE_PHY_LOCAL  = I40E_AQ_LB_PHY_LOCAL,
12 | 	I40E_LB_MODE_PHY_REMOTE = I40E_AQ_LB_PHY_REMOTE,
13 | 	I40E_LB_MODE_MAC_LOCAL  = I40E_AQ_LB_MAC_LOCAL,
14 | };
15 | 
16 | struct i40e_diag_reg_test_info {
17 | 	u32 offset;	/* the base register */
18 | 	u32 mask;	/* bits that can be tested */
19 | 	u32 elements;	/* number of elements if array */
20 | 	u32 stride;	/* bytes between each element */
21 | };
22 | 
23 | extern const struct i40e_diag_reg_test_info i40e_reg_list[];
24 | 
25 | i40e_status i40e_diag_reg_test(struct i40e_hw *hw);
26 | i40e_status i40e_diag_eeprom_test(struct i40e_hw *hw);
27 | 
28 | #endif /* _I40E_DIAG_H_ */
29 | 


--------------------------------------------------------------------------------
/src/i40e_ethtool_stats.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | /* ethtool statistics helpers */
  5 | 
  6 | /**
  7 |  * struct i40e_stats - definition for an ethtool statistic
  8 |  * @stat_string: statistic name to display in ethtool -S output
  9 |  * @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64)
 10 |  * @stat_offset: offsetof() the stat from a base pointer
 11 |  *
 12 |  * This structure defines a statistic to be added to the ethtool stats buffer.
 13 |  * It defines a statistic as offset from a common base pointer. Stats should
 14 |  * be defined in constant arrays using the I40E_STAT macro, with every element
 15 |  * of the array using the same _type for calculating the sizeof_stat and
 16 |  * stat_offset.
 17 |  *
 18 |  * The sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or
 19 |  * sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from
 20 |  * the i40e_add_ethtool_stat() helper function.
 21 |  *
 22 |  * The stat_string is interpreted as a format string, allowing formatted
 23 |  * values to be inserted while looping over multiple structures for a given
 24 |  * statistics array. Thus, every statistic string in an array should have the
 25 |  * same type and number of format specifiers, to be formatted by variadic
 26 |  * arguments to the i40e_add_stat_string() helper function.
 27 |  **/
 28 | struct i40e_stats {
 29 | 	char stat_string[ETH_GSTRING_LEN];
 30 | 	int sizeof_stat;
 31 | 	int stat_offset;
 32 | };
 33 | 
 34 | /* Helper macro to define an i40e_stat structure with proper size and type.
 35 |  * Use this when defining constant statistics arrays. Note that @_type expects
 36 |  * only a type name and is used multiple times.
 37 |  */
 38 | #define I40E_STAT(_type, _name, _stat) { \
 39 | 	.stat_string = _name, \
 40 | 	.sizeof_stat = sizeof_field(_type, _stat), \
 41 | 	.stat_offset = offsetof(_type, _stat) \
 42 | }
 43 | 
 44 | /* Helper macro for defining some statistics directly copied from the netdev
 45 |  * stats structure.
 46 |  */
 47 | #ifdef HAVE_NDO_GET_STATS64
 48 | #define I40E_NETDEV_STAT(_net_stat) \
 49 | 	I40E_STAT(struct rtnl_link_stats64, #_net_stat, _net_stat)
 50 | #else
 51 | #define I40E_NETDEV_STAT(_net_stat) \
 52 | 	I40E_STAT(struct net_device_stats, #_net_stat, _net_stat)
 53 | #endif
 54 | 
 55 | /* Helper macro for defining some statistics related to queues */
 56 | #define I40E_QUEUE_STAT(_name, _stat) \
 57 | 	I40E_STAT(struct i40e_ring, _name, _stat)
 58 | 
 59 | /* Stats associated with a Tx or Rx ring */
 60 | static const struct i40e_stats i40e_gstrings_queue_stats[] = {
 61 | 	I40E_QUEUE_STAT("%s-%u.packets", stats.packets),
 62 | 	I40E_QUEUE_STAT("%s-%u.bytes", stats.bytes),
 63 | };
 64 | 
 65 | #ifdef HAVE_XDP_SUPPORT
 66 | /* Stats associated with Rx ring's XDP prog */
 67 | static const struct i40e_stats i40e_gstrings_rx_queue_xdp_stats[] = {
 68 | 	I40E_QUEUE_STAT("%s-%u.xdp.pass", xdp_stats.xdp_pass),
 69 | 	I40E_QUEUE_STAT("%s-%u.xdp.drop", xdp_stats.xdp_drop),
 70 | 	I40E_QUEUE_STAT("%s-%u.xdp.tx", xdp_stats.xdp_tx),
 71 | 	I40E_QUEUE_STAT("%s-%u.xdp.unknown", xdp_stats.xdp_unknown),
 72 | 	I40E_QUEUE_STAT("%s-%u.xdp.redirect", xdp_stats.xdp_redirect),
 73 | 	I40E_QUEUE_STAT("%s-%u.xdp.redirect_fail", xdp_stats.xdp_redirect_fail),
 74 | };
 75 | #endif
 76 | 
 77 | /**
 78 |  * i40e_add_one_ethtool_stat - copy the stat into the supplied buffer
 79 |  * @data: location to store the stat value
 80 |  * @pointer: basis for where to copy from
 81 |  * @stat: the stat definition
 82 |  *
 83 |  * Copies the stat data defined by the pointer and stat structure pair into
 84 |  * the memory supplied as data. Used to implement i40e_add_ethtool_stats and
 85 |  * i40e_add_queue_stats. If the pointer is null, data will be zero'd.
 86 |  */
 87 | static void
 88 | i40e_add_one_ethtool_stat(u64 *data, void *pointer,
 89 | 			  const struct i40e_stats *stat)
 90 | {
 91 | 	char *p;
 92 | 
 93 | 	if (!pointer) {
 94 | 		/* ensure that the ethtool data buffer is zero'd for any stats
 95 | 		 * which don't have a valid pointer.
 96 | 		 */
 97 | 		*data = 0;
 98 | 		return;
 99 | 	}
100 | 
101 | 	p = (char *)pointer + stat->stat_offset;
102 | 	switch (stat->sizeof_stat) {
103 | 	case sizeof(u64):
104 | 		*data = *((u64 *)p);
105 | 		break;
106 | 	case sizeof(u32):
107 | 		*data = *((u32 *)p);
108 | 		break;
109 | 	case sizeof(u16):
110 | 		*data = *((u16 *)p);
111 | 		break;
112 | 	case sizeof(u8):
113 | 		*data = *((u8 *)p);
114 | 		break;
115 | 	default:
116 | 		WARN_ONCE(1, "unexpected stat size for %s",
117 | 			  stat->stat_string);
118 | 		*data = 0;
119 | 	}
120 | }
121 | 
122 | /**
123 |  * __i40e_add_ethtool_stats - copy stats into the ethtool supplied buffer
124 |  * @data: ethtool stats buffer
125 |  * @pointer: location to copy stats from
126 |  * @stats: array of stats to copy
127 |  * @size: the size of the stats definition
128 |  *
129 |  * Copy the stats defined by the stats array using the pointer as a base into
130 |  * the data buffer supplied by ethtool. Updates the data pointer to point to
131 |  * the next empty location for successive calls to __i40e_add_ethtool_stats.
132 |  * If pointer is null, set the data values to zero and update the pointer to
133 |  * skip these stats.
134 |  **/
135 | static void
136 | __i40e_add_ethtool_stats(u64 **data, void *pointer,
137 | 			 const struct i40e_stats stats[],
138 | 			 const unsigned int size)
139 | {
140 | 	unsigned int i;
141 | 
142 | 	for (i = 0; i < size; i++)
143 | 		i40e_add_one_ethtool_stat((*data)++, pointer, &stats[i]);
144 | }
145 | 
146 | /**
147 |  * i40e_add_ethtool_stats - copy stats into ethtool supplied buffer
148 |  * @data: ethtool stats buffer
149 |  * @pointer: location where stats are stored
150 |  * @stats: static const array of stat definitions
151 |  *
152 |  * Macro to ease the use of __i40e_add_ethtool_stats by taking a static
153 |  * constant stats array and passing the ARRAY_SIZE(). This avoids typos by
154 |  * ensuring that we pass the size associated with the given stats array.
155 |  *
156 |  * The parameter stats is evaluated twice, so parameters with side effects
157 |  * should be avoided.
158 |  **/
159 | #define i40e_add_ethtool_stats(data, pointer, stats) \
160 | 	__i40e_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
161 | 
162 | /**
163 |  * i40e_add_queue_stats - copy queue statistics into supplied buffer
164 |  * @data: ethtool stats buffer
165 |  * @ring: the ring to copy
166 |  *
167 |  * Queue statistics must be copied while protected by
168 |  * u64_stats_fetch_begin, so we can't directly use i40e_add_ethtool_stats.
169 |  * Assumes that queue stats are defined in i40e_gstrings_queue_stats. If the
170 |  * ring pointer is null, zero out the queue stat values and update the data
171 |  * pointer. Otherwise safely copy the stats from the ring into the supplied
172 |  * buffer and update the data pointer when finished.
173 |  *
174 |  * This function expects to be called while under rcu_read_lock().
175 |  **/
176 | static void
177 | i40e_add_queue_stats(u64 **data, struct i40e_ring *ring)
178 | {
179 | 	const unsigned int size = ARRAY_SIZE(i40e_gstrings_queue_stats);
180 | 	const struct i40e_stats *stats = i40e_gstrings_queue_stats;
181 | #ifdef HAVE_NDO_GET_STATS64
182 | 	unsigned int start;
183 | #endif
184 | 	unsigned int i;
185 | 
186 | 	/* To avoid invalid statistics values, ensure that we keep retrying
187 | 	 * the copy until we get a consistent value according to
188 | 	 * u64_stats_fetch_retry. But first, make sure our ring is
189 | 	 * non-null before attempting to access its syncp.
190 | 	 */
191 | #ifdef HAVE_NDO_GET_STATS64
192 | 	do {
193 | 		start = !ring ? 0 : u64_stats_fetch_begin(&ring->syncp);
194 | 		for (i = 0; i < size; i++)
195 | 			i40e_add_one_ethtool_stat(&(*data)[i], ring, &stats[i]);
196 | 	} while (ring && u64_stats_fetch_retry(&ring->syncp, start));
197 | #else
198 | 	for (i = 0; i < size; i++)
199 | 		i40e_add_one_ethtool_stat(&(*data)[i], ring, &stats[i]);
200 | #endif
201 | 
202 | 	/* Once we successfully copy the stats in, update the data pointer */
203 | 	*data += size;
204 | }
205 | 
206 | #ifdef HAVE_XDP_SUPPORT
207 | /**
208 |  * i40e_add_rx_queue_xdp_stats - copy XDP statistics into supplied buffer
209 |  * @data: ethtool stats buffer
210 |  * @rx_ring: the rx ring to copy
211 |  *
212 |  * RX queue XDP statistics must be copied while protected by
213 |  * u64_stats_fetch_begin, so we can't directly use i40e_add_ethtool_stats.
214 |  * Assumes that queue stats are defined in i40e_gstrings_rx_queue_xdp_stats. If
215 |  * the ring pointer is null, zero out the queue stat values and update the data
216 |  * pointer. Otherwise safely copy the stats from the ring into the supplied
217 |  * buffer and update the data pointer when finished.
218 |  *
219 |  * This function expects to be called while under rcu_read_lock().
220 |  **/
221 | static void
222 | i40e_add_rx_queue_xdp_stats(u64 **data, struct i40e_ring *rx_ring)
223 | {
224 | 	const unsigned int xdp_size =
225 | 		ARRAY_SIZE(i40e_gstrings_rx_queue_xdp_stats);
226 | 	const struct i40e_stats *xdp_stats = i40e_gstrings_rx_queue_xdp_stats;
227 | #ifdef HAVE_NDO_GET_STATS64
228 | 	unsigned int start;
229 | #endif
230 | 	unsigned int i;
231 | 
232 | 	/* To avoid invalid statistics values, ensure that we keep retrying
233 | 	 * the copy until we get a consistent value according to
234 | 	 * u64_stats_fetch_retry. But first, make sure our ring is
235 | 	 * non-null before attempting to access its syncp.
236 | 	 */
237 | #ifdef HAVE_NDO_GET_STATS64
238 | 	do {
239 | 		start = !rx_ring ? 0 :
240 | 			u64_stats_fetch_begin(&rx_ring->syncp);
241 | #endif
242 | 	for (i = 0; i < xdp_size; i++) {
243 | 		i40e_add_one_ethtool_stat(&(*data)[i], rx_ring,
244 | 					  &xdp_stats[i]);
245 | 	}
246 | #ifdef HAVE_NDO_GET_STATS64
247 | 	} while (rx_ring && u64_stats_fetch_retry(&rx_ring->syncp, start));
248 | #endif
249 | 
250 | 	/* Once we successfully copy the stats in, update the data pointer */
251 | 	*data += xdp_size;
252 | }
253 | #endif
254 | 
255 | /**
256 |  * __i40e_add_stat_strings - copy stat strings into ethtool buffer
257 |  * @p: ethtool supplied buffer
258 |  * @stats: stat definitions array
259 |  * @size: size of the stats array
260 |  *
261 |  * Format and copy the strings described by stats into the buffer pointed at
262 |  * by p.
263 |  **/
264 | static void __i40e_add_stat_strings(u8 **p, const struct i40e_stats stats[],
265 | 				    const unsigned int size, ...)
266 | {
267 | 	unsigned int i;
268 | 
269 | 	for (i = 0; i < size; i++) {
270 | 		va_list args;
271 | 
272 | 		va_start(args, size);
273 | 		vsnprintf((char *)*p, ETH_GSTRING_LEN, stats[i].stat_string, args);
274 | 		*p += ETH_GSTRING_LEN;
275 | 		va_end(args);
276 | 	}
277 | }
278 | 
279 | /**
280 |  * i40e_add_stat_strings - copy stat strings into ethtool buffer
281 |  * @p: ethtool supplied buffer
282 |  * @stats: stat definitions array
283 |  *
284 |  * Format and copy the strings described by the const static stats value into
285 |  * the buffer pointed at by p.
286 |  *
287 |  * The parameter stats is evaluated twice, so parameters with side effects
288 |  * should be avoided. Additionally, stats must be an array such that
289 |  * ARRAY_SIZE can be called on it.
290 |  **/
291 | #define i40e_add_stat_strings(p, stats, ...) \
292 | 	__i40e_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
293 | 


--------------------------------------------------------------------------------
/src/i40e_filters.c:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #include "i40e_filters.h"
 5 | 
 6 | /**
 7 |  * __i40e_del_filter - Remove a specific filter from the VSI
 8 |  * @vsi: VSI to remove from
 9 |  * @f: the filter to remove from the list
10 |  *
11 |  * This function should be called instead of i40e_del_filter only if you know
12 |  * the exact filter you will remove already, such as via i40e_find_filter or
13 |  * i40e_find_mac.
14 |  *
15 |  * NOTE: This function is expected to be called with mac_filter_hash_lock
16 |  * being held.
17 |  * ANOTHER NOTE: This function MUST be called from within the context of
18 |  * the "safe" variants of any list iterators, e.g. list_for_each_entry_safe()
19 |  * instead of list_for_each_entry().
20 |  **/
21 | void __i40e_del_filter(struct i40e_vsi *vsi, struct i40e_mac_filter *f)
22 | {
23 | 	if (!f)
24 | 		return;
25 | 
26 | 	/* If the filter was never added to firmware then we can just delete it
27 | 	 * directly and we don't want to set the status to remove or else an
28 | 	 * admin queue command will unnecessarily fire.
29 | 	 */
30 | 	if (f->state == I40E_FILTER_FAILED || f->state == I40E_FILTER_NEW) {
31 | 		hash_del(&f->hlist);
32 | 		kfree(f);
33 | 	} else {
34 | 		f->state = I40E_FILTER_REMOVE;
35 | 	}
36 | 
37 | 	vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
38 | 	set_bit(__I40E_MACVLAN_SYNC_PENDING, vsi->back->state);
39 | }
40 | 
41 | 


--------------------------------------------------------------------------------
/src/i40e_filters.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _I40E_FILTERS_H_
 5 | #define _I40E_FILTERS_H_
 6 | 
 7 | #include "i40e.h"
 8 | 
 9 | void __i40e_del_filter(struct i40e_vsi *vsi, struct i40e_mac_filter *f);
10 | 
11 | #endif /* _I40E_FILTERS_H_ */
12 | 


--------------------------------------------------------------------------------
/src/i40e_helper.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_HELPER_H_
  5 | #define _I40E_HELPER_H_
  6 | 
  7 | #include "i40e_alloc.h"
  8 | 
  9 | /**
 10 |  * i40e_allocate_dma_mem_d - OS specific memory alloc for shared code
 11 |  * @hw:   pointer to the HW structure
 12 |  * @mem:  ptr to mem struct to fill out
 13 |  * @mtype: memory type identifier (unused)
 14 |  * @size: size of memory requested
 15 |  * @alignment: what to align the allocation to
 16 |  **/
 17 | inline int i40e_allocate_dma_mem_d(struct i40e_hw *hw,
 18 | 				   struct i40e_dma_mem *mem,
 19 | 				   __always_unused enum i40e_memory_type mtype,
 20 | 				   u64 size, u32 alignment)
 21 | {
 22 | 	struct i40e_pf *nf = (struct i40e_pf *)hw->back;
 23 | 
 24 | 	mem->size = ALIGN(size, alignment);
 25 | #ifdef HAVE_DMA_ALLOC_COHERENT_ZEROES_MEM
 26 | 	mem->va = dma_alloc_coherent(&nf->pdev->dev, mem->size,
 27 | 				     &mem->pa, GFP_KERNEL);
 28 | #else
 29 | 	mem->va = dma_zalloc_coherent(&nf->pdev->dev, mem->size,
 30 | 				      &mem->pa, GFP_KERNEL);
 31 | #endif
 32 | 	if (!mem->va)
 33 | 		return -ENOMEM;
 34 | 
 35 | 	return 0;
 36 | }
 37 | 
 38 | /**
 39 |  * i40e_free_dma_mem_d - OS specific memory free for shared code
 40 |  * @hw:   pointer to the HW structure
 41 |  * @mem:  ptr to mem struct to free
 42 |  **/
 43 | inline int i40e_free_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem)
 44 | {
 45 | 	struct i40e_pf *nf = (struct i40e_pf *)hw->back;
 46 | 
 47 | 	dma_free_coherent(&nf->pdev->dev, mem->size, mem->va, mem->pa);
 48 | 	mem->va = NULL;
 49 | 	mem->pa = 0;
 50 | 	mem->size = 0;
 51 | 
 52 | 	return 0;
 53 | }
 54 | 
 55 | /**
 56 |  * i40e_allocate_virt_mem_d - OS specific memory alloc for shared code
 57 |  * @hw:   pointer to the HW structure
 58 |  * @mem:  ptr to mem struct to fill out
 59 |  * @size: size of memory requested
 60 |  **/
 61 | inline int i40e_allocate_virt_mem_d(struct i40e_hw *hw,
 62 | 				    struct i40e_virt_mem *mem,
 63 | 				    u32 size)
 64 | {
 65 | 	mem->size = size;
 66 | 	mem->va = kzalloc(size, GFP_KERNEL);
 67 | 
 68 | 	if (!mem->va)
 69 | 		return -ENOMEM;
 70 | 
 71 | 	return 0;
 72 | }
 73 | 
 74 | /**
 75 |  * i40e_free_virt_mem_d - OS specific memory free for shared code
 76 |  * @hw:   pointer to the HW structure
 77 |  * @mem:  ptr to mem struct to free
 78 |  **/
 79 | inline int i40e_free_virt_mem_d(struct i40e_hw *hw, struct i40e_virt_mem *mem)
 80 | {
 81 | 	/* it's ok to kfree a NULL pointer */
 82 | 	kfree(mem->va);
 83 | 	mem->va = NULL;
 84 | 	mem->size = 0;
 85 | 
 86 | 	return 0;
 87 | }
 88 | 
 89 | /* prototype */
 90 | inline void i40e_destroy_spinlock_d(struct i40e_spinlock *sp);
 91 | inline void i40e_acquire_spinlock_d(struct i40e_spinlock *sp);
 92 | inline void i40e_release_spinlock_d(struct i40e_spinlock *sp);
 93 | 
 94 | /**
 95 |  * i40e_init_spinlock_d - OS specific spinlock init for shared code
 96 |  * @sp: pointer to a spinlock declared in driver space
 97 |  **/
 98 | static inline void i40e_init_spinlock_d(struct i40e_spinlock *sp)
 99 | {
100 | 	mutex_init((struct mutex *)sp);
101 | }
102 | 
103 | /**
104 |  * i40e_acquire_spinlock_d - OS specific spinlock acquire for shared code
105 |  * @sp: pointer to a spinlock declared in driver space
106 |  **/
107 | inline void i40e_acquire_spinlock_d(struct i40e_spinlock *sp)
108 | {
109 | 	mutex_lock((struct mutex *)sp);
110 | }
111 | 
112 | /**
113 |  * i40e_release_spinlock_d - OS specific spinlock release for shared code
114 |  * @sp: pointer to a spinlock declared in driver space
115 |  **/
116 | inline void i40e_release_spinlock_d(struct i40e_spinlock *sp)
117 | {
118 | 	mutex_unlock((struct mutex *)sp);
119 | }
120 | 
121 | /**
122 |  * i40e_destroy_spinlock_d - OS specific spinlock destroy for shared code
123 |  * @sp: pointer to a spinlock declared in driver space
124 |  **/
125 | inline void i40e_destroy_spinlock_d(struct i40e_spinlock *sp)
126 | {
127 | 	mutex_destroy((struct mutex *)sp);
128 | }
129 | #endif /* _I40E_HELPER_H_ */
130 | 


--------------------------------------------------------------------------------
/src/i40e_hmc.c:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #include "i40e_osdep.h"
  5 | #include "i40e_register.h"
  6 | #include "i40e_status.h"
  7 | #include "i40e_alloc.h"
  8 | #include "i40e_hmc.h"
  9 | #ifndef I40E_NO_TYPE_HEADER
 10 | #include "i40e_type.h"
 11 | #endif
 12 | 
 13 | /**
 14 |  * i40e_add_sd_table_entry - Adds a segment descriptor to the table
 15 |  * @hw: pointer to our hw struct
 16 |  * @hmc_info: pointer to the HMC configuration information struct
 17 |  * @sd_index: segment descriptor index to manipulate
 18 |  * @type: what type of segment descriptor we're manipulating
 19 |  * @direct_mode_sz: size to alloc in direct mode
 20 |  **/
 21 | i40e_status i40e_add_sd_table_entry(struct i40e_hw *hw,
 22 | 					      struct i40e_hmc_info *hmc_info,
 23 | 					      u32 sd_index,
 24 | 					      enum i40e_sd_entry_type type,
 25 | 					      u64 direct_mode_sz)
 26 | {
 27 | 	i40e_status ret_code = I40E_SUCCESS;
 28 | 	struct i40e_hmc_sd_entry *sd_entry;
 29 | 	enum   i40e_memory_type mem_type;
 30 | 	bool dma_mem_alloc_done = false;
 31 | 	struct i40e_dma_mem mem;
 32 | 	u64 alloc_len;
 33 | 
 34 | 	if (NULL == hmc_info->sd_table.sd_entry) {
 35 | 		ret_code = I40E_ERR_BAD_PTR;
 36 | 		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_entry\n");
 37 | 		goto exit;
 38 | 	}
 39 | 
 40 | 	if (sd_index >= hmc_info->sd_table.sd_cnt) {
 41 | 		ret_code = I40E_ERR_INVALID_SD_INDEX;
 42 | 		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_index\n");
 43 | 		goto exit;
 44 | 	}
 45 | 
 46 | 	sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
 47 | 	if (!sd_entry->valid) {
 48 | 		if (I40E_SD_TYPE_PAGED == type) {
 49 | 			mem_type = i40e_mem_pd;
 50 | 			alloc_len = I40E_HMC_PAGED_BP_SIZE;
 51 | 		} else {
 52 | 			mem_type = i40e_mem_bp_jumbo;
 53 | 			alloc_len = direct_mode_sz;
 54 | 		}
 55 | 
 56 | 		/* allocate a 4K pd page or 2M backing page */
 57 | 		ret_code = i40e_allocate_dma_mem(hw, &mem, mem_type, alloc_len,
 58 | 						 I40E_HMC_PD_BP_BUF_ALIGNMENT);
 59 | 		if (ret_code)
 60 | 			goto exit;
 61 | 		dma_mem_alloc_done = true;
 62 | 		if (I40E_SD_TYPE_PAGED == type) {
 63 | 			ret_code = i40e_allocate_virt_mem(hw,
 64 | 					&sd_entry->u.pd_table.pd_entry_virt_mem,
 65 | 					sizeof(struct i40e_hmc_pd_entry) * 512);
 66 | 			if (ret_code)
 67 | 				goto exit;
 68 | 			sd_entry->u.pd_table.pd_entry =
 69 | 				(struct i40e_hmc_pd_entry *)
 70 | 				sd_entry->u.pd_table.pd_entry_virt_mem.va;
 71 | 			i40e_memcpy(&sd_entry->u.pd_table.pd_page_addr,
 72 | 				    &mem, sizeof(struct i40e_dma_mem),
 73 | 				    I40E_NONDMA_TO_NONDMA);
 74 | 		} else {
 75 | 			i40e_memcpy(&sd_entry->u.bp.addr,
 76 | 				    &mem, sizeof(struct i40e_dma_mem),
 77 | 				    I40E_NONDMA_TO_NONDMA);
 78 | 			sd_entry->u.bp.sd_pd_index = sd_index;
 79 | 		}
 80 | 		/* initialize the sd entry */
 81 | 		hmc_info->sd_table.sd_entry[sd_index].entry_type = type;
 82 | 
 83 | 		/* increment the ref count */
 84 | 		I40E_INC_SD_REFCNT(&hmc_info->sd_table);
 85 | 	}
 86 | 	/* Increment backing page reference count */
 87 | 	if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
 88 | 		I40E_INC_BP_REFCNT(&sd_entry->u.bp);
 89 | exit:
 90 | 	if (I40E_SUCCESS != ret_code)
 91 | 		if (dma_mem_alloc_done)
 92 | 			i40e_free_dma_mem(hw, &mem);
 93 | 
 94 | 	return ret_code;
 95 | }
 96 | 
 97 | /**
 98 |  * i40e_add_pd_table_entry - Adds page descriptor to the specified table
 99 |  * @hw: pointer to our HW structure
100 |  * @hmc_info: pointer to the HMC configuration information structure
101 |  * @pd_index: which page descriptor index to manipulate
102 |  * @rsrc_pg: if not NULL, use preallocated page instead of allocating new one.
103 |  *
104 |  * This function:
105 |  *	1. Initializes the pd entry
106 |  *	2. Adds pd_entry in the pd_table
107 |  *	3. Mark the entry valid in i40e_hmc_pd_entry structure
108 |  *	4. Initializes the pd_entry's ref count to 1
109 |  * assumptions:
110 |  *	1. The memory for pd should be pinned down, physically contiguous and
111 |  *	   aligned on 4K boundary and zeroed memory.
112 |  *	2. It should be 4K in size.
113 |  **/
114 | i40e_status i40e_add_pd_table_entry(struct i40e_hw *hw,
115 | 					      struct i40e_hmc_info *hmc_info,
116 | 					      u32 pd_index,
117 | 					      struct i40e_dma_mem *rsrc_pg)
118 | {
119 | 	i40e_status ret_code = I40E_SUCCESS;
120 | 	struct i40e_hmc_pd_table *pd_table;
121 | 	struct i40e_hmc_pd_entry *pd_entry;
122 | 	struct i40e_dma_mem mem;
123 | 	struct i40e_dma_mem *page = &mem;
124 | 	u32 sd_idx, rel_pd_idx;
125 | 	u64 *pd_addr;
126 | 	u64 page_desc;
127 | 
128 | 	if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
129 | 		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
130 | 		hw_dbg(hw, "i40e_add_pd_table_entry: bad pd_index\n");
131 | 		goto exit;
132 | 	}
133 | 
134 | 	/* find corresponding sd */
135 | 	sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
136 | 	if (I40E_SD_TYPE_PAGED !=
137 | 	    hmc_info->sd_table.sd_entry[sd_idx].entry_type)
138 | 		goto exit;
139 | 
140 | 	rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
141 | 	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
142 | 	pd_entry = &pd_table->pd_entry[rel_pd_idx];
143 | 	if (!pd_entry->valid) {
144 | 		if (rsrc_pg) {
145 | 			pd_entry->rsrc_pg = true;
146 | 			page = rsrc_pg;
147 | 		} else {
148 | 			/* allocate a 4K backing page */
149 | 			ret_code = i40e_allocate_dma_mem(hw, page, i40e_mem_bp,
150 | 						I40E_HMC_PAGED_BP_SIZE,
151 | 						I40E_HMC_PD_BP_BUF_ALIGNMENT);
152 | 			if (ret_code)
153 | 				goto exit;
154 | 			pd_entry->rsrc_pg = false;
155 | 		}
156 | 
157 | 		i40e_memcpy(&pd_entry->bp.addr, page,
158 | 			    sizeof(struct i40e_dma_mem), I40E_NONDMA_TO_NONDMA);
159 | 		pd_entry->bp.sd_pd_index = pd_index;
160 | 		pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
161 | 		/* Set page address and valid bit */
162 | 		page_desc = page->pa | 0x1;
163 | 
164 | 		pd_addr = (u64 *)pd_table->pd_page_addr.va;
165 | 		pd_addr += rel_pd_idx;
166 | 
167 | 		/* Add the backing page physical address in the pd entry */
168 | 		i40e_memcpy(pd_addr, &page_desc, sizeof(u64),
169 | 			    I40E_NONDMA_TO_DMA);
170 | 
171 | 		pd_entry->sd_index = sd_idx;
172 | 		pd_entry->valid = true;
173 | 		I40E_INC_PD_REFCNT(pd_table);
174 | 	}
175 | 	I40E_INC_BP_REFCNT(&pd_entry->bp);
176 | exit:
177 | 	return ret_code;
178 | }
179 | 
180 | /**
181 |  * i40e_remove_pd_bp - remove a backing page from a page descriptor
182 |  * @hw: pointer to our HW structure
183 |  * @hmc_info: pointer to the HMC configuration information structure
184 |  * @idx: the page index
185 |  *
186 |  * This function:
187 |  *	1. Marks the entry in pd tabe (for paged address mode) or in sd table
188 |  *	   (for direct address mode) invalid.
189 |  *	2. Write to register PMPDINV to invalidate the backing page in FV cache
190 |  *	3. Decrement the ref count for the pd _entry
191 |  * assumptions:
192 |  *	1. Caller can deallocate the memory used by backing storage after this
193 |  *	   function returns.
194 |  **/
195 | i40e_status i40e_remove_pd_bp(struct i40e_hw *hw,
196 | 					struct i40e_hmc_info *hmc_info,
197 | 					u32 idx)
198 | {
199 | 	i40e_status ret_code = I40E_SUCCESS;
200 | 	struct i40e_hmc_pd_entry *pd_entry;
201 | 	struct i40e_hmc_pd_table *pd_table;
202 | 	struct i40e_hmc_sd_entry *sd_entry;
203 | 	u32 sd_idx, rel_pd_idx;
204 | 	u64 *pd_addr;
205 | 
206 | 	/* calculate index */
207 | 	sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
208 | 	rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
209 | 	if (sd_idx >= hmc_info->sd_table.sd_cnt) {
210 | 		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
211 | 		hw_dbg(hw, "i40e_remove_pd_bp: bad idx\n");
212 | 		goto exit;
213 | 	}
214 | 	sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
215 | 	if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
216 | 		ret_code = I40E_ERR_INVALID_SD_TYPE;
217 | 		hw_dbg(hw, "i40e_remove_pd_bp: wrong sd_entry type\n");
218 | 		goto exit;
219 | 	}
220 | 	/* get the entry and decrease its ref counter */
221 | 	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
222 | 	pd_entry = &pd_table->pd_entry[rel_pd_idx];
223 | 	I40E_DEC_BP_REFCNT(&pd_entry->bp);
224 | 	if (pd_entry->bp.ref_cnt)
225 | 		goto exit;
226 | 
227 | 	/* mark the entry invalid */
228 | 	pd_entry->valid = false;
229 | 	I40E_DEC_PD_REFCNT(pd_table);
230 | 	pd_addr = (u64 *)pd_table->pd_page_addr.va;
231 | 	pd_addr += rel_pd_idx;
232 | 	i40e_memset(pd_addr, 0, sizeof(u64), I40E_DMA_MEM);
233 | 	I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
234 | 
235 | 	/* free memory here */
236 | 	if (!pd_entry->rsrc_pg)
237 | 		ret_code = i40e_free_dma_mem(hw, &(pd_entry->bp.addr));
238 | 	if (I40E_SUCCESS != ret_code)
239 | 		goto exit;
240 | 	if (!pd_table->ref_cnt)
241 | 		i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
242 | exit:
243 | 	return ret_code;
244 | }
245 | 
246 | /**
247 |  * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
248 |  * @hmc_info: pointer to the HMC configuration information structure
249 |  * @idx: the page index
250 |  **/
251 | i40e_status i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
252 | 					     u32 idx)
253 | {
254 | 	i40e_status ret_code = I40E_SUCCESS;
255 | 	struct i40e_hmc_sd_entry *sd_entry;
256 | 
257 | 	/* get the entry and decrease its ref counter */
258 | 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
259 | 	I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
260 | 	if (sd_entry->u.bp.ref_cnt) {
261 | 		ret_code = I40E_ERR_NOT_READY;
262 | 		goto exit;
263 | 	}
264 | 	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
265 | 
266 | 	/* mark the entry invalid */
267 | 	sd_entry->valid = false;
268 | exit:
269 | 	return ret_code;
270 | }
271 | 
272 | /**
273 |  * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
274 |  * @hw: pointer to our hw struct
275 |  * @hmc_info: pointer to the HMC configuration information structure
276 |  * @idx: the page index
277 |  * @is_pf: used to distinguish between VF and PF
278 |  **/
279 | i40e_status i40e_remove_sd_bp_new(struct i40e_hw *hw,
280 | 					    struct i40e_hmc_info *hmc_info,
281 | 					    u32 idx, bool is_pf)
282 | {
283 | 	struct i40e_hmc_sd_entry *sd_entry;
284 | 
285 | 	if (!is_pf)
286 | 		return I40E_NOT_SUPPORTED;
287 | 
288 | 	/* get the entry and decrease its ref counter */
289 | 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
290 | 	I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
291 | 
292 | 	return i40e_free_dma_mem(hw, &(sd_entry->u.bp.addr));
293 | }
294 | 
295 | /**
296 |  * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
297 |  * @hmc_info: pointer to the HMC configuration information structure
298 |  * @idx: segment descriptor index to find the relevant page descriptor
299 |  **/
300 | i40e_status i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
301 | 					       u32 idx)
302 | {
303 | 	i40e_status ret_code = I40E_SUCCESS;
304 | 	struct i40e_hmc_sd_entry *sd_entry;
305 | 
306 | 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
307 | 
308 | 	if (sd_entry->u.pd_table.ref_cnt) {
309 | 		ret_code = I40E_ERR_NOT_READY;
310 | 		goto exit;
311 | 	}
312 | 
313 | 	/* mark the entry invalid */
314 | 	sd_entry->valid = false;
315 | 
316 | 	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
317 | exit:
318 | 	return ret_code;
319 | }
320 | 
321 | /**
322 |  * i40e_remove_pd_page_new - Removes a PD page from sd entry.
323 |  * @hw: pointer to our hw struct
324 |  * @hmc_info: pointer to the HMC configuration information structure
325 |  * @idx: segment descriptor index to find the relevant page descriptor
326 |  * @is_pf: used to distinguish between VF and PF
327 |  **/
328 | i40e_status i40e_remove_pd_page_new(struct i40e_hw *hw,
329 | 					      struct i40e_hmc_info *hmc_info,
330 | 					      u32 idx, bool is_pf)
331 | {
332 | 	struct i40e_hmc_sd_entry *sd_entry;
333 | 
334 | 	if (!is_pf)
335 | 		return I40E_NOT_SUPPORTED;
336 | 
337 | 	sd_entry = &hmc_info->sd_table.sd_entry[idx];
338 | 	I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
339 | 
340 | 	return i40e_free_dma_mem(hw, &(sd_entry->u.pd_table.pd_page_addr));
341 | }
342 | 


--------------------------------------------------------------------------------
/src/i40e_hmc.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_HMC_H_
  5 | #define _I40E_HMC_H_
  6 | 
  7 | #define I40E_HMC_MAX_BP_COUNT 512
  8 | 
  9 | /* forward-declare the HW struct for the compiler */
 10 | struct i40e_hw;
 11 | 
 12 | #define I40E_HMC_INFO_SIGNATURE		0x484D5347 /* HMSG */
 13 | #define I40E_HMC_PD_CNT_IN_SD		512
 14 | #define I40E_HMC_DIRECT_BP_SIZE		0x200000 /* 2M */
 15 | #define I40E_HMC_PAGED_BP_SIZE		4096
 16 | #define I40E_HMC_PD_BP_BUF_ALIGNMENT	4096
 17 | #define I40E_FIRST_VF_FPM_ID		16
 18 | 
 19 | struct i40e_hmc_obj_info {
 20 | 	u64 base;	/* base addr in FPM */
 21 | 	u32 max_cnt;	/* max count available for this hmc func */
 22 | 	u32 cnt;	/* count of objects driver actually wants to create */
 23 | 	u64 size;	/* size in bytes of one object */
 24 | };
 25 | 
 26 | enum i40e_sd_entry_type {
 27 | 	I40E_SD_TYPE_INVALID = 0,
 28 | 	I40E_SD_TYPE_PAGED   = 1,
 29 | 	I40E_SD_TYPE_DIRECT  = 2
 30 | };
 31 | 
 32 | struct i40e_hmc_bp {
 33 | 	enum i40e_sd_entry_type entry_type;
 34 | 	struct i40e_dma_mem addr; /* populate to be used by hw */
 35 | 	u32 sd_pd_index;
 36 | 	u32 ref_cnt;
 37 | };
 38 | 
 39 | struct i40e_hmc_pd_entry {
 40 | 	struct i40e_hmc_bp bp;
 41 | 	u32 sd_index;
 42 | 	bool rsrc_pg;
 43 | 	bool valid;
 44 | };
 45 | 
 46 | struct i40e_hmc_pd_table {
 47 | 	struct i40e_dma_mem pd_page_addr; /* populate to be used by hw */
 48 | 	struct i40e_hmc_pd_entry  *pd_entry; /* [512] for sw book keeping */
 49 | 	struct i40e_virt_mem pd_entry_virt_mem; /* virt mem for pd_entry */
 50 | 
 51 | 	u32 ref_cnt;
 52 | 	u32 sd_index;
 53 | };
 54 | 
 55 | struct i40e_hmc_sd_entry {
 56 | 	enum i40e_sd_entry_type entry_type;
 57 | 	bool valid;
 58 | 
 59 | 	union {
 60 | 		struct i40e_hmc_pd_table pd_table;
 61 | 		struct i40e_hmc_bp bp;
 62 | 	} u;
 63 | };
 64 | 
 65 | struct i40e_hmc_sd_table {
 66 | 	struct i40e_virt_mem addr; /* used to track sd_entry allocations */
 67 | 	u32 sd_cnt;
 68 | 	u32 ref_cnt;
 69 | 	struct i40e_hmc_sd_entry *sd_entry; /* (sd_cnt*512) entries max */
 70 | };
 71 | 
 72 | struct i40e_hmc_info {
 73 | 	u32 signature;
 74 | 	/* equals to pci func num for PF and dynamically allocated for VFs */
 75 | 	u8 hmc_fn_id;
 76 | 	u16 first_sd_index; /* index of the first available SD */
 77 | 
 78 | 	/* hmc objects */
 79 | 	struct i40e_hmc_obj_info *hmc_obj;
 80 | 	struct i40e_virt_mem hmc_obj_virt_mem;
 81 | 	struct i40e_hmc_sd_table sd_table;
 82 | };
 83 | 
 84 | #define I40E_INC_SD_REFCNT(sd_table)	((sd_table)->ref_cnt++)
 85 | #define I40E_INC_PD_REFCNT(pd_table)	((pd_table)->ref_cnt++)
 86 | #define I40E_INC_BP_REFCNT(bp)		((bp)->ref_cnt++)
 87 | 
 88 | #define I40E_DEC_SD_REFCNT(sd_table)	((sd_table)->ref_cnt--)
 89 | #define I40E_DEC_PD_REFCNT(pd_table)	((pd_table)->ref_cnt--)
 90 | #define I40E_DEC_BP_REFCNT(bp)		((bp)->ref_cnt--)
 91 | 
 92 | /**
 93 |  * I40E_SET_PF_SD_ENTRY - marks the sd entry as valid in the hardware
 94 |  * @hw: pointer to our hw struct
 95 |  * @pa: pointer to physical address
 96 |  * @sd_index: segment descriptor index
 97 |  * @type: if sd entry is direct or paged
 98 |  **/
 99 | #define I40E_SET_PF_SD_ENTRY(hw, pa, sd_index, type)			\
100 | {									\
101 | 	u32 val1, val2, val3;						\
102 | 	val1 = (u32)(upper_32_bits(pa));				\
103 | 	val2 = (u32)(pa) | (I40E_HMC_MAX_BP_COUNT <<			\
104 | 		 I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_SHIFT) |		\
105 | 		((((type) == I40E_SD_TYPE_PAGED) ? 0 : 1) <<		\
106 | 		I40E_PFHMC_SDDATALOW_PMSDTYPE_SHIFT) |			\
107 | 		BIT(I40E_PFHMC_SDDATALOW_PMSDVALID_SHIFT);		\
108 | 	val3 = (sd_index) | BIT_ULL(I40E_PFHMC_SDCMD_PMSDWR_SHIFT);	\
109 | 	wr32((hw), I40E_PFHMC_SDDATAHIGH, val1);			\
110 | 	wr32((hw), I40E_PFHMC_SDDATALOW, val2);				\
111 | 	wr32((hw), I40E_PFHMC_SDCMD, val3);				\
112 | }
113 | 
114 | /**
115 |  * I40E_CLEAR_PF_SD_ENTRY - marks the sd entry as invalid in the hardware
116 |  * @hw: pointer to our hw struct
117 |  * @sd_index: segment descriptor index
118 |  * @type: if sd entry is direct or paged
119 |  **/
120 | #define I40E_CLEAR_PF_SD_ENTRY(hw, sd_index, type)			\
121 | {									\
122 | 	u32 val2, val3;							\
123 | 	val2 = (I40E_HMC_MAX_BP_COUNT <<				\
124 | 		I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_SHIFT) |		\
125 | 		((((type) == I40E_SD_TYPE_PAGED) ? 0 : 1) <<		\
126 | 		I40E_PFHMC_SDDATALOW_PMSDTYPE_SHIFT);			\
127 | 	val3 = (sd_index) | BIT_ULL(I40E_PFHMC_SDCMD_PMSDWR_SHIFT);	\
128 | 	wr32((hw), I40E_PFHMC_SDDATAHIGH, 0);				\
129 | 	wr32((hw), I40E_PFHMC_SDDATALOW, val2);				\
130 | 	wr32((hw), I40E_PFHMC_SDCMD, val3);				\
131 | }
132 | 
133 | /**
134 |  * I40E_INVALIDATE_PF_HMC_PD - Invalidates the pd cache in the hardware
135 |  * @hw: pointer to our hw struct
136 |  * @sd_idx: segment descriptor index
137 |  * @pd_idx: page descriptor index
138 |  **/
139 | #define I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, pd_idx)			\
140 | 	wr32((hw), I40E_PFHMC_PDINV,					\
141 | 	    (((sd_idx) << I40E_PFHMC_PDINV_PMSDIDX_SHIFT) |		\
142 | 	     ((pd_idx) << I40E_PFHMC_PDINV_PMPDIDX_SHIFT)))
143 | 
144 | /**
145 |  * I40E_FIND_SD_INDEX_LIMIT - finds segment descriptor index limit
146 |  * @hmc_info: pointer to the HMC configuration information structure
147 |  * @type: type of HMC resources we're searching
148 |  * @index: starting index for the object
149 |  * @cnt: number of objects we're trying to create
150 |  * @sd_idx: pointer to return index of the segment descriptor in question
151 |  * @sd_limit: pointer to return the maximum number of segment descriptors
152 |  *
153 |  * This function calculates the segment descriptor index and index limit
154 |  * for the resource defined by i40e_hmc_rsrc_type.
155 |  **/
156 | #define I40E_FIND_SD_INDEX_LIMIT(hmc_info, type, index, cnt, sd_idx, sd_limit)\
157 | {									\
158 | 	u64 fpm_addr, fpm_limit;					\
159 | 	fpm_addr = (hmc_info)->hmc_obj[(type)].base +			\
160 | 		   (hmc_info)->hmc_obj[(type)].size * (index);		\
161 | 	fpm_limit = fpm_addr + (hmc_info)->hmc_obj[(type)].size * (cnt);\
162 | 	*(sd_idx) = (u32)(fpm_addr / I40E_HMC_DIRECT_BP_SIZE);		\
163 | 	*(sd_limit) = (u32)((fpm_limit - 1) / I40E_HMC_DIRECT_BP_SIZE);	\
164 | 	/* add one more to the limit to correct our range */		\
165 | 	*(sd_limit) += 1;						\
166 | }
167 | 
168 | /**
169 |  * I40E_FIND_PD_INDEX_LIMIT - finds page descriptor index limit
170 |  * @hmc_info: pointer to the HMC configuration information struct
171 |  * @type: HMC resource type we're examining
172 |  * @idx: starting index for the object
173 |  * @cnt: number of objects we're trying to create
174 |  * @pd_index: pointer to return page descriptor index
175 |  * @pd_limit: pointer to return page descriptor index limit
176 |  *
177 |  * Calculates the page descriptor index and index limit for the resource
178 |  * defined by i40e_hmc_rsrc_type.
179 |  **/
180 | #define I40E_FIND_PD_INDEX_LIMIT(hmc_info, type, idx, cnt, pd_index, pd_limit)\
181 | {									\
182 | 	u64 fpm_adr, fpm_limit;						\
183 | 	fpm_adr = (hmc_info)->hmc_obj[(type)].base +			\
184 | 		  (hmc_info)->hmc_obj[(type)].size * (idx);		\
185 | 	fpm_limit = fpm_adr + (hmc_info)->hmc_obj[(type)].size * (cnt);	\
186 | 	*(pd_index) = (u32)(fpm_adr / I40E_HMC_PAGED_BP_SIZE);		\
187 | 	*(pd_limit) = (u32)((fpm_limit - 1) / I40E_HMC_PAGED_BP_SIZE);	\
188 | 	/* add one more to the limit to correct our range */		\
189 | 	*(pd_limit) += 1;						\
190 | }
191 | i40e_status i40e_add_sd_table_entry(struct i40e_hw *hw,
192 | 					      struct i40e_hmc_info *hmc_info,
193 | 					      u32 sd_index,
194 | 					      enum i40e_sd_entry_type type,
195 | 					      u64 direct_mode_sz);
196 | 
197 | i40e_status i40e_add_pd_table_entry(struct i40e_hw *hw,
198 | 					      struct i40e_hmc_info *hmc_info,
199 | 					      u32 pd_index,
200 | 					      struct i40e_dma_mem *rsrc_pg);
201 | i40e_status i40e_remove_pd_bp(struct i40e_hw *hw,
202 | 					struct i40e_hmc_info *hmc_info,
203 | 					u32 idx);
204 | i40e_status i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
205 | 					     u32 idx);
206 | i40e_status i40e_remove_sd_bp_new(struct i40e_hw *hw,
207 | 					    struct i40e_hmc_info *hmc_info,
208 | 					    u32 idx, bool is_pf);
209 | i40e_status i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
210 | 					       u32 idx);
211 | i40e_status i40e_remove_pd_page_new(struct i40e_hw *hw,
212 | 					      struct i40e_hmc_info *hmc_info,
213 | 					      u32 idx, bool is_pf);
214 | 
215 | #endif /* _I40E_HMC_H_ */
216 | 


--------------------------------------------------------------------------------
/src/i40e_lan_hmc.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_LAN_HMC_H_
  5 | #define _I40E_LAN_HMC_H_
  6 | 
  7 | /* forward-declare the HW struct for the compiler */
  8 | struct i40e_hw;
  9 | 
 10 | /* HMC element context information */
 11 | 
 12 | /* Rx queue context data
 13 |  *
 14 |  * The sizes of the variables may be larger than needed due to crossing byte
 15 |  * boundaries. If we do not have the width of the variable set to the correct
 16 |  * size then we could end up shifting bits off the top of the variable when the
 17 |  * variable is at the top of a byte and crosses over into the next byte.
 18 |  */
 19 | struct i40e_hmc_obj_rxq {
 20 | 	u16 head;
 21 | 	u16 cpuid; /* bigger than needed, see above for reason */
 22 | 	u64 base;
 23 | 	u16 qlen;
 24 | #define I40E_RXQ_CTX_DBUFF_SHIFT 7
 25 | 	u16 dbuff; /* bigger than needed, see above for reason */
 26 | #define I40E_RXQ_CTX_HBUFF_SHIFT 6
 27 | 	u16 hbuff; /* bigger than needed, see above for reason */
 28 | 	u8  dtype;
 29 | 	u8  dsize;
 30 | 	u8  crcstrip;
 31 | 	u8  fc_ena;
 32 | 	u8  l2tsel;
 33 | 	u8  hsplit_0;
 34 | 	u8  hsplit_1;
 35 | 	u8  showiv;
 36 | 	u32 rxmax; /* bigger than needed, see above for reason */
 37 | 	u8  tphrdesc_ena;
 38 | 	u8  tphwdesc_ena;
 39 | 	u8  tphdata_ena;
 40 | 	u8  tphhead_ena;
 41 | 	u16 lrxqthresh; /* bigger than needed, see above for reason */
 42 | 	u8  prefena;	/* NOTE: normally must be set to 1 at init */
 43 | };
 44 | 
 45 | /* Tx queue context data
 46 | *
 47 | * The sizes of the variables may be larger than needed due to crossing byte
 48 | * boundaries. If we do not have the width of the variable set to the correct
 49 | * size then we could end up shifting bits off the top of the variable when the
 50 | * variable is at the top of a byte and crosses over into the next byte.
 51 | */
 52 | struct i40e_hmc_obj_txq {
 53 | 	u16 head;
 54 | 	u8  new_context;
 55 | 	u64 base;
 56 | 	u8  fc_ena;
 57 | 	u8  timesync_ena;
 58 | 	u8  fd_ena;
 59 | 	u8  alt_vlan_ena;
 60 | 	u16 thead_wb;
 61 | 	u8  cpuid;
 62 | 	u8  head_wb_ena;
 63 | 	u16 qlen;
 64 | 	u8  tphrdesc_ena;
 65 | 	u8  tphrpacket_ena;
 66 | 	u8  tphwdesc_ena;
 67 | 	u64 head_wb_addr;
 68 | 	u32 crc;
 69 | 	u16 rdylist;
 70 | 	u8  rdylist_act;
 71 | };
 72 | 
 73 | /* for hsplit_0 field of Rx HMC context */
 74 | enum i40e_hmc_obj_rx_hsplit_0 {
 75 | 	I40E_HMC_OBJ_RX_HSPLIT_0_NO_SPLIT      = 0,
 76 | 	I40E_HMC_OBJ_RX_HSPLIT_0_SPLIT_L2      = 1,
 77 | 	I40E_HMC_OBJ_RX_HSPLIT_0_SPLIT_IP      = 2,
 78 | 	I40E_HMC_OBJ_RX_HSPLIT_0_SPLIT_TCP_UDP = 4,
 79 | 	I40E_HMC_OBJ_RX_HSPLIT_0_SPLIT_SCTP    = 8,
 80 | };
 81 | 
 82 | /* fcoe_cntx and fcoe_filt are for debugging purpose only */
 83 | struct i40e_hmc_obj_fcoe_cntx {
 84 | 	u32 rsv[32];
 85 | };
 86 | 
 87 | struct i40e_hmc_obj_fcoe_filt {
 88 | 	u32 rsv[8];
 89 | };
 90 | 
 91 | /* Context sizes for LAN objects */
 92 | enum i40e_hmc_lan_object_size {
 93 | 	I40E_HMC_LAN_OBJ_SZ_8   = 0x3,
 94 | 	I40E_HMC_LAN_OBJ_SZ_16  = 0x4,
 95 | 	I40E_HMC_LAN_OBJ_SZ_32  = 0x5,
 96 | 	I40E_HMC_LAN_OBJ_SZ_64  = 0x6,
 97 | 	I40E_HMC_LAN_OBJ_SZ_128 = 0x7,
 98 | 	I40E_HMC_LAN_OBJ_SZ_256 = 0x8,
 99 | 	I40E_HMC_LAN_OBJ_SZ_512 = 0x9,
100 | };
101 | 
102 | #define I40E_HMC_L2OBJ_BASE_ALIGNMENT 512
103 | #define I40E_HMC_OBJ_SIZE_TXQ         128
104 | #define I40E_HMC_OBJ_SIZE_RXQ         32
105 | #define I40E_HMC_OBJ_SIZE_FCOE_CNTX   64
106 | #define I40E_HMC_OBJ_SIZE_FCOE_FILT   64
107 | 
108 | enum i40e_hmc_lan_rsrc_type {
109 | 	I40E_HMC_LAN_FULL  = 0,
110 | 	I40E_HMC_LAN_TX    = 1,
111 | 	I40E_HMC_LAN_RX    = 2,
112 | 	I40E_HMC_FCOE_CTX  = 3,
113 | 	I40E_HMC_FCOE_FILT = 4,
114 | 	I40E_HMC_LAN_MAX   = 5
115 | };
116 | 
117 | enum i40e_hmc_model {
118 | 	I40E_HMC_MODEL_DIRECT_PREFERRED = 0,
119 | 	I40E_HMC_MODEL_DIRECT_ONLY      = 1,
120 | 	I40E_HMC_MODEL_PAGED_ONLY       = 2,
121 | 	I40E_HMC_MODEL_UNKNOWN,
122 | };
123 | 
124 | struct i40e_hmc_lan_create_obj_info {
125 | 	struct i40e_hmc_info *hmc_info;
126 | 	u32 rsrc_type;
127 | 	u32 start_idx;
128 | 	u32 count;
129 | 	enum i40e_sd_entry_type entry_type;
130 | 	u64 direct_mode_sz;
131 | };
132 | 
133 | struct i40e_hmc_lan_delete_obj_info {
134 | 	struct i40e_hmc_info *hmc_info;
135 | 	u32 rsrc_type;
136 | 	u32 start_idx;
137 | 	u32 count;
138 | };
139 | 
140 | i40e_status i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
141 | 					u32 rxq_num, u32 fcoe_cntx_num,
142 | 					u32 fcoe_filt_num);
143 | i40e_status i40e_configure_lan_hmc(struct i40e_hw *hw,
144 | 					     enum i40e_hmc_model model);
145 | i40e_status i40e_shutdown_lan_hmc(struct i40e_hw *hw);
146 | 
147 | i40e_status i40e_clear_lan_tx_queue_context(struct i40e_hw *hw,
148 | 						      u16 queue);
149 | i40e_status i40e_set_lan_tx_queue_context(struct i40e_hw *hw,
150 | 						    u16 queue,
151 | 						    struct i40e_hmc_obj_txq *s);
152 | i40e_status i40e_clear_lan_rx_queue_context(struct i40e_hw *hw,
153 | 						      u16 queue);
154 | i40e_status i40e_set_lan_rx_queue_context(struct i40e_hw *hw,
155 | 						    u16 queue,
156 | 						    struct i40e_hmc_obj_rxq *s);
157 | 
158 | #endif /* _I40E_LAN_HMC_H_ */
159 | 


--------------------------------------------------------------------------------
/src/i40e_osdep.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_OSDEP_H_
  5 | #define _I40E_OSDEP_H_
  6 | 
  7 | #include <linux/types.h>
  8 | #include <linux/if_ether.h>
  9 | #include <linux/if_vlan.h>
 10 | #include <linux/tcp.h>
 11 | #include <linux/pci.h>
 12 | #include <linux/highuid.h>
 13 | 
 14 | #include <linux/io.h>
 15 | #include <asm-generic/int-ll64.h>
 16 | 
 17 | #ifndef readq
 18 | static inline __u64 readq(const volatile void __iomem *addr)
 19 | {
 20 | 	const volatile u32 __iomem *p = addr;
 21 | 	u32 low, high;
 22 | 
 23 | 	low = readl(p);
 24 | 	high = readl(p + 1);
 25 | 
 26 | 	return low + ((u64)high << 32);
 27 | }
 28 | #endif
 29 | 
 30 | #ifndef writeq
 31 | static inline void writeq(__u64 val, volatile void __iomem *addr)
 32 | {
 33 | 	writel(val, addr);
 34 | 	writel(val >> 32, addr + 4);
 35 | }
 36 | #endif
 37 | #include "kcompat.h"
 38 | 
 39 | /* File to be the magic between shared code and
 40 |  * actual OS primitives
 41 |  */
 42 | 
 43 | #define hw_dbg(h, s, ...) do {					\
 44 | 		pr_debug("i40e %02x:%02x.%x " s,		\
 45 | 			(h)->bus.bus_id, (h)->bus.device,	\
 46 | 			(h)->bus.func, ##__VA_ARGS__);		\
 47 | } while (0)
 48 | 
 49 | 
 50 | #define wr32(a, reg, value)	writel((value), ((a)->hw_addr + (reg)))
 51 | #define rd32(a, reg)		readl((a)->hw_addr + (reg))
 52 | 
 53 | #define wr64(a, reg, value)	writeq((value), ((a)->hw_addr + (reg)))
 54 | #define rd64(a, reg)		readq((a)->hw_addr + (reg))
 55 | #define i40e_flush(a)		readl((a)->hw_addr + I40E_GLGEN_STAT)
 56 | /* memory allocation tracking */
 57 | struct i40e_dma_mem {
 58 | 	void *va;
 59 | 	dma_addr_t pa;
 60 | 	u32 size;
 61 | };
 62 | 
 63 | #define i40e_allocate_dma_mem(h, m, unused, s, a) \
 64 | 			i40e_allocate_dma_mem_d(h, m, unused, s, a)
 65 | 
 66 | #define i40e_free_dma_mem(h, m) i40e_free_dma_mem_d(h, m)
 67 | 
 68 | struct i40e_virt_mem {
 69 | 	void *va;
 70 | 	u32 size;
 71 | };
 72 | 
 73 | #define i40e_allocate_virt_mem(h, m, s) i40e_allocate_virt_mem_d(h, m, s)
 74 | #define i40e_free_virt_mem(h, m) i40e_free_virt_mem_d(h, m)
 75 | 
 76 | #define i40e_debug(h, m, s, ...)				\
 77 | do {								\
 78 | 	if (((m) & (h)->debug_mask))				\
 79 | 		pr_info("i40e %02x:%02x.%x " s,			\
 80 | 			(h)->bus.bus_id, (h)->bus.device,	\
 81 | 			(h)->bus.func, ##__VA_ARGS__);		\
 82 | } while (0)
 83 | 
 84 | /* these things are all directly replaced with sed during the kernel build */
 85 | #define INLINE inline
 86 | 
 87 | 
 88 | #define CPU_TO_LE16(o) cpu_to_le16(o)
 89 | #define CPU_TO_LE32(s) cpu_to_le32(s)
 90 | #define CPU_TO_LE64(h) cpu_to_le64(h)
 91 | #define LE16_TO_CPU(a) le16_to_cpu(a)
 92 | #define LE32_TO_CPU(c) le32_to_cpu(c)
 93 | #define LE64_TO_CPU(k) le64_to_cpu(k)
 94 | 
 95 | /* SW spinlock */
 96 | struct i40e_spinlock {
 97 | 	struct mutex spinlock;
 98 | };
 99 | 
100 | static inline void i40e_no_action(struct i40e_spinlock *sp)
101 | {
102 | 	/* nothing */
103 | }
104 | 
105 | /* the locks are initialized in _probe and destroyed in _remove
106 |  * so make sure NOT to implement init/destroy here, as to
107 |  * avoid the i40e_init_adminq code trying to reinitialize
108 |  * the persistent lock memory
109 |  */
110 | #define i40e_init_spinlock(_sp)    i40e_no_action(_sp)
111 | #define i40e_acquire_spinlock(_sp) i40e_acquire_spinlock_d(_sp)
112 | #define i40e_release_spinlock(_sp) i40e_release_spinlock_d(_sp)
113 | #define i40e_destroy_spinlock(_sp) i40e_no_action(_sp)
114 | 
115 | 
116 | #define i40e_memset(a, b, c, d)  memset((a), (b), (c))
117 | #define i40e_memcpy(a, b, c, d)  memcpy((a), (b), (c))
118 | 
119 | typedef enum i40e_status_code i40e_status;
120 | #endif /* _I40E_OSDEP_H_ */
121 | 


--------------------------------------------------------------------------------
/src/i40e_status.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _I40E_STATUS_H_
 5 | #define _I40E_STATUS_H_
 6 | 
 7 | /* Error Codes */
 8 | enum i40e_status_code {
 9 | 	I40E_SUCCESS				= 0,
10 | 	I40E_ERR_NVM				= -1,
11 | 	I40E_ERR_NVM_CHECKSUM			= -2,
12 | 	I40E_ERR_PHY				= -3,
13 | 	I40E_ERR_CONFIG				= -4,
14 | 	I40E_ERR_PARAM				= -5,
15 | 	I40E_ERR_MAC_TYPE			= -6,
16 | 	I40E_ERR_UNKNOWN_PHY			= -7,
17 | 	I40E_ERR_LINK_SETUP			= -8,
18 | 	I40E_ERR_ADAPTER_STOPPED		= -9,
19 | 	I40E_ERR_INVALID_MAC_ADDR		= -10,
20 | 	I40E_ERR_DEVICE_NOT_SUPPORTED		= -11,
21 | 	I40E_ERR_PRIMARY_REQUESTS_PENDING	= -12,
22 | 	I40E_ERR_INVALID_LINK_SETTINGS		= -13,
23 | 	I40E_ERR_AUTONEG_NOT_COMPLETE		= -14,
24 | 	I40E_ERR_RESET_FAILED			= -15,
25 | 	I40E_ERR_SWFW_SYNC			= -16,
26 | 	I40E_ERR_NO_AVAILABLE_VSI		= -17,
27 | 	I40E_ERR_NO_MEMORY			= -18,
28 | 	I40E_ERR_BAD_PTR			= -19,
29 | 	I40E_ERR_RING_FULL			= -20,
30 | 	I40E_ERR_INVALID_PD_ID			= -21,
31 | 	I40E_ERR_INVALID_QP_ID			= -22,
32 | 	I40E_ERR_INVALID_CQ_ID			= -23,
33 | 	I40E_ERR_INVALID_CEQ_ID			= -24,
34 | 	I40E_ERR_INVALID_AEQ_ID			= -25,
35 | 	I40E_ERR_INVALID_SIZE			= -26,
36 | 	I40E_ERR_INVALID_ARP_INDEX		= -27,
37 | 	I40E_ERR_INVALID_FPM_FUNC_ID		= -28,
38 | 	I40E_ERR_QP_INVALID_MSG_SIZE		= -29,
39 | 	I40E_ERR_QP_TOOMANY_WRS_POSTED		= -30,
40 | 	I40E_ERR_INVALID_FRAG_COUNT		= -31,
41 | 	I40E_ERR_QUEUE_EMPTY			= -32,
42 | 	I40E_ERR_INVALID_ALIGNMENT		= -33,
43 | 	I40E_ERR_FLUSHED_QUEUE			= -34,
44 | 	I40E_ERR_INVALID_PUSH_PAGE_INDEX	= -35,
45 | 	I40E_ERR_INVALID_IMM_DATA_SIZE		= -36,
46 | 	I40E_ERR_TIMEOUT			= -37,
47 | 	I40E_ERR_OPCODE_MISMATCH		= -38,
48 | 	I40E_ERR_CQP_COMPL_ERROR		= -39,
49 | 	I40E_ERR_INVALID_VF_ID			= -40,
50 | 	I40E_ERR_INVALID_HMCFN_ID		= -41,
51 | 	I40E_ERR_BACKING_PAGE_ERROR		= -42,
52 | 	I40E_ERR_NO_PBLCHUNKS_AVAILABLE		= -43,
53 | 	I40E_ERR_INVALID_PBLE_INDEX		= -44,
54 | 	I40E_ERR_INVALID_SD_INDEX		= -45,
55 | 	I40E_ERR_INVALID_PAGE_DESC_INDEX	= -46,
56 | 	I40E_ERR_INVALID_SD_TYPE		= -47,
57 | 	I40E_ERR_MEMCPY_FAILED			= -48,
58 | 	I40E_ERR_INVALID_HMC_OBJ_INDEX		= -49,
59 | 	I40E_ERR_INVALID_HMC_OBJ_COUNT		= -50,
60 | 	I40E_ERR_INVALID_SRQ_ARM_LIMIT		= -51,
61 | 	I40E_ERR_SRQ_ENABLED			= -52,
62 | 	I40E_ERR_ADMIN_QUEUE_ERROR		= -53,
63 | 	I40E_ERR_ADMIN_QUEUE_TIMEOUT		= -54,
64 | 	I40E_ERR_BUF_TOO_SHORT			= -55,
65 | 	I40E_ERR_ADMIN_QUEUE_FULL		= -56,
66 | 	I40E_ERR_ADMIN_QUEUE_NO_WORK		= -57,
67 | 	I40E_ERR_BAD_IWARP_CQE			= -58,
68 | 	I40E_ERR_NVM_BLANK_MODE			= -59,
69 | 	I40E_ERR_NOT_IMPLEMENTED		= -60,
70 | 	I40E_ERR_PE_DOORBELL_NOT_ENABLED	= -61,
71 | 	I40E_ERR_DIAG_TEST_FAILED		= -62,
72 | 	I40E_ERR_NOT_READY			= -63,
73 | 	I40E_NOT_SUPPORTED			= -64,
74 | 	I40E_ERR_FIRMWARE_API_VERSION		= -65,
75 | 	I40E_ERR_ADMIN_QUEUE_CRITICAL_ERROR	= -66,
76 | };
77 | 
78 | #endif /* _I40E_STATUS_H_ */
79 | 


--------------------------------------------------------------------------------
/src/i40e_trace.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef CONFIG_TRACEPOINTS
  5 | #if !defined(_I40E_TRACE_H_)
  6 | #define _I40E_TRACE_H_
  7 | /* If the Linux kernel tracepoints are not available then the i40e_trace*
  8 |  * macros become nops.
  9 |  */
 10 | 
 11 | #define i40e_trace(trace_name, args...)
 12 | #define i40e_trace_enabled(trace_name) (0)
 13 | #endif /* !defined(_I40E_TRACE_H_) */
 14 | #else /* CONFIG_TRACEPOINTS */
 15 | /*
 16 |  * Modeled on trace-events-sample.h
 17 |  */
 18 | 
 19 | /*
 20 |  * The trace subsystem name for i40e will be "i40e".
 21 |  *
 22 |  * This file is named i40e_trace.h.
 23 |  *
 24 |  * Since this include file's name is different from the trace
 25 |  * subsystem name, we'll have to define TRACE_INCLUDE_FILE at the end
 26 |  * of this file.
 27 |  */
 28 | #undef TRACE_SYSTEM
 29 | #define TRACE_SYSTEM i40e
 30 | 
 31 | /*
 32 |  * See trace-events-sample.h for a detailed description of why this
 33 |  * guard clause is different from most normal include files.
 34 |  */
 35 | #if !defined(_I40E_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
 36 | #define _I40E_TRACE_H_
 37 | 
 38 | #include <linux/tracepoint.h>
 39 | 
 40 | /*
 41 |  * i40e_trace() macro enables shared code to refer to trace points
 42 |  * like:
 43 |  *
 44 |  * trace_i40e{,vf}_example(args...)
 45 |  *
 46 |  * ... as:
 47 |  *
 48 |  * i40e_trace(example, args...)
 49 |  *
 50 |  * ... to resolve to the PF or VF version of the tracepoint without
 51 |  * ifdefs, and to allow tracepoints to be disabled entirely at build
 52 |  * time.
 53 |  *
 54 |  * Trace point should always be referred to in the driver via this
 55 |  * macro.
 56 |  *
 57 |  * Similarly, i40e_trace_enabled(trace_name) wraps references to
 58 |  * trace_i40e{,vf}_<trace_name>_enabled() functions.
 59 |  */
 60 | #define _I40E_TRACE_NAME(trace_name) (trace_ ## i40e ## _ ## trace_name)
 61 | #define I40E_TRACE_NAME(trace_name) _I40E_TRACE_NAME(trace_name)
 62 | 
 63 | #define i40e_trace(trace_name, args...) I40E_TRACE_NAME(trace_name)(args)
 64 | 
 65 | #define i40e_trace_enabled(trace_name) I40E_TRACE_NAME(trace_name##_enabled)()
 66 | 
 67 | /*
 68 |  * Events common to PF and VF. Corresponding versions will be defined
 69 |  * for both, named trace_i40e_* and trace_i40evf_*. The i40e_trace()
 70 |  * macro above will select the right trace point name for the driver
 71 |  * being built from shared code.
 72 |  */
 73 | 
 74 | /* Events related to a vsi & ring */
 75 | DECLARE_EVENT_CLASS(
 76 | 	i40e_tx_template,
 77 | 
 78 | 	TP_PROTO(struct i40e_ring *ring,
 79 | 		 struct i40e_tx_desc *desc,
 80 | 		 struct i40e_tx_buffer *buf),
 81 | 
 82 | 	TP_ARGS(ring, desc, buf),
 83 | 
 84 | 	/*
 85 | 	 * The convention here is to make the first fields in the
 86 | 	 * TP_STRUCT match the TP_PROTO exactly. This enables the use
 87 | 	 * of the args struct generated by the tplist tool (from the
 88 | 	 * bcc-tools package) to be used for those fields. To access
 89 | 	 * fields other than the tracepoint args will require the
 90 | 	 * tplist output to be adjusted.
 91 | 	 */
 92 | 	TP_STRUCT__entry(
 93 | 		__field(void*, ring)
 94 | 		__field(void*, desc)
 95 | 		__field(void*, buf)
 96 | 		__string(devname, ring->netdev->name)
 97 | 	),
 98 | 
 99 | 	TP_fast_assign(
100 | 		__entry->ring = ring;
101 | 		__entry->desc = desc;
102 | 		__entry->buf = buf;
103 | 		__assign_str(devname, ring->netdev->name);
104 | 	),
105 | 
106 | 	TP_printk(
107 | 		"netdev: %s ring: %p desc: %p buf %p",
108 | 		__get_str(devname), __entry->ring,
109 | 		__entry->desc, __entry->buf)
110 | );
111 | 
112 | DEFINE_EVENT(
113 | 	i40e_tx_template, i40e_clean_tx_irq,
114 | 	TP_PROTO(struct i40e_ring *ring,
115 | 		 struct i40e_tx_desc *desc,
116 | 		 struct i40e_tx_buffer *buf),
117 | 
118 | 	TP_ARGS(ring, desc, buf));
119 | 
120 | DEFINE_EVENT(
121 | 	i40e_tx_template, i40e_clean_tx_irq_unmap,
122 | 	TP_PROTO(struct i40e_ring *ring,
123 | 		 struct i40e_tx_desc *desc,
124 | 		 struct i40e_tx_buffer *buf),
125 | 
126 | 	TP_ARGS(ring, desc, buf));
127 | 
128 | DECLARE_EVENT_CLASS(
129 | 	i40e_rx_template,
130 | 
131 | 	TP_PROTO(struct i40e_ring *ring,
132 | 		 union i40e_rx_desc *desc,
133 | 		 struct sk_buff *skb),
134 | 
135 | 	TP_ARGS(ring, desc, skb),
136 | 
137 | 	TP_STRUCT__entry(
138 | 		__field(void*, ring)
139 | 		__field(void*, desc)
140 | 		__field(void*, skb)
141 | 		__string(devname, ring->netdev->name)
142 | 	),
143 | 
144 | 	TP_fast_assign(
145 | 		__entry->ring = ring;
146 | 		__entry->desc = desc;
147 | 		__entry->skb = skb;
148 | 		__assign_str(devname, ring->netdev->name);
149 | 	),
150 | 
151 | 	TP_printk(
152 | 		"netdev: %s ring: %p desc: %p skb %p",
153 | 		__get_str(devname), __entry->ring,
154 | 		__entry->desc, __entry->skb)
155 | );
156 | 
157 | DEFINE_EVENT(
158 | 	i40e_rx_template, i40e_clean_rx_irq,
159 | 	TP_PROTO(struct i40e_ring *ring,
160 | 		 union i40e_rx_desc *desc,
161 | 		 struct sk_buff *skb),
162 | 
163 | 	TP_ARGS(ring, desc, skb));
164 | 
165 | DEFINE_EVENT(
166 | 	i40e_rx_template, i40e_clean_rx_irq_rx,
167 | 	TP_PROTO(struct i40e_ring *ring,
168 | 		 union i40e_rx_desc *desc,
169 | 		 struct sk_buff *skb),
170 | 
171 | 	TP_ARGS(ring, desc, skb));
172 | 
173 | DECLARE_EVENT_CLASS(
174 | 	i40e_xmit_template,
175 | 
176 | 	TP_PROTO(struct sk_buff *skb,
177 | 		 struct i40e_ring *ring),
178 | 
179 | 	TP_ARGS(skb, ring),
180 | 
181 | 	TP_STRUCT__entry(
182 | 		__field(void*, skb)
183 | 		__field(void*, ring)
184 | 		__string(devname, ring->netdev->name)
185 | 	),
186 | 
187 | 	TP_fast_assign(
188 | 		__entry->skb = skb;
189 | 		__entry->ring = ring;
190 | 		__assign_str(devname, ring->netdev->name);
191 | 	),
192 | 
193 | 	TP_printk(
194 | 		"netdev: %s skb: %p ring: %p",
195 | 		__get_str(devname), __entry->skb,
196 | 		__entry->ring)
197 | );
198 | 
199 | DEFINE_EVENT(
200 | 	i40e_xmit_template, i40e_xmit_frame_ring,
201 | 	TP_PROTO(struct sk_buff *skb,
202 | 		 struct i40e_ring *ring),
203 | 
204 | 	TP_ARGS(skb, ring));
205 | 
206 | DEFINE_EVENT(
207 | 	i40e_xmit_template, i40e_xmit_frame_ring_drop,
208 | 	TP_PROTO(struct sk_buff *skb,
209 | 		 struct i40e_ring *ring),
210 | 
211 | 	TP_ARGS(skb, ring));
212 | 
213 | /*
214 |  * Events unique to the PF.
215 |  */
216 | 
217 | #endif /* _I40E_TRACE_H_ */
218 | /* This must be outside ifdef _I40E_TRACE_H */
219 | 
220 | /* This trace include file is not located in the .../include/trace
221 |  * with the kernel tracepoint definitions, because we're a loadable
222 |  * module.
223 |  */
224 | #undef TRACE_INCLUDE_PATH
225 | #define TRACE_INCLUDE_PATH .
226 | #undef TRACE_INCLUDE_FILE
227 | #define TRACE_INCLUDE_FILE i40e_trace
228 | #include <trace/define_trace.h>
229 | #endif /* CONFIG_TRACEPOINTS */
230 | 


--------------------------------------------------------------------------------
/src/i40e_txrx_common.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_TXRX_COMMON_H_
  5 | #define _I40E_TXRX_COMMON_H_
  6 | 
  7 | #ifndef HAVE_MEM_TYPE_XSK_BUFF_POOL
  8 | void i40e_fd_handle_status(struct i40e_ring *rx_ring,
  9 | 			   union i40e_rx_desc *rx_desc, u8 prog_id);
 10 | #endif /* HAVE_MEM_TYPE_XSK_BUFF_POOL */
 11 | int i40e_xmit_xdp_tx_ring(struct xdp_buff *xdp, struct i40e_ring *xdp_ring);
 12 | #if (defined HAVE_AF_XDP_ZC_SUPPORT && defined HAVE_MEM_TYPE_XSK_BUFF_POOL)
 13 | void i40e_clean_programming_status(struct i40e_ring *rx_ring, u64 qword0_raw,
 14 | 				   u64 qword1);
 15 | #else
 16 | struct i40e_rx_buffer *i40e_clean_programming_status
 17 | 	(struct i40e_ring *rx_ring,
 18 | 	 union i40e_rx_desc *rx_desc,
 19 | 	 u64 qw);
 20 | #endif
 21 | void i40e_process_skb_fields(struct i40e_ring *rx_ring,
 22 | 			     union i40e_rx_desc *rx_desc,
 23 | 			     struct sk_buff *skb);
 24 | void i40e_receive_skb(struct i40e_ring *rx_ring,
 25 | 		      struct sk_buff *skb, u16 vlan_tag, u16 vlan_tpid);
 26 | 
 27 | void i40e_xdp_ring_update_tail(struct i40e_ring *xdp_ring);
 28 | void i40e_update_rx_stats(struct i40e_ring *rx_ring,
 29 | 			  unsigned int total_rx_bytes,
 30 | 			  unsigned int total_rx_packets);
 31 | void i40e_finalize_xdp_rx(struct i40e_ring *rx_ring, unsigned int xdp_res);
 32 | void i40e_release_rx_desc(struct i40e_ring *rx_ring, u32 val);
 33 | void i40e_xsk_clean_tx_ring(struct i40e_ring *tx_ring);
 34 | void i40e_xsk_clean_rx_ring(struct i40e_ring *rx_ring);
 35 | bool i40e_xsk_any_rx_ring_enabled(struct i40e_vsi *vsi);
 36 | 
 37 | #ifndef HAVE_MEM_TYPE_XSK_BUFF_POOL
 38 | /**
 39 |  * i40e_rx_is_programming_status - check for programming status descriptor
 40 |  * @qw: qword representing status_error_len in CPU ordering
 41 |  *
 42 |  * The value of in the descriptor length field indicate if this
 43 |  * is a programming status descriptor for flow director or FCoE
 44 |  * by the value of I40E_RX_PROG_STATUS_DESC_LENGTH, otherwise
 45 |  * it is a packet descriptor.
 46 |  **/
 47 | static inline bool i40e_rx_is_programming_status(u64 qw)
 48 | {
 49 | /* The Rx filter programming status and SPH bit occupy the same
 50 |  * spot in the descriptor. Since we don't support packet split we
 51 |  * can just reuse the bit as an indication that this is a
 52 |  * programming status descriptor.
 53 |  */
 54 | 	return qw & I40E_RXD_QW1_LENGTH_SPH_MASK;
 55 | }
 56 | #endif /* HAVE_MEM_TYPE_XSK_BUFF_POOL */
 57 | 
 58 | #define I40E_XDP_PASS          0
 59 | #define I40E_XDP_CONSUMED      BIT(0)
 60 | #define I40E_XDP_TX            BIT(1)
 61 | #define I40E_XDP_REDIR         BIT(2)
 62 | 
 63 | static inline __le64 build_ctob(u32 td_cmd, u32 td_offset, unsigned int size,
 64 | 		                                u32 td_tag)
 65 | {
 66 | 	return cpu_to_le64(I40E_TX_DESC_DTYPE_DATA |
 67 | 			   ((u64)td_cmd  << I40E_TXD_QW1_CMD_SHIFT) |
 68 | 			   ((u64)td_offset << I40E_TXD_QW1_OFFSET_SHIFT) |
 69 | 			   ((u64)size  << I40E_TXD_QW1_TX_BUF_SZ_SHIFT) |
 70 | 			   ((u64)td_tag  << I40E_TXD_QW1_L2TAG1_SHIFT));
 71 | }
 72 | 
 73 | #ifdef HAVE_AF_XDP_ZC_SUPPORT
 74 | /**
 75 |  * i40e_update_tx_stats - Update the egress statistics for the Tx ring
 76 |  * @tx_ring: Tx ring to update
 77 |  * @total_packets: total packets sent
 78 |  * @total_bytes: total bytes sent
 79 |  **/
 80 | static inline void i40e_update_tx_stats(struct i40e_ring *tx_ring,
 81 | 					unsigned int total_packets,
 82 | 					unsigned int total_bytes)
 83 | {
 84 | 	u64_stats_update_begin(&tx_ring->syncp);
 85 | 	tx_ring->stats.bytes += total_bytes;
 86 | 	tx_ring->stats.packets += total_packets;
 87 | 	u64_stats_update_end(&tx_ring->syncp);
 88 | 	tx_ring->q_vector->tx.total_bytes += total_bytes;
 89 | 	tx_ring->q_vector->tx.total_packets += total_packets;
 90 | }
 91 | #endif /* HAVE_AF_XDP_ZC_SUPPORT */
 92 | 
 93 | #define WB_STRIDE 4
 94 | 
 95 | /**
 96 |  * i40e_arm_wb - (Possibly) arms Tx write-back
 97 |  * @tx_ring: Tx ring to update
 98 |  * @vsi: the VSI
 99 |  * @budget: the NAPI budget left
100 |  **/
101 | static inline void i40e_arm_wb(struct i40e_ring *tx_ring,
102 | 			       struct i40e_vsi *vsi,
103 | 			       int budget)
104 | {
105 | 	if (tx_ring->flags & I40E_TXR_FLAGS_WB_ON_ITR) {
106 | 		/* check to see if there are < 4 descriptors
107 | 		 * waiting to be written back, then kick the hardware to force
108 | 		 * them to be written back in case we stay in NAPI.
109 | 		 * In this mode on X722 we do not enable Interrupt.
110 | 		 */
111 | 		unsigned int j = i40e_get_tx_pending(tx_ring, false);
112 | 
113 | 		if (budget &&
114 | 		    ((j / WB_STRIDE) == 0) && j > 0 &&
115 | 		    !test_bit(__I40E_VSI_DOWN, vsi->state) &&
116 | 		    (I40E_DESC_UNUSED(tx_ring) != tx_ring->count))
117 | 			tx_ring->arm_wb = true;
118 | 	}
119 | }
120 | 
121 | #ifdef HAVE_MEM_TYPE_XSK_BUFF_POOL
122 | /**
123 |  * i40e_rx_is_programming_status - check for programming status descriptor
124 |  * @qword1: qword1 representing status_error_len in CPU ordering
125 |  *
126 |  * The value of in the descriptor length field indicate if this
127 |  * is a programming status descriptor for flow director or FCoE
128 |  * by the value of I40E_RX_PROG_STATUS_DESC_LENGTH, otherwise
129 |  * it is a packet descriptor.
130 |  **/
131 | static inline bool i40e_rx_is_programming_status(u64 qword1)
132 | {
133 | 	/* The Rx filter programming status and SPH bit occupy the same
134 | 	 * spot in the descriptor. Since we don't support packet split we
135 | 	 * can just reuse the bit as an indication that this is a
136 | 	 * programming status descriptor.
137 | 	 */
138 | 	return qword1 & I40E_RXD_QW1_LENGTH_SPH_MASK;
139 | }
140 | #endif /* HAVE_MEM_TYPE_XSK_BUFF_POOL */
141 | 
142 | void i40e_xsk_clean_rx_ring(struct i40e_ring *rx_ring);
143 | void i40e_xsk_clean_tx_ring(struct i40e_ring *tx_ring);
144 | bool i40e_xsk_any_rx_ring_enabled(struct i40e_vsi *vsi);
145 | 
146 | #endif /* _I40E_TXRX_COMMON_H_ */
147 | 


--------------------------------------------------------------------------------
/src/i40e_virtchnl_pf.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _I40E_VIRTCHNL_PF_H_
  5 | #define _I40E_VIRTCHNL_PF_H_
  6 | 
  7 | #include "i40e.h"
  8 | 
  9 | #define I40E_MAX_VLANID 4095
 10 | 
 11 | #define I40E_VIRTCHNL_SUPPORTED_QTYPES 2
 12 | 
 13 | #define I40E_DEFAULT_NUM_MDD_EVENTS_ALLOWED	3
 14 | 
 15 | #define I40E_VLAN_PRIORITY_SHIFT	13
 16 | #define I40E_VLAN_MASK			0xFFF
 17 | #define I40E_PRIORITY_MASK		0xE000
 18 | 
 19 | #define I40E_MAX_VF_PROMISC_FLAGS	3
 20 | 
 21 | #define I40E_VF_STATE_WAIT_COUNT	20
 22 | #define I40E_VFR_WAIT_COUNT		100
 23 | #define I40E_VF_RESET_TIME_MIN		30000000	// time in nsec
 24 | 
 25 | /* Various queue ctrls */
 26 | enum i40e_queue_ctrl {
 27 | 	I40E_QUEUE_CTRL_UNKNOWN = 0,
 28 | 	I40E_QUEUE_CTRL_ENABLE,
 29 | 	I40E_QUEUE_CTRL_ENABLECHECK,
 30 | 	I40E_QUEUE_CTRL_DISABLE,
 31 | 	I40E_QUEUE_CTRL_DISABLECHECK,
 32 | 	I40E_QUEUE_CTRL_FASTDISABLE,
 33 | 	I40E_QUEUE_CTRL_FASTDISABLECHECK,
 34 | };
 35 | 
 36 | /* VF states */
 37 | enum i40e_vf_states {
 38 | 	I40E_VF_STATE_INIT = 0,
 39 | 	I40E_VF_STATE_ACTIVE,
 40 | 	I40E_VF_STATE_DISABLED,
 41 | 	I40E_VF_STATE_MC_PROMISC,
 42 | 	I40E_VF_STATE_UC_PROMISC,
 43 | 	I40E_VF_STATE_PRE_ENABLE,
 44 | 	I40E_VF_STATE_RESETTING,
 45 | 	I40E_VF_STATE_RESOURCES_LOADED,
 46 | };
 47 | 
 48 | /* VF capabilities */
 49 | enum i40e_vf_capabilities {
 50 | 	I40E_VIRTCHNL_VF_CAP_PRIVILEGE = 0,
 51 | 	I40E_VIRTCHNL_VF_CAP_L2,
 52 | };
 53 | 
 54 | /* In ADq, max 4 VSI's can be allocated per VF including primary VF VSI.
 55 |  * These variables are used to store indices, id's and number of queues
 56 |  * for each VSI including that of primary VF VSI. Each Traffic class is
 57 |  * termed as channel and each channel can in-turn have 4 queues which
 58 |  * means max 16 queues overall per VF.
 59 |  */
 60 | struct i40evf_channel {
 61 | 	u16 vsi_idx; /* index in PF struct for all channel VSIs */
 62 | 	u16 vsi_id; /* VSI ID used by firmware */
 63 | 	u16 num_qps; /* number of queue pairs requested by user */
 64 | 	u64 max_tx_rate; /* bandwidth rate allocation for VSIs */
 65 | };
 66 | 
 67 | /* used for VLAN list 'vm_vlan_list' by VM for trusted and untrusted VF */
 68 | struct i40e_vm_vlan {
 69 | 	struct list_head list;
 70 | 	s16 vlan;
 71 | 	u16 vsi_id;
 72 | };
 73 | 
 74 | /* used for MAC list 'vm_mac_list' to recognize MACs added by VM */
 75 | struct i40e_vm_mac {
 76 | 	struct list_head list;
 77 | 	u8 macaddr[ETH_ALEN];
 78 | };
 79 | 
 80 | /* used for following share for given traffic class by VF*/
 81 | struct i40e_vf_tc_info {
 82 | 	bool applied;
 83 | 	u8 applied_tc_share[I40E_MAX_TRAFFIC_CLASS];
 84 | 	u8 requested_tc_share[I40E_MAX_TRAFFIC_CLASS];
 85 | 	u16 max_tc_tx_rate[I40E_MAX_TRAFFIC_CLASS];
 86 | };
 87 | 
 88 | struct i40e_time_mac {
 89 | 	unsigned long time_modified;
 90 | 	u8 addr[ETH_ALEN];
 91 | };
 92 | 
 93 | struct i40e_mdd_vf_events {
 94 | 	u64 count;	/* total count of Rx|Tx events */
 95 | 	/* count number of the last printed event */
 96 | 	u64 last_printed;
 97 | };
 98 | 
 99 | /* VF information structure */
100 | struct i40e_vf {
101 | 	struct i40e_pf *pf;
102 | 
103 | 	/* VF id in the PF space */
104 | 	s16 vf_id;
105 | 	/* all VF vsis connect to the same parent */
106 | 	enum i40e_switch_element_types parent_type;
107 | 	struct virtchnl_version_info vf_ver;
108 | 	u32 driver_caps; /* reported by VF driver */
109 | 
110 | 	/* VF Port Extender (PE) stag if used */
111 | 	u16 stag;
112 | 
113 | 	struct virtchnl_ether_addr default_lan_addr;
114 | 	struct i40e_time_mac legacy_last_added_umac; /* keeps last added MAC address */
115 | 	s16 port_vlan_id;
116 | 	bool pf_set_mac;	/* The VMM admin set the VF MAC address */
117 | 	bool trusted;
118 | 	bool source_pruning;
119 | 	u64 reset_timestamp;
120 | 
121 | 	/* VSI indices - actual VSI pointers are maintained in the PF structure
122 | 	 * When assigned, these will be non-zero, because VSI 0 is always
123 | 	 * the main LAN VSI for the PF.
124 | 	 */
125 | 	u16 lan_vsi_idx;	/* index into PF struct */
126 | 	u16 lan_vsi_id;		/* ID as used by firmware */
127 | 
128 | 	u8 num_queue_pairs;	/* num of qps assigned to VF vsis */
129 | 	u8 num_req_queues;	/* num of requested qps */
130 | 	/* num of mdd tx and rx events detected */
131 | 	struct i40e_mdd_vf_events mdd_rx_events;
132 | 	struct i40e_mdd_vf_events mdd_tx_events;
133 | 
134 | 	unsigned long vf_caps;	/* vf's adv. capabilities */
135 | 	unsigned long vf_states;	/* vf's runtime states */
136 | 	unsigned int tx_rate;	/* Tx bandwidth limit in Mbps */
137 | #ifdef HAVE_NDO_SET_VF_LINK_STATE
138 | 	bool link_forced;
139 | 	bool link_up;		/* only valid if VF link is forced */
140 | #endif
141 | 	bool mac_anti_spoof;
142 | 	bool vlan_anti_spoof;
143 | 	u16 num_vlan;
144 | 	DECLARE_BITMAP(mirror_vlans, VLAN_N_VID);
145 | 	u16 vlan_rule_id;
146 | #define I40E_NO_VF_MIRROR	-1
147 | /* assuming vf ids' range is <0..max_supported> */
148 | #define I40E_IS_MIRROR_VLAN_ID_VALID(id) ((id) >= 0)
149 | 	u16 ingress_rule_id;
150 | 	int ingress_vlan;
151 | 	u16 egress_rule_id;
152 | 	int egress_vlan;
153 | 	DECLARE_BITMAP(trunk_vlans, VLAN_N_VID);
154 | 	bool trunk_set_by_pf;
155 | 	bool allow_untagged; /* update filters, when changing value */
156 | 	bool loopback;
157 | 	bool vlan_stripping;
158 | 	u8 promisc_mode;
159 | 	u8 bw_share;
160 | 	bool bw_share_applied; /* true if config is applied to the device */
161 | 	bool tc_bw_share_req;
162 | 	bool pf_ctrl_disable; /* bool for PF ctrl of VF enable/disable */
163 | 	u8 queue_type;
164 | 	bool allow_bcast;
165 | 	/* VLAN list created by VM for trusted and untrusted VF */
166 | 	struct list_head vm_vlan_list;
167 | 	/* MAC list created by VM */
168 | 	struct list_head vm_mac_list;
169 | 	/* ADq related variables */
170 | 	bool adq_enabled; /* flag to enable adq */
171 | 	u8 num_tc;
172 | 	struct i40evf_channel ch[I40E_MAX_VF_VSI];
173 | 	struct hlist_head cloud_filter_list;
174 | 	u16 num_cloud_filters;
175 | 	struct i40e_vf_tc_info tc_info;
176 | 	struct virtchnl_vlan_caps vlan_v2_caps;
177 | };
178 | 
179 | void i40e_free_vfs(struct i40e_pf *pf);
180 | #if defined(HAVE_SRIOV_CONFIGURE) || defined(HAVE_RHEL6_SRIOV_CONFIGURE)
181 | int i40e_pci_sriov_configure(struct pci_dev *dev, int num_vfs);
182 | #endif
183 | int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs);
184 | int i40e_vc_process_vf_msg(struct i40e_pf *pf, s16 vf_id, u32 v_opcode,
185 | 			   u32 v_retval, u8 *msg, u16 msglen);
186 | int i40e_vc_process_vflr_event(struct i40e_pf *pf);
187 | bool i40e_reset_vf(struct i40e_vf *vf, bool flr);
188 | bool i40e_reset_all_vfs(struct i40e_pf *pf, bool flr);
189 | void i40e_vc_notify_vf_reset(struct i40e_vf *vf);
190 | 
191 | /* VF configuration related iplink handlers */
192 | int i40e_ndo_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac);
193 | #ifdef IFLA_VF_VLAN_INFO_MAX
194 | int i40e_ndo_set_vf_port_vlan(struct net_device *netdev, int vf_id,
195 | 			      u16 vlan_id, u8 qos, __be16 vlan_proto);
196 | #else
197 | int i40e_ndo_set_vf_port_vlan(struct net_device *netdev,
198 | 			      int vf_id, u16 vlan_id, u8 qos);
199 | #endif
200 | #ifdef HAVE_NDO_SET_VF_MIN_MAX_TX_RATE
201 | int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
202 | 		       int max_tx_rate);
203 | #else
204 | int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int tx_rate);
205 | #endif
206 | #ifdef HAVE_NDO_SET_VF_TRUST
207 | int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting);
208 | #endif
209 | int i40e_ndo_enable_vf(struct net_device *netdev, int vf_id, bool enable);
210 | #ifdef IFLA_VF_MAX
211 | int i40e_ndo_get_vf_config(struct net_device *netdev,
212 | 			   int vf_id, struct ifla_vf_info *ivi);
213 | #ifdef HAVE_NDO_SET_VF_LINK_STATE
214 | int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link);
215 | #endif
216 | #ifdef HAVE_VF_SPOOFCHK_CONFIGURE
217 | int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable);
218 | #endif
219 | #endif
220 | 
221 | void i40e_vc_notify_link_state(struct i40e_pf *pf);
222 | void i40e_vc_notify_reset(struct i40e_pf *pf);
223 | void i40e_restore_all_vfs_msi_state(struct pci_dev *pdev);
224 | #ifdef HAVE_VF_STATS
225 | int i40e_get_vf_stats(struct net_device *netdev, int vf_id,
226 | 		      struct ifla_vf_stats *vf_stats);
227 | #endif
228 | extern const struct vfd_ops i40e_vfd_ops;
229 | 
230 | #endif /* _I40E_VIRTCHNL_PF_H_ */
231 | 


--------------------------------------------------------------------------------
/src/i40e_xsk.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _I40E_XSK_H_
 5 | #define _I40E_XSK_H_
 6 | 
 7 | #ifdef HAVE_AF_XDP_ZC_SUPPORT
 8 | 
 9 | /* This value should match the pragma in the loop_unrolled_for
10 |  * macro. Why 4? It is strictly empirical. It seems to be a good
11 |  * compromise between the advantage of having simultaneous outstanding
12 |  * reads to the DMA array that can hide each others latency and the
13 |  * disadvantage of having a larger code path.
14 |  */
15 | #define PKTS_PER_BATCH 4
16 | 
17 | #if __GNUC__ >= 8
18 | #define loop_unrolled_for _Pragma("GCC unroll 4") for
19 | #else
20 | #define loop_unrolled_for for
21 | #endif
22 | 
23 | struct i40e_vsi;
24 | #ifdef HAVE_NETDEV_BPF_XSK_POOL
25 | struct xsk_buff_pool;
26 | #else
27 | struct xdp_umem;
28 | #endif /*HAVE_NETDEV_BPF_XSK_POOL */
29 | struct zero_copy_allocator;
30 | 
31 | int i40e_queue_pair_disable(struct i40e_vsi *vsi, int queue_pair);
32 | int i40e_queue_pair_enable(struct i40e_vsi *vsi, int queue_pair);
33 | #ifndef NO_XDP_QUERY_XSK_UMEM
34 | int i40e_xsk_umem_query(struct i40e_vsi *vsi, struct xdp_umem **umem,
35 | 			u16 qid);
36 | #endif /* NO_XDP_QUERY_XSK_UMEM */
37 | #ifdef HAVE_NETDEV_BPF_XSK_POOL
38 | int i40e_xsk_pool_setup(struct i40e_vsi *vsi, struct xsk_buff_pool *pool,
39 | 			u16 qid);
40 | #else
41 | int i40e_xsk_umem_setup(struct i40e_vsi *vsi, struct xdp_umem *umem,
42 | 			u16 qid);
43 | #endif /* HAVE_NETDEV_BFP_XSK_POOL */
44 | #ifndef HAVE_MEM_TYPE_XSK_BUFF_POOL
45 | void i40e_zca_free(struct zero_copy_allocator *alloc, unsigned long handle);
46 | #endif /* HAVE_MEM_TYPE_XSK_BUFF_POOL */
47 | 
48 | bool i40e_alloc_rx_buffers_zc(struct i40e_ring *rx_ring, u16 cleaned_count);
49 | int i40e_clean_rx_irq_zc(struct i40e_ring *rx_ring, int budget);
50 | 
51 | bool i40e_clean_xdp_tx_irq(struct i40e_vsi *vsi, struct i40e_ring *tx_ring);
52 | #ifdef HAVE_NDO_XSK_WAKEUP
53 | int i40e_xsk_wakeup(struct net_device *dev, u32 queue_id, u32 flags);
54 | #else
55 | int i40e_xsk_async_xmit(struct net_device *dev, u32 queue_id);
56 | #endif /* HAVE_NDO_XSK_WAKEUP */
57 | 
58 | #ifdef HAVE_MEM_TYPE_XSK_BUFF_POOL
59 | int i40e_alloc_rx_bi_zc(struct i40e_ring *rx_ring);
60 | void i40e_clear_rx_bi_zc(struct i40e_ring *rx_ring);
61 | #endif /* HAVE_MEM_TYPE_XSK_BUFF_POOL */
62 | 
63 | #endif /* HAVE_AF_XDP_SUPPORT */
64 | #endif /* _I40E_XSK_H_ */
65 | 
66 | 


--------------------------------------------------------------------------------
/src/kcompat-lib.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # SPDX-License-Identifier: GPL-2.0-only
  3 | # Copyright (C) 2013-2023 Intel Corporation
  4 | 
  5 | # to be sourced
  6 | 
  7 | # General shell helpers
  8 | 
  9 | # exit with non-zero exit code; if there is only one param:
 10 | # exit with msg $1 and exit code from last command (or 99 if = 0)
 11 | # otherwise, exit with $1 and use remaining arguments as msg
 12 | function die() {
 13 | 	rc=$?
 14 | 	if [ $# -gt 1 ]; then
 15 | 		rc="$1"
 16 | 		shift
 17 | 	fi
 18 | 	[ "$rc" -ne 0 ] || rc=99
 19 | 	echo >&2 "$@"
 20 | 	exit $rc
 21 | }
 22 | 
 23 | # filter out paths that are not files
 24 | # input $@, output via echo;
 25 | # note: pass `-` for stdin
 26 | # note: outputs nothing if all input files are "bad" (eg. not existing), but it
 27 | #	is left for caller to decide if this is an erorr condition;
 28 | # note: whitespaces are considered "bad" as part of filename, it's an error.
 29 | function filter-out-bad-files() {
 30 | 	if [[ $# = 1 && "$1" = '-' ]]; then
 31 | 		echo -
 32 | 		return 0
 33 | 	fi
 34 | 	if [ $# = 0 ]; then
 35 | 		die 10 "no files passed, use '-' when reading from pipe (|)"
 36 | 	fi
 37 | 	local any=0 diagmsgs=/dev/stderr re=$'[\t \n]'
 38 | 	[ -n "${QUIET_COMPAT-}" ] && diagmsgs=/dev/null
 39 | 	for x in "$@"; do
 40 | 		if [ -e "$x" ]; then
 41 | 			if [[ "$x" =~ $re ]]; then
 42 | 				die 11 "err: filename contains whitespaces: $x."
 43 | 			fi
 44 | 			echo "$x"
 45 | 			any=1
 46 | 		else
 47 | 			echo >&"$diagmsgs" filtering "$x" out
 48 | 		fi
 49 | 	done
 50 | 	if [ $any = 0 ]; then
 51 | 		echo >&"$diagmsgs" 'all files (for given query) filtered out'
 52 | 	fi
 53 | }
 54 | 
 55 | # Basics of regexp explained, as a reference for mostly-C programmers:
 56 | # (bash) "regexp-$VAR-regexp"  - bash' VARs are placed into "QUOTED" strings
 57 | # /\);?$/       - match end of function declaration, $ is end of string
 58 | # ^[ \t]*       - (heuristic), anything but comment, eg to exclude function docs
 59 | # /STH/, /END/  - (awk), print all lines sice STH matched, up to END, inclusive
 60 | 
 61 | # "Whitespace only"
 62 | WB='[ \t\n]'
 63 | 
 64 | # Helpers below print the thing that is looked for, for further grep'ping/etc.
 65 | # That simplifies process of excluding comments or spares us state machine impl.
 66 | #
 67 | # We take advantage of current/common linux codebase formatting here.
 68 | #
 69 | # Functions in this section require input file/s passed as args
 70 | # (usually one, but more could be supplied in case of renames in kernel),
 71 | # '-' could be used as an (only) file argument to read from stdin/pipe.
 72 | 
 73 | # wrapper over find-something-decl() functions below, to avoid repetition
 74 | # pass $what as $1, $end as $2, and $files to look in as rest of args
 75 | function find-decl() {
 76 | 	test $# -ge 3 # ensure that there are at least 3 params
 77 | 	local what end files
 78 | 	what="$1"
 79 | 	end="$2"
 80 | 	shift 2
 81 | 	files="$(filter-out-bad-files "$@")" || die
 82 | 	if [ -z "$files" ]; then
 83 | 		return 0
 84 | 	fi
 85 | 	# shellcheck disable=SC2086
 86 | 	awk "
 87 | 		/^$WB*\*/ {next}
 88 | 		$what, $end
 89 | 	" $files
 90 | }
 91 | 
 92 | # yield $1 function declaration (signature), don't pass return type in $1
 93 | # looks only in files specified ($2, $3...)
 94 | function find-fun-decl() {
 95 | 	test $# -ge 2
 96 | 	local what end
 97 | 	what="/$WB*([(]\*)?$1$WB*($|[()])/"
 98 | 	end='/\);?$/'
 99 | 	shift
100 | 	find-decl "$what" "$end" "$@"
101 | }
102 | 
103 | # yield $1 enum declaration (type/body)
104 | function find-enum-decl() {
105 | 	test $# -ge 2
106 | 	local what end
107 | 	what="/^$WB*enum$WB+$1"' \{$/'
108 | 	end='/\};$/'
109 | 	shift
110 | 	find-decl "$what" "$end" "$@"
111 | }
112 | 
113 | # yield $1 struct declaration (type/body)
114 | function find-struct-decl() {
115 | 	test $# -ge 2
116 | 	local what end
117 | 	what="/^$WB*struct$WB+$1"' \{$/'
118 | 	end='/^\};$/' # that's (^) different from enum-decl
119 | 	shift
120 | 	find-decl "$what" "$end" "$@"
121 | }
122 | 
123 | # yield first line of $1 macro definition
124 | function find-macro-decl() {
125 | 	test $# -ge 2
126 | 	local what end
127 | 	# only unindented defines, only whole-word match
128 | 	what="/^#define$WB+$1"'([ \t\(]|$)/'
129 | 	end=1 # only first line; use find-macro-implementation-decl for full body
130 | 	shift
131 | 	find-decl "$what" "$end" "$@"
132 | }
133 | 
134 | # yield full macro implementation
135 | function find-macro-implementation-decl() {
136 | 	test $# -ge 2
137 | 	local what end
138 | 	# only unindented defines, only whole-word match
139 | 	what="/^#define$WB+$1"'([ \t\(]|$)/'
140 | 	# full implementation, until a line not ending in a backslash.
141 | 	# Does not handle macros with comments embedded within the definition.
142 | 	end='/[^\\]$/'
143 | 	shift
144 | 	find-decl "$what" "$end" "$@"
145 | }
146 | 
147 | # yield first line of $1 typedef definition (simple typedefs only)
148 | # this probably won't handle typedef struct { \n int foo;\n};
149 | function find-typedef-decl() {
150 | 	test $# -ge 2
151 | 	local what end
152 | 	what="/^typedef .* $1"';$/'
153 | 	end=1
154 | 	shift
155 | 	find-decl "$what" "$end" "$@"
156 | }
157 | 
158 | # gen() - DSL-like function to wrap around all the other
159 | #
160 | # syntax:
161 | #   gen DEFINE if (KIND [METHOD of]) NAME [(matches|lacks) PATTERN|absent] in <list-of-files>
162 | 
163 | # where:
164 | #   DEFINE is HAVE_ or NEED_ #define to print;
165 | #   `if` is there to just read it easier and made syntax easier to check;
166 | #
167 | #   NAME is the name for what we are looking for;
168 | #
169 | #   KIND specifies what kind of declaration/definition we are looking for,
170 | #      could be: fun, enum, struct, method, macro, typedef,
171 | #      'implementation of macro'
172 | #   for KIND=method, we are looking for function ptr named METHOD in struct
173 | #     named NAME (two optional args are then necessary (METHOD & of));
174 | #
175 | #   for KIND='implementation of macro' we are looking for the full
176 | #     implementation of the macro, not just its first line. This is usually
177 | #     combined with "matches" or "lacks".
178 | #
179 | #   next [optional] args could be used:
180 | #     matches PATTERN - use to grep for the PATTERN within definition
181 | #       (eg, for ext_ack param)
182 | #     lacks - use to add #define only if there is no match of the PATTERN,
183 | #       *but* the NAME is *found*
184 | #     absent - the NAME that we grep for must be not found
185 | #       (ie: function not exisiting)
186 | #
187 | #     without this optional params, behavior is the same as with
188 | #       `matches .` - use to grep just for existence of NAME;
189 | #
190 | #   `in` is there to ease syntax, similar to `if` before.
191 | #
192 | #  <list-of-files> is just space-separate list of files to look in,
193 | #    single (-) for stdin.
194 | #
195 | # PATTERN is awk pattern, will be wrapped by two slashes (/)
196 | function gen() {
197 | 	test $# -ge 6 || die 20 "too few arguments, $# given, at least 6 needed"
198 | 	local define if_kw kind name in_kw # mandatory
199 | 	local of_kw method_name operator pattern # optional
200 | 	local src_line="${BASH_SOURCE[0]}:${BASH_LINENO[0]}"
201 | 	define="$1"
202 | 	if_kw="$2"
203 | 	kind="$3"
204 | 	local orig_args_cnt=$#
205 | 	shift 3
206 | 	[ "$if_kw" != if ] && die 21 "$src_line: 'if' keyword expected, '$if_kw' given"
207 | 	case "$kind" in
208 | 	fun|enum|struct|macro|typedef)
209 | 		name="$1"
210 | 		shift
211 | 	;;
212 | 	method)
213 | 		test $# -ge 5 || die 22 "$src_line: too few arguments, $orig_args_cnt given, at least 8 needed"
214 | 		method_name="$1"
215 | 		of_kw="$2"
216 | 		name="$3"
217 | 		shift 3
218 | 		[ "$of_kw" != of ] && die 23 "$src_line: 'of' keyword expected, '$of_kw' given"
219 | 	;;
220 | 	implementation)
221 | 		test $# -ge 5 || die 28 "$src_line: too few arguments, $orig_args_cnt given, at least 8 needed"
222 | 		of_kw="$1"
223 | 		kind="$2"
224 | 		name="$3"
225 | 		shift 3
226 | 		[ "$of_kw" != of ] && die 29 "$src_line: 'of' keyword expected, '$of_kw' given"
227 | 		[ "$kind" != macro ] && die 30 "$src_line: implementation only supports 'macro', '$kind' given"
228 | 		kind=macro-implementation
229 | 	;;
230 | 	*) die 24 "$src_line: unknown KIND ($kind) to look for" ;;
231 | 	esac
232 | 	operator="$1"
233 | 	case "$operator" in
234 | 	absent)
235 | 		pattern='.'
236 | 		in_kw="$2"
237 | 		shift 2
238 | 	;;
239 | 	matches|lacks)
240 | 		pattern="$2"
241 | 		in_kw="$3"
242 | 		shift 3
243 | 	;;
244 | 	in)
245 | 		operator=matches
246 | 		pattern='.'
247 | 		in_kw=in
248 | 		shift
249 | 	;;
250 | 	*) die 25 "$src_line: unknown OPERATOR ($operator) to look for" ;;
251 | 	esac
252 | 	[ "$in_kw" != in ] && die 26 "$src_line: 'in' keyword expected, '$in_kw' given"
253 | 	test $# -ge 1 || die 27 "$src_line: too few arguments, at least one filename expected"
254 | 
255 | 	local first_decl=
256 | 	if [ "$kind" = method ]; then
257 | 		first_decl="$(find-struct-decl "$name" "$@")" || exit 28
258 | 		# prepare params for next lookup phase
259 | 		set -- - # overwrite $@ to be single dash (-)
260 | 		name="$method_name"
261 | 		kind=fun
262 | 	elif [[ $# = 1 && "$1" = '-' ]]; then
263 | 		# avoid losing stdin provided to gen() due to redirection (<<<)
264 | 		first_decl="$(cat -)"
265 | 	fi
266 | 
267 | 	# lookup the NAME
268 | 	local body
269 | 	body="$(find-$kind-decl "$name" "$@" <<< "$first_decl")" || exit 29
270 | 	awk -v define="$define" -v pattern="$pattern" -v "$operator"=1 '
271 | 		/./ { not_empty = 1 }
272 | 		$0 ~ pattern { found = 1 }
273 | 		END {
274 | 			if (lacks && !found && not_empty || matches && found || absent && !found)
275 | 				print "#define", define
276 | 		}
277 | 	' <<< "$body"
278 | }
279 | 


--------------------------------------------------------------------------------
/src/kcompat_defs.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _KCOMPAT_DEFS_H_
 5 | #define _KCOMPAT_DEFS_H_
 6 | 
 7 | #ifndef LINUX_VERSION_CODE
 8 | #include <linux/version.h>
 9 | #else
10 | #ifndef KERNEL_VERSION
11 | #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
12 | #endif
13 | #endif /* LINUX_VERSION_CODE */
14 | 
15 | #ifndef UTS_RELEASE
16 | #include <generated/utsrelease.h>
17 | #endif
18 | 
19 | /*
20 |  * Include the definitions file for HAVE/NEED flags for the standard upstream
21 |  * kernels.
22 |  *
23 |  * Then, based on the distribution we detect, load the distribution specific
24 |  * definitions file that customizes the definitions for the target
25 |  * distribution.
26 |  */
27 | #include "kcompat_std_defs.h"
28 | 
29 | #ifdef CONFIG_SUSE_KERNEL
30 | #include "kcompat_sles_defs.h"
31 | #elif UBUNTU_VERSION_CODE
32 | #include "kcompat_ubuntu_defs.h"
33 | #elif RHEL_RELEASE_CODE
34 | #include "kcompat_rhel_defs.h"
35 | #endif
36 | 
37 | #include "kcompat_generated_defs.h"
38 | 
39 | #endif /* _KCOMPAT_DEFS_H_ */
40 | 


--------------------------------------------------------------------------------
/src/kcompat_gcc.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _KCOMPAT_GCC_H_
  5 | #define _KCOMPAT_GCC_H_
  6 | 
  7 | #ifndef GCC_VERSION
  8 | #define GCC_VERSION (__GNUC__ * 10000		\
  9 | 		     + __GNUC_MINOR__ * 100	\
 10 | 		     + __GNUC_PATCHLEVEL__)
 11 | #endif /* GCC_VERSION */
 12 | 
 13 | #ifdef __has_attribute
 14 | #if __has_attribute(__fallthrough__)
 15 | # define fallthrough __attribute__((__fallthrough__))
 16 | #else
 17 | # define fallthrough do {} while (0)  /* fallthrough */
 18 | #endif /* __has_attribute(fallthrough) */
 19 | #else
 20 | # define fallthrough do {} while (0)  /* fallthrough */
 21 | #endif /* __has_attribute */
 22 | 
 23 | /* Backport macros for controlling GCC diagnostics */
 24 | #if ( LINUX_VERSION_CODE < KERNEL_VERSION(4,18,0) )
 25 | 
 26 | /* Compilers before gcc-4.6 do not understand "#pragma GCC diagnostic push" */
 27 | #if GCC_VERSION >= 40600
 28 | #define __diag_str1(s)		#s
 29 | #define __diag_str(s)		__diag_str1(s)
 30 | #define __diag(s)		_Pragma(__diag_str(GCC diagnostic s))
 31 | #else
 32 | #define __diag(s)
 33 | #endif /* GCC_VERSION >= 4.6 */
 34 | #define __diag_push()	__diag(push)
 35 | #define __diag_pop()	__diag(pop)
 36 | #endif /* LINUX_VERSION < 4.18.0 */
 37 | 
 38 | #if GCC_VERSION < 50000
 39 | /* Workaround for gcc bug - not accepting "(type)" before "{ ... }" as part of
 40 |  * static struct initializers [when used with -std=gnu11 switch]
 41 |  * https://bugzilla.redhat.com/show_bug.cgi?id=1672652
 42 |  *
 43 |  * fix was backported to gcc 4.8.5-39 by RedHat, contained in RHEL 7.7
 44 |  * workaround here is to just drop that redundant (commented out below) part and
 45 |  * redefine kernel macros used by us.
 46 |  */
 47 | 
 48 | /* Since problematic code could be triggered by print-family (incl. wrappers)
 49 |  * invocation, we have to first include headers that contain macros that we are
 50 |  * redefining, and only later proceed with the rest of includes.
 51 |  */
 52 | #include <linux/compiler.h>
 53 | #include <linux/dynamic_debug.h>
 54 | #include <linux/pci.h>
 55 | #include <linux/spinlock.h>
 56 | 
 57 | #ifdef __SPIN_LOCK_INITIALIZER
 58 | #undef __SPIN_LOCK_UNLOCKED
 59 | #define __SPIN_LOCK_UNLOCKED(lockname) \
 60 | 	/* (spinlock_t) */ __SPIN_LOCK_INITIALIZER(lockname)
 61 | #endif /* __SPIN_LOCK_INITIALIZER */
 62 | 
 63 | #ifdef __RAW_SPIN_LOCK_INITIALIZER
 64 | #undef __RAW_SPIN_LOCK_UNLOCKED
 65 | #define __RAW_SPIN_LOCK_UNLOCKED(lockname) \
 66 | 	/* (raw_spinlock_t) */ __RAW_SPIN_LOCK_INITIALIZER(lockname)
 67 | #endif /* __RAW_SPIN_LOCK_INITIALIZER */
 68 | 
 69 | #ifndef CONFIG_DEBUG_SPINLOCK
 70 | /* raw_spin_lock_init needs __RAW_SPIN_LOCK_UNLOCKED with typecast, so keep the
 71 |  * original impl,
 72 |  * but enhance it with typecast dropped from __RAW_SPIN_LOCK_UNLOCKED() */
 73 | #undef raw_spin_lock_init
 74 | #define raw_spin_lock_init(lock)					\
 75 | 	do { *(lock) = (raw_spinlock_t) __RAW_SPIN_LOCK_UNLOCKED(lock);	\
 76 | 	} while (0)
 77 | #endif /* !CONFIG_DEBUG_SPINLOCK */
 78 | 
 79 | #undef STATIC_KEY_INIT_TRUE
 80 | #define STATIC_KEY_INIT_TRUE					\
 81 | 	{ .enabled = { 1 },					\
 82 | 	  { .type = 1UL } }
 83 | 
 84 | #undef STATIC_KEY_INIT_FALSE
 85 | #define STATIC_KEY_INIT_FALSE	\
 86 | 	{ .enabled = { 0 } }
 87 | 
 88 | #ifdef NEED_DEFINE_STATIC_KEY_FALSE
 89 | #undef STATIC_KEY_TRUE_INIT
 90 | #define STATIC_KEY_TRUE_INIT \
 91 | 	(struct static_key_true) { .key = STATIC_KEY_INIT_TRUE }
 92 | 
 93 | #undef STATIC_KEY_FALSE_INIT
 94 | #define STATIC_KEY_FALSE_INIT \
 95 | 	(struct static_key_false) { .key = STATIC_KEY_INIT_FALSE }
 96 | #endif /* NEED_DEFINE_STATIC_KEY_FALSE */
 97 | 
 98 | #ifdef HAVE_JUMP_LABEL
 99 | /* dd_key_init() is used (indirectly) with arg like "(STATIC_KEY_INIT_FALSE)"
100 |  * from DEFINE_DYNAMIC_DEBUG_METADATA(), which, depending on config has many
101 |  * different definitions (including helper macros).
102 |  * To reduce compat code, just consume parens from the arg instead copy-pasting
103 |  * all definitions and slightly changing them. */
104 | #define _KC_SLURP_PARENS(...) __VA_ARGS__
105 | #undef dd_key_init
106 | #define dd_key_init(key, init) key = _KC_SLURP_PARENS init
107 | #endif /* HAVE_JUMP_LABEL */
108 | 
109 | #undef UUID_INIT
110 | #define UUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)		\
111 | 	{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff,			\
112 | 	   ((a) >> 8) & 0xff, (a) & 0xff,				\
113 | 	   ((b) >> 8) & 0xff, (b) & 0xff,				\
114 | 	   ((c) >> 8) & 0xff, (c) & 0xff,				\
115 | 	   (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)		\
116 | 	}}
117 | 
118 | #endif /* GCC_VERSION < 5.0 */
119 | 
120 | #endif /* _KCOMPAT_GCC_H_ */
121 | 


--------------------------------------------------------------------------------
/src/kcompat_overflow.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | /* SPDX-License-Identifier: GPL-2.0 OR MIT */
  5 | #ifndef __LINUX_OVERFLOW_H
  6 | #define __LINUX_OVERFLOW_H
  7 | 
  8 | #include <linux/compiler.h>
  9 | 
 10 | /*
 11 |  * In the fallback code below, we need to compute the minimum and
 12 |  * maximum values representable in a given type. These macros may also
 13 |  * be useful elsewhere, so we provide them outside the
 14 |  * COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW block.
 15 |  *
 16 |  * It would seem more obvious to do something like
 17 |  *
 18 |  * #define type_min(T) (T)(is_signed_type(T) ? (T)1 << (8*sizeof(T)-1) : 0)
 19 |  * #define type_max(T) (T)(is_signed_type(T) ? ((T)1 << (8*sizeof(T)-1)) - 1 : ~(T)0)
 20 |  *
 21 |  * Unfortunately, the middle expressions, strictly speaking, have
 22 |  * undefined behaviour, and at least some versions of gcc warn about
 23 |  * the type_max expression (but not if -fsanitize=undefined is in
 24 |  * effect; in that case, the warning is deferred to runtime...).
 25 |  *
 26 |  * The slightly excessive casting in type_min is to make sure the
 27 |  * macros also produce sensible values for the exotic type _Bool. [The
 28 |  * overflow checkers only almost work for _Bool, but that's
 29 |  * a-feature-not-a-bug, since people shouldn't be doing arithmetic on
 30 |  * _Bools. Besides, the gcc builtins don't allow _Bool* as third
 31 |  * argument.]
 32 |  *
 33 |  * Idea stolen from
 34 |  * https://mail-index.netbsd.org/tech-misc/2007/02/05/0000.html -
 35 |  * credit to Christian Biere.
 36 |  */
 37 | /* The is_signed_type macro is redefined in a few places in various kernel
 38 |  * headers. If this header is included at the same time as one of those, we
 39 |  * will generate compilation warnings. Since we can't fix every old kernel,
 40 |  * rename is_signed_type for this file to _kc_is_signed_type. This prevents
 41 |  * the macro name collision, and should be safe since our drivers do not
 42 |  * directly call the macro.
 43 |  */
 44 | #define _kc_is_signed_type(type)       (((type)(-1)) < (type)1)
 45 | #define __type_half_max(type) ((type)1 << (8*sizeof(type) - 1 - _kc_is_signed_type(type)))
 46 | #define type_max(T) ((T)((__type_half_max(T) - 1) + __type_half_max(T)))
 47 | #define type_min(T) ((T)((T)-type_max(T)-(T)1))
 48 | 
 49 | 
 50 | #ifdef COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW
 51 | /*
 52 |  * For simplicity and code hygiene, the fallback code below insists on
 53 |  * a, b and *d having the same type (similar to the min() and max()
 54 |  * macros), whereas gcc's type-generic overflow checkers accept
 55 |  * different types. Hence we don't just make check_add_overflow an
 56 |  * alias for __builtin_add_overflow, but add type checks similar to
 57 |  * below.
 58 |  */
 59 | #define check_add_overflow(a, b, d) ({		\
 60 | 	typeof(a) __a = (a);			\
 61 | 	typeof(b) __b = (b);			\
 62 | 	typeof(d) __d = (d);			\
 63 | 	(void) (&__a == &__b);			\
 64 | 	(void) (&__a == __d);			\
 65 | 	__builtin_add_overflow(__a, __b, __d);	\
 66 | })
 67 | 
 68 | #define check_sub_overflow(a, b, d) ({		\
 69 | 	typeof(a) __a = (a);			\
 70 | 	typeof(b) __b = (b);			\
 71 | 	typeof(d) __d = (d);			\
 72 | 	(void) (&__a == &__b);			\
 73 | 	(void) (&__a == __d);			\
 74 | 	__builtin_sub_overflow(__a, __b, __d);	\
 75 | })
 76 | 
 77 | #define check_mul_overflow(a, b, d) ({		\
 78 | 	typeof(a) __a = (a);			\
 79 | 	typeof(b) __b = (b);			\
 80 | 	typeof(d) __d = (d);			\
 81 | 	(void) (&__a == &__b);			\
 82 | 	(void) (&__a == __d);			\
 83 | 	__builtin_mul_overflow(__a, __b, __d);	\
 84 | })
 85 | 
 86 | #else
 87 | 
 88 | 
 89 | /* Checking for unsigned overflow is relatively easy without causing UB. */
 90 | #define __unsigned_add_overflow(a, b, d) ({	\
 91 | 	typeof(a) __a = (a);			\
 92 | 	typeof(b) __b = (b);			\
 93 | 	typeof(d) __d = (d);			\
 94 | 	(void) (&__a == &__b);			\
 95 | 	(void) (&__a == __d);			\
 96 | 	*__d = __a + __b;			\
 97 | 	*__d < __a;				\
 98 | })
 99 | #define __unsigned_sub_overflow(a, b, d) ({	\
100 | 	typeof(a) __a = (a);			\
101 | 	typeof(b) __b = (b);			\
102 | 	typeof(d) __d = (d);			\
103 | 	(void) (&__a == &__b);			\
104 | 	(void) (&__a == __d);			\
105 | 	*__d = __a - __b;			\
106 | 	__a < __b;				\
107 | })
108 | /*
109 |  * If one of a or b is a compile-time constant, this avoids a division.
110 |  */
111 | #define __unsigned_mul_overflow(a, b, d) ({		\
112 | 	typeof(a) __a = (a);				\
113 | 	typeof(b) __b = (b);				\
114 | 	typeof(d) __d = (d);				\
115 | 	(void) (&__a == &__b);				\
116 | 	(void) (&__a == __d);				\
117 | 	*__d = __a * __b;				\
118 | 	__builtin_constant_p(__b) ?			\
119 | 	  __b > 0 && __a > type_max(typeof(__a)) / __b : \
120 | 	  __a > 0 && __b > type_max(typeof(__b)) / __a;	 \
121 | })
122 | 
123 | /*
124 |  * For signed types, detecting overflow is much harder, especially if
125 |  * we want to avoid UB. But the interface of these macros is such that
126 |  * we must provide a result in *d, and in fact we must produce the
127 |  * result promised by gcc's builtins, which is simply the possibly
128 |  * wrapped-around value. Fortunately, we can just formally do the
129 |  * operations in the widest relevant unsigned type (u64) and then
130 |  * truncate the result - gcc is smart enough to generate the same code
131 |  * with and without the (u64) casts.
132 |  */
133 | 
134 | /*
135 |  * Adding two signed integers can overflow only if they have the same
136 |  * sign, and overflow has happened iff the result has the opposite
137 |  * sign.
138 |  */
139 | #define __signed_add_overflow(a, b, d) ({	\
140 | 	typeof(a) __a = (a);			\
141 | 	typeof(b) __b = (b);			\
142 | 	typeof(d) __d = (d);			\
143 | 	(void) (&__a == &__b);			\
144 | 	(void) (&__a == __d);			\
145 | 	*__d = (u64)__a + (u64)__b;		\
146 | 	(((~(__a ^ __b)) & (*__d ^ __a))	\
147 | 		& type_min(typeof(__a))) != 0;	\
148 | })
149 | 
150 | /*
151 |  * Subtraction is similar, except that overflow can now happen only
152 |  * when the signs are opposite. In this case, overflow has happened if
153 |  * the result has the opposite sign of a.
154 |  */
155 | #define __signed_sub_overflow(a, b, d) ({	\
156 | 	typeof(a) __a = (a);			\
157 | 	typeof(b) __b = (b);			\
158 | 	typeof(d) __d = (d);			\
159 | 	(void) (&__a == &__b);			\
160 | 	(void) (&__a == __d);			\
161 | 	*__d = (u64)__a - (u64)__b;		\
162 | 	((((__a ^ __b)) & (*__d ^ __a))		\
163 | 		& type_min(typeof(__a))) != 0;	\
164 | })
165 | 
166 | /*
167 |  * Signed multiplication is rather hard. gcc always follows C99, so
168 |  * division is truncated towards 0. This means that we can write the
169 |  * overflow check like this:
170 |  *
171 |  * (a > 0 && (b > MAX/a || b < MIN/a)) ||
172 |  * (a < -1 && (b > MIN/a || b < MAX/a) ||
173 |  * (a == -1 && b == MIN)
174 |  *
175 |  * The redundant casts of -1 are to silence an annoying -Wtype-limits
176 |  * (included in -Wextra) warning: When the type is u8 or u16, the
177 |  * __b_c_e in check_mul_overflow obviously selects
178 |  * __unsigned_mul_overflow, but unfortunately gcc still parses this
179 |  * code and warns about the limited range of __b.
180 |  */
181 | 
182 | #define __signed_mul_overflow(a, b, d) ({				\
183 | 	typeof(a) __a = (a);						\
184 | 	typeof(b) __b = (b);						\
185 | 	typeof(d) __d = (d);						\
186 | 	typeof(a) __tmax = type_max(typeof(a));				\
187 | 	typeof(a) __tmin = type_min(typeof(a));				\
188 | 	(void) (&__a == &__b);						\
189 | 	(void) (&__a == __d);						\
190 | 	*__d = (u64)__a * (u64)__b;					\
191 | 	(__b > 0   && (__a > __tmax/__b || __a < __tmin/__b)) ||	\
192 | 	(__b < (typeof(__b))-1  && (__a > __tmin/__b || __a < __tmax/__b)) || \
193 | 	(__b == (typeof(__b))-1 && __a == __tmin);			\
194 | })
195 | 
196 | 
197 | #define check_add_overflow(a, b, d)					\
198 | 	__builtin_choose_expr(_kc_is_signed_type(typeof(a)),		\
199 | 			__signed_add_overflow(a, b, d),			\
200 | 			__unsigned_add_overflow(a, b, d))
201 | 
202 | #define check_sub_overflow(a, b, d)					\
203 | 	__builtin_choose_expr(_kc_is_signed_type(typeof(a)),		\
204 | 			__signed_sub_overflow(a, b, d),			\
205 | 			__unsigned_sub_overflow(a, b, d))
206 | 
207 | #define check_mul_overflow(a, b, d)					\
208 | 	__builtin_choose_expr(_kc_is_signed_type(typeof(a)),		\
209 | 			__signed_mul_overflow(a, b, d),			\
210 | 			__unsigned_mul_overflow(a, b, d))
211 | 
212 | 
213 | #endif /* COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW */
214 | 
215 | /** check_shl_overflow() - Calculate a left-shifted value and check overflow
216 |  *
217 |  * @a: Value to be shifted
218 |  * @s: How many bits left to shift
219 |  * @d: Pointer to where to store the result
220 |  *
221 |  * Computes *@d = (@a << @s)
222 |  *
223 |  * Returns true if '*d' cannot hold the result or when 'a << s' doesn't
224 |  * make sense. Example conditions:
225 |  * - 'a << s' causes bits to be lost when stored in *d.
226 |  * - 's' is garbage (e.g. negative) or so large that the result of
227 |  *   'a << s' is guaranteed to be 0.
228 |  * - 'a' is negative.
229 |  * - 'a << s' sets the sign bit, if any, in '*d'.
230 |  *
231 |  * '*d' will hold the results of the attempted shift, but is not
232 |  * considered "safe for use" if false is returned.
233 |  */
234 | #define check_shl_overflow(a, s, d) ({					\
235 | 	typeof(a) _a = a;						\
236 | 	typeof(s) _s = s;						\
237 | 	typeof(d) _d = d;						\
238 | 	u64 _a_full = _a;						\
239 | 	unsigned int _to_shift =					\
240 | 		_s >= 0 && _s < 8 * sizeof(*d) ? _s : 0;		\
241 | 	*_d = (_a_full << _to_shift);					\
242 | 	(_to_shift != _s || *_d < 0 || _a < 0 ||			\
243 | 		(*_d >> _to_shift) != _a);				\
244 | })
245 | 
246 | /**
247 |  * array_size() - Calculate size of 2-dimensional array.
248 |  *
249 |  * @a: dimension one
250 |  * @b: dimension two
251 |  *
252 |  * Calculates size of 2-dimensional array: @a * @b.
253 |  *
254 |  * Returns: number of bytes needed to represent the array or SIZE_MAX on
255 |  * overflow.
256 |  */
257 | static inline __must_check size_t array_size(size_t a, size_t b)
258 | {
259 | 	size_t bytes;
260 | 
261 | 	if (check_mul_overflow(a, b, &bytes))
262 | 		return SIZE_MAX;
263 | 
264 | 	return bytes;
265 | }
266 | 
267 | /**
268 |  * array3_size() - Calculate size of 3-dimensional array.
269 |  *
270 |  * @a: dimension one
271 |  * @b: dimension two
272 |  * @c: dimension three
273 |  *
274 |  * Calculates size of 3-dimensional array: @a * @b * @c.
275 |  *
276 |  * Returns: number of bytes needed to represent the array or SIZE_MAX on
277 |  * overflow.
278 |  */
279 | static inline __must_check size_t array3_size(size_t a, size_t b, size_t c)
280 | {
281 | 	size_t bytes;
282 | 
283 | 	if (check_mul_overflow(a, b, &bytes))
284 | 		return SIZE_MAX;
285 | 	if (check_mul_overflow(bytes, c, &bytes))
286 | 		return SIZE_MAX;
287 | 
288 | 	return bytes;
289 | }
290 | 
291 | static inline __must_check size_t __ab_c_size(size_t n, size_t size, size_t c)
292 | {
293 | 	size_t bytes;
294 | 
295 | 	if (check_mul_overflow(n, size, &bytes))
296 | 		return SIZE_MAX;
297 | 	if (check_add_overflow(bytes, c, &bytes))
298 | 		return SIZE_MAX;
299 | 
300 | 	return bytes;
301 | }
302 | 
303 | /**
304 |  * struct_size() - Calculate size of structure with trailing array.
305 |  * @p: Pointer to the structure.
306 |  * @member: Name of the array member.
307 |  * @n: Number of elements in the array.
308 |  *
309 |  * Calculates size of memory needed for structure @p followed by an
310 |  * array of @n @member elements.
311 |  *
312 |  * Return: number of bytes needed or SIZE_MAX on overflow.
313 |  */
314 | #define struct_size(p, member, n)					\
315 | 	__ab_c_size(n,							\
316 | 		    sizeof(*(p)->member) + __must_be_array((p)->member),\
317 | 		    sizeof(*(p)))
318 | 
319 | #endif /* __LINUX_OVERFLOW_H */
320 | 


--------------------------------------------------------------------------------
/src/kcompat_rhel_defs.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _KCOMPAT_RHEL_DEFS_H_
  5 | #define _KCOMPAT_RHEL_DEFS_H_
  6 | 
  7 | /* This is the RedHat Enterprise Linux distribution specific definitions file.
  8 |  * It defines what features need backports for a given version of the RHEL
  9 |  * kernel.
 10 |  *
 11 |  * It checks the RHEL_RELEASE_CODE and RHEL_RELEASE_VERSION macros to decide
 12 |  * what support the target kernel has.
 13 |  *
 14 |  * It assumes that kcompat_std_defs.h has already been processed, and will
 15 |  * #define or #undef any flags that have changed based on backports done by
 16 |  * RHEL.
 17 |  */
 18 | 
 19 | #if !RHEL_RELEASE_CODE
 20 | #error "RHEL_RELEASE_CODE is 0 or undefined"
 21 | #endif
 22 | 
 23 | #ifndef RHEL_RELEASE_VERSION
 24 | #error "RHEL_RELEASE_VERSION is undefined"
 25 | #endif
 26 | 
 27 | /*****************************************************************************/
 28 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,3))
 29 | #define NEED_NETDEV_TXQ_BQL_PREFETCH
 30 | #else /* >= 7.3 */
 31 | #endif /* 7.3 */
 32 | 
 33 | /*****************************************************************************/
 34 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,4))
 35 | #define NEED_BUILD_BUG_ON
 36 | #else /* >= 7.4 */
 37 | #define HAVE_RHEL7_EXTENDED_OFFLOAD_STATS
 38 | #define HAVE_INCLUDE_BITFIELD
 39 | #endif /* 7.4 */
 40 | 
 41 | /*****************************************************************************/
 42 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,5))
 43 | #else /* >= 7.5 */
 44 | #define HAVE_TCF_EXTS_TO_LIST
 45 | #define HAVE_FLOW_DISSECTOR_KEY_IP
 46 | #endif /* 7.5 */
 47 | 
 48 | /*****************************************************************************/
 49 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,6))
 50 | #undef HAVE_XDP_BUFF_RXQ
 51 | #undef HAVE_XDP_RXQ_INFO_REG_3_PARAMS
 52 | #else /* >= 7.6 */
 53 | #undef NEED_JIFFIES_64_TIME_IS_MACROS
 54 | #undef NEED_TC_CLS_CAN_OFFLOAD_AND_CHAIN0
 55 | #undef NEED_TC_SETUP_QDISC_MQPRIO
 56 | #endif /* 7.6 */
 57 | 
 58 | /*****************************************************************************/
 59 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(7,7))
 60 | #else /* >= 7.7 */
 61 | #define HAVE_DEVLINK_PORT_ATTRS_SET_PORT_FLAVOUR
 62 | #define HAVE_ETHTOOL_NEW_100G_BITS
 63 | #undef NEED_NETDEV_TX_SENT_QUEUE
 64 | #undef NEED_IN_TASK
 65 | #define HAVE_FLOW_DISSECTOR_KEY_ENC_IP
 66 | #endif /* 7.7 */
 67 | 
 68 | /*****************************************************************************/
 69 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,0))
 70 | #else /* >= 8.0 */
 71 | #undef HAVE_TCF_EXTS_TO_LIST
 72 | #undef HAVE_ETHTOOL_NEW_100G_BITS
 73 | #define HAVE_NDO_OFFLOAD_STATS
 74 | #undef HAVE_RHEL7_EXTENDED_OFFLOAD_STATS
 75 | #define HAVE_TCF_EXTS_FOR_EACH_ACTION
 76 | /* 7.7 undefs it due to a backport in 7.7+, but 8.0 needs it still */
 77 | #define NEED_NETDEV_TX_SENT_QUEUE
 78 | #endif /* 8.0 */
 79 | 
 80 | /*****************************************************************************/
 81 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,1))
 82 | #define NEED_IDA_ALLOC_MIN_MAX_RANGE_FREE
 83 | #define NEED_FLOW_MATCH
 84 | #else /* >= 8.1 */
 85 | #define HAVE_ETHTOOL_NEW_100G_BITS
 86 | #undef NEED_IDA_ALLOC_MIN_MAX_RANGE_FREE
 87 | #undef NEED_FLOW_MATCH
 88 | #undef NEED_NETDEV_TX_SENT_QUEUE
 89 | #undef NEED_INDIRECT_CALL_WRAPPER_MACROS
 90 | #define HAVE_INDIRECT_CALL_WRAPPER_HEADER
 91 | #define HAVE_GRETAP_TYPE
 92 | #define HAVE_GENEVE_TYPE
 93 | #define HAVE_VXLAN_TYPE
 94 | #define HAVE_LINKMODE
 95 | #endif /* 8.1 */
 96 | 
 97 | /*****************************************************************************/
 98 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,2))
 99 | #else /* >= 8.2 */
100 | #undef NEED_DEVLINK_FLASH_UPDATE_STATUS_NOTIFY
101 | #undef NEED_SKB_FRAG_OFF
102 | #undef NEED_SKB_FRAG_OFF_ADD
103 | #undef NEED_FLOW_INDR_BLOCK_CB_REGISTER
104 | #define HAVE_FLOW_INDR_BLOCK_LOCK
105 | #define HAVE_DEVLINK_PORT_ATTRS_SET_SWITCH_ID
106 | #define HAVE_NETDEV_SB_DEV
107 | #endif /* 8.2 */
108 | 
109 | /*****************************************************************************/
110 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,3))
111 | #else /* >= 8.3 */
112 | #undef NEED_CPU_LATENCY_QOS_RENAME
113 | #undef NEED_DEVLINK_REGION_CREATE_OPS
114 | #endif /* 8.3 */
115 | 
116 | /*****************************************************************************/
117 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,4))
118 | #else /* >= 8.4 */
119 | #undef NEED_DEVLINK_PORT_ATTRS_SET_STRUCT
120 | #undef NEED_DEVLINK_FLASH_UPDATE_TIMEOUT_NOTIFY
121 | #undef HAVE_XDP_QUERY_PROG
122 | #define HAVE_AF_XDP_ZC_SUPPORT
123 | #define HAVE_MEM_TYPE_XSK_BUFF_POOL
124 | #define HAVE_NDO_XSK_WAKEUP
125 | #define XSK_UMEM_RETURNS_XDP_DESC
126 | #undef NEED_XSK_UMEM_GET_RX_FRAME_SIZE
127 | #define HAVE_ETHTOOL_COALESCE_PARAMS_SUPPORT
128 | #define HAVE_PTP_FIND_PIN_UNLOCKED
129 | #endif /* 8.4 */
130 | 
131 | /*****************************************************************************/
132 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,5))
133 | #else /* >= 8.5 */
134 | #undef HAVE_NAPI_BUSY_LOOP
135 | #undef HAVE_XDP_RXQ_INFO_REG_3_PARAMS
136 | #undef NEED_XSK_BUFF_DMA_SYNC_FOR_CPU
137 | #define NO_XDP_QUERY_XSK_UMEM
138 | #undef NEED_XSK_BUFF_POOL_RENAME
139 | #define HAVE_NETDEV_BPF_XSK_POOL
140 | #define HAVE_AF_XDP_NETDEV_UMEM
141 | #define HAVE_DEVLINK_OPS_CREATE_DEL
142 | #endif /* 8.5 */
143 | 
144 | /*****************************************************************************/
145 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,6))
146 | #else /* >= 8.6 */
147 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(9,0))
148 | #define HAVE_ETHTOOL_COALESCE_EXTACK
149 | #endif /* < 9.0 */
150 | #endif /* 8.6 */
151 | 
152 | /*****************************************************************************/
153 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(8,7))
154 | #else /* >= 8.7 */
155 | #undef NEED_DEVLINK_ALLOC_SETS_DEV
156 | #define HAVE_DEVLINK_SET_STATE_3_PARAM
157 | #endif /* 8.7 */
158 | 
159 | /*****************************************************************************/
160 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(9,0))
161 | #else /* >= 9.0 */
162 | #define HAVE_XDP_BUFF_RXQ
163 | #endif /* 9.0 */
164 | 
165 | /*****************************************************************************/
166 | #if (RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(9,1))
167 | #else /* >= 9.1 */
168 | #undef HAVE_PASID_SUPPORT
169 | #define HAVE_ETHTOOL_COALESCE_EXTACK
170 | #endif /* 9.1 */
171 | 
172 | /*****************************************************************************/
173 | #endif /* _KCOMPAT_RHEL_DEFS_H_ */
174 | 


--------------------------------------------------------------------------------
/src/kcompat_sles_defs.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _KCOMPAT_SLES_DEFS_H_
  5 | #define _KCOMPAT_SLES_DEFS_H_
  6 | 
  7 | /* This is the SUSE Linux Enterprise distribution specific definitions file.
  8 |  * It defines what features need backports for a given version of the SUSE
  9 |  * Linux Enterprise kernel.
 10 |  *
 11 |  * It checks a combination of the LINUX_VERSION code and the
 12 |  * SLE_LOCALVERSION_CODE to determine what support the kernel has.
 13 |  *
 14 |  * It assumes that kcompat_std_defs.h has already been processed, and will
 15 |  * #define or #undef any flags that have changed based on backports done by
 16 |  * SUSE.
 17 |  */
 18 | 
 19 | #ifndef LINUX_VERSION_CODE
 20 | #error "LINUX_VERSION_CODE is undefined"
 21 | #endif
 22 | 
 23 | #ifndef KERNEL_VERSION
 24 | #error "KERNEL_VERSION is undefined"
 25 | #endif
 26 | 
 27 | #if !SLE_KERNEL_REVISION
 28 | #error "SLE_KERNEL_REVISION is 0 or undefined"
 29 | #endif
 30 | 
 31 | #if SLE_KERNEL_REVISION > 65535
 32 | #error "SLE_KERNEL_REVISION is unexpectedly large"
 33 | #endif
 34 | 
 35 | /* SLE kernel versions are a combination of the LINUX_VERSION_CODE along with
 36 |  * an extra digit that indicates the SUSE specific revision of that kernel.
 37 |  * This value is found in the CONFIG_LOCALVERSION of the SUSE kernel, which is
 38 |  * extracted by common.mk and placed into SLE_KERNEL_REVISION_CODE.
 39 |  *
 40 |  * We combine the value of SLE_KERNEL_REVISION along with the LINUX_VERSION code
 41 |  * to generate the useful value that determines what specific kernel we're
 42 |  * dealing with.
 43 |  *
 44 |  * Just in case the SLE_KERNEL_REVISION ever goes above 255, we reserve 16 bits
 45 |  * instead of 8 for this value.
 46 |  */
 47 | #define SLE_KERNEL_CODE ((LINUX_VERSION_CODE << 16) + SLE_KERNEL_REVISION)
 48 | #define SLE_KERNEL_VERSION(a,b,c,d) ((KERNEL_VERSION(a,b,c) << 16) + (d))
 49 | 
 50 | /* Unlike RHEL, SUSE kernels are not always tied to a single service pack. For
 51 |  * example, 4.12.14 was used as the base for SLE 15 SP1, SLE 12 SP4, and SLE 12
 52 |  * SP5.
 53 |  *
 54 |  * You can find the patches that SUSE applied to the kernel tree at
 55 |  * https://github.com/SUSE/kernel-source.
 56 |  *
 57 |  * You can find the correct kernel version for a check by using steps similar
 58 |  * to the following
 59 |  *
 60 |  * 1) download the kernel-source repo
 61 |  * 2) checkout the relevant branch, i.e SLE15-SP3
 62 |  * 3) find the relevant backport you're interested in the patches.suse
 63 |  *    directory
 64 |  * 4) git log <patch file> to locate the commit that introduced the backport
 65 |  * 5) git describe --contains to find the relevant tag that includes that
 66 |  *    commit, i.e. rpm-5.3.18-37
 67 |  * 6) those digits represent the SLE kernel that introduced that backport.
 68 |  *
 69 |  * Try to keep the checks in SLE_KERNEL_CODE order and condense where
 70 |  * possible.
 71 |  */
 72 | 
 73 | /*****************************************************************************/
 74 | #if (SLE_KERNEL_CODE > SLE_KERNEL_VERSION(4,12,14,23) && \
 75 |      SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,94))
 76 | /*
 77 |  * 4.12.14 is used as the base for SLE 12 SP4, SLE 12 SP5, SLE 15, and SLE 15
 78 |  * SP1. Unfortunately the revision codes do not line up cleanly. SLE 15
 79 |  * launched with 4.12.14-23. It appears that SLE 12 SP4 and SLE 15 SP1 both
 80 |  * diverged from this point, with SLE 12 SP4 kernels starting around
 81 |  * 4.12.14-94. A few backports for SLE 15 SP1 landed in some alpha and beta
 82 |  * kernels tagged between 4.12.14-25 up to 4.12.14-32. These changes did not
 83 |  * make it into SLE 12 SP4. This was cleaned up with SLE 12 SP5 by an apparent
 84 |  * merge in 4.12.14-111. The official launch of SLE 15 SP1 ended up with
 85 |  * version 4.12.14-195.
 86 |  *
 87 |  * Because of this inconsistency and because all of these kernels appear to be
 88 |  * alpha or beta kernel releases for SLE 15 SP1, we do not rely on version
 89 |  * checks between this range. Issue a warning to indicate that we do not
 90 |  * support these.
 91 |  */
 92 | #warning "SLE kernel versions between 4.12.14-23 and 4.12.14-94 are not supported"
 93 | #endif
 94 | 
 95 | /*****************************************************************************/
 96 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,10))
 97 | #else /* >= 4.12.14-10 */
 98 | #undef NEED_INDIRECT_CALL_WRAPPER_MACROS
 99 | #define HAVE_INDIRECT_CALL_WRAPPER_HEADER
100 | #endif /* 4.12.14-10 */
101 | 
102 | /*****************************************************************************/
103 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,100))
104 | #else /* >= 4.12.14-100 */
105 | #undef HAVE_TCF_EXTS_TO_LIST
106 | #define HAVE_TCF_EXTS_FOR_EACH_ACTION
107 | #endif /* 4.12.14-100 */
108 | 
109 | /*****************************************************************************/
110 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,111))
111 | #define NEED_IDA_ALLOC_MIN_MAX_RANGE_FREE
112 | #else /* >= 4.12.14-111 */
113 | #define HAVE_DEVLINK_PORT_ATTRS_SET_PORT_FLAVOUR
114 | #undef NEED_MACVLAN_ACCEL_PRIV
115 | #undef NEED_MACVLAN_RELEASE_L2FW_OFFLOAD
116 | #undef NEED_MACVLAN_SUPPORTS_DEST_FILTER
117 | #undef NEED_IDA_ALLOC_MIN_MAX_RANGE_FREE
118 | #endif /* 4.12.14-111 */
119 | 
120 | /*****************************************************************************/
121 | /* SLES 12-SP5 base kernel version */
122 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,115))
123 | #else /* >= 4.12.14-115 */
124 | #define HAVE_NDO_SELECT_QUEUE_SB_DEV
125 | #define HAVE_TCF_MIRRED_DEV
126 | #define HAVE_TCF_BLOCK
127 | #define HAVE_TC_CB_AND_SETUP_QDISC_MQPRIO
128 | #define HAVE_TCF_BLOCK_CB_REGISTER_EXTACK
129 | #undef NEED_TC_SETUP_QDISC_MQPRIO
130 | #undef NEED_TC_CLS_CAN_OFFLOAD_AND_CHAIN0
131 | #undef NEED_NETDEV_TX_SENT_QUEUE
132 | #define HAVE_LINKMODE
133 | #endif /* 4.12.14-115 */
134 | 
135 | /*****************************************************************************/
136 | /* SLES 15-SP1 base */
137 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(4,12,14,195))
138 | #else /* >= 4.12.14-195 */
139 | #undef NEED_NETDEV_TX_SENT_QUEUE
140 | #endif /* 4.12.14-195 */
141 | 
142 | /*****************************************************************************/
143 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,3,8,2))
144 | #else /* >= 5.3.8-2 */
145 | #undef NEED_FLOW_INDR_BLOCK_CB_REGISTER
146 | #undef NEED_SKB_FRAG_OFF
147 | #undef NEED_SKB_FRAG_OFF_ADD
148 | #define HAVE_FLOW_INDR_BLOCK_LOCK
149 | #endif /* 5.3.8-2 */
150 | 
151 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,3,18,26))
152 | #else /* >= 5.3.18-26 */
153 | #undef NEED_CPU_LATENCY_QOS_RENAME
154 | #endif
155 | 
156 | /*****************************************************************************/
157 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,3,18,34))
158 | #else /* >= 5.3.18-34 */
159 | #undef NEED_DEVLINK_REGION_CREATE_OPS
160 | #undef NEED_DEVLINK_PORT_ATTRS_SET_STRUCT
161 | #endif /* 5.3.18-34 */
162 | 
163 | /*****************************************************************************/
164 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,3,18,38))
165 | #else /* >= 5.3.18-38 */
166 | #undef NEED_DEVLINK_FLASH_UPDATE_TIMEOUT_NOTIFY
167 | #endif /* 5.3.18-38 */
168 | 
169 | /*****************************************************************************/
170 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,3,18,41))
171 | #define NEED_XSK_BUFF_POOL_RENAME
172 | #else /* >= 5.3.18-41 */
173 | #define HAVE_XDP_BUFF_FRAME_SZ
174 | #define HAVE_NETDEV_BPF_XSK_POOL
175 | #undef NEED_XSK_UMEM_GET_RX_FRAME_SIZE
176 | #undef NEED_XSK_BUFF_POOL_RENAME
177 | #undef NEED_XSK_BUFF_DMA_SYNC_FOR_CPU
178 | #define HAVE_MEM_TYPE_XSK_BUFF_POOL
179 | #endif /* 5.3.18-41 */
180 | 
181 | /*****************************************************************************/
182 | #if (SLE_KERNEL_CODE < SLE_KERNEL_VERSION(5,14,21,9))
183 | #else /* >= 5.14.21-150400.9 */
184 | #undef NEED_DEVLINK_ALLOC_SETS_DEV
185 | #define HAVE_ETHTOOL_COALESCE_EXTACK
186 | #define HAVE_DEVLINK_OPS_CREATE_DEL
187 | #define HAVE_DEVLINK_SET_STATE_3_PARAM
188 | #endif /* 5.14.21-150400.9 */
189 | 
190 | #endif /* _KCOMPAT_SLES_DEFS_H_ */
191 | 


--------------------------------------------------------------------------------
/src/kcompat_std_defs.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _KCOMPAT_STD_DEFS_H_
  5 | #define _KCOMPAT_STD_DEFS_H_
  6 | 
  7 | /* This file contains the definitions for what kernel features need backports
  8 |  * for a given kernel. It targets only the standard stable kernel releases.
  9 |  * It must check only LINUX_VERSION_CODE and assume the kernel is a standard
 10 |  * release, and not a custom distribution.
 11 |  *
 12 |  * It must define HAVE_<FLAG> and NEED_<FLAG> for features. It must not
 13 |  * implement any backports, instead leaving the implementation to the
 14 |  * kcompat_impl.h header.
 15 |  *
 16 |  * If a feature can be easily implemented as a replacement macro or fully
 17 |  * backported, use a NEED_<FLAG> to indicate that the feature needs
 18 |  * a backport. (If NEED_<FLAG> is undefined, then no backport for that feature
 19 |  * is needed).
 20 |  *
 21 |  * If a feature cannot be easily implemented in kcompat directly, but
 22 |  * requires drivers to make specific changes such as stripping out an entire
 23 |  * feature or modifying a function pointer prototype, use a HAVE_<FLAG>.
 24 |  */
 25 | 
 26 | #ifndef LINUX_VERSION_CODE
 27 | #error "LINUX_VERSION_CODE is undefined"
 28 | #endif
 29 | 
 30 | #ifndef KERNEL_VERSION
 31 | #error "KERNEL_VERSION is undefined"
 32 | #endif
 33 | 
 34 | /*****************************************************************************/
 35 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,8,0))
 36 | #else /* >= 4,8,0 */
 37 | #define HAVE_TCF_EXTS_TO_LIST
 38 | #define HAVE_PCI_ALLOC_IRQ
 39 | #endif /* 4,8,0 */
 40 | 
 41 | /*****************************************************************************/
 42 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,9,0))
 43 | #define NEED_JIFFIES_64_TIME_IS_MACROS
 44 | #else /* >= 4,9,0 */
 45 | #define HAVE_KTHREAD_DELAYED_API
 46 | #define HAVE_NDO_OFFLOAD_STATS
 47 | #define HAVE_INCLUDE_BITFIELD
 48 | #endif /* 4,9,0 */
 49 | 
 50 | /*****************************************************************************/
 51 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,9,62))
 52 | #define NEED_IN_TASK
 53 | #else /* >= 4,9,62 */
 54 | #endif /* 4,9,62 */
 55 | 
 56 | /*****************************************************************************/
 57 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,12,0))
 58 | #else /* >= 4,12,0 */
 59 | #define HAVE_NAPI_BUSY_LOOP
 60 | #endif /* 4,12,0 */
 61 | 
 62 | /*****************************************************************************/
 63 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,13,0))
 64 | #else /* >= 4,13,0 */
 65 | #define HAVE_FLOW_DISSECTOR_KEY_IP
 66 | #endif /* 4,13,0 */
 67 | 
 68 | /*****************************************************************************/
 69 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,15,0))
 70 | #define NEED_TC_SETUP_QDISC_MQPRIO
 71 | #define NEED_NETDEV_XDP_STRUCT
 72 | #else /* >= 4,15,0 */
 73 | #define HAVE_TC_CB_AND_SETUP_QDISC_MQPRIO
 74 | #define HAVE_NDO_BPF
 75 | #endif /* 4,15,0 */
 76 | 
 77 | /*****************************************************************************/
 78 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,16,0))
 79 | #define NEED_TC_CLS_CAN_OFFLOAD_AND_CHAIN0
 80 | #else /* >= 4,16,0 */
 81 | #define HAVE_XDP_BUFF_RXQ
 82 | #define HAVE_XDP_RXQ_INFO_REG_3_PARAMS
 83 | #endif /* 4,16,0 */
 84 | 
 85 | /*****************************************************************************/
 86 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,17,0))
 87 | #define NEED_CONVERT_ART_NS_TO_TSC
 88 | #else /* >= 4,17,0 */
 89 | #endif /* 4,17,0 */
 90 | 
 91 | /*****************************************************************************/
 92 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,18,0))
 93 | #define NEED_MACVLAN_ACCEL_PRIV
 94 | #define NEED_MACVLAN_RELEASE_L2FW_OFFLOAD
 95 | #define NEED_MACVLAN_SUPPORTS_DEST_FILTER
 96 | #else /* >= 4,18,0 */
 97 | #define HAVE_DEVLINK_PORT_ATTRS_SET_PORT_FLAVOUR
 98 | #endif /* 4,18,0 */
 99 | 
100 | /*****************************************************************************/
101 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,19,0))
102 | #define NEED_IDA_ALLOC_MIN_MAX_RANGE_FREE
103 | #else /* >= 4,19,0 */
104 | #undef HAVE_TCF_EXTS_TO_LIST
105 | #define HAVE_TCF_EXTS_FOR_EACH_ACTION
106 | #define HAVE_TC_ETF_QOPT_OFFLOAD
107 | #define HAVE_FLOW_DISSECTOR_KEY_ENC_IP
108 | #endif /* 4,19,0 */
109 | 
110 | /*****************************************************************************/
111 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,20,0))
112 | #define NEED_NETDEV_TX_SENT_QUEUE
113 | #else /* >= 4.20.0 */
114 | #define HAVE_VXLAN_TYPE
115 | #define HAVE_LINKMODE
116 | #endif /* 4.20.0 */
117 | 
118 | /*****************************************************************************/
119 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,0,0))
120 | #define NEED_INDIRECT_CALL_WRAPPER_MACROS
121 | #else /* >= 5.0.0 */
122 | #define HAVE_GRETAP_TYPE
123 | #define HAVE_GENEVE_TYPE
124 | #define HAVE_INDIRECT_CALL_WRAPPER_HEADER
125 | #endif /* 5.0.0 */
126 | 
127 | /*****************************************************************************/
128 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,1,0))
129 | #define NEED_FLOW_MATCH
130 | #else /* >= 5.1.0 */
131 | #define HAVE_ETHTOOL_200G_BITS
132 | #define HAVE_ETHTOOL_NEW_100G_BITS
133 | #endif /* 5.1.0 */
134 | 
135 | /*****************************************************************************/
136 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,2,0))
137 | #else /* >= 5.2.0 */
138 | #define HAVE_DEVLINK_PORT_ATTRS_SET_SWITCH_ID
139 | #endif /* 5.2.0 */
140 | 
141 | /*****************************************************************************/
142 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,3,0))
143 | #define NEED_DEVLINK_FLASH_UPDATE_STATUS_NOTIFY
144 | #else /* >= 5.3.0 */
145 | #endif /* 5.3.0 */
146 | 
147 | /*****************************************************************************/
148 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,4,0))
149 | #define NEED_SKB_FRAG_OFF_ADD
150 | #define NEED_SKB_FRAG_OFF
151 | #if (LINUX_VERSION_CODE > KERNEL_VERSION(4,14,241) && \
152 |      LINUX_VERSION_CODE < KERNEL_VERSION(4,15,0))
153 | #undef NEED_SKB_FRAG_OFF
154 | #endif /* > 4.14.241 && < 4.15.0 */
155 | #if (LINUX_VERSION_CODE > KERNEL_VERSION(4,19,200) && \
156 |      LINUX_VERSION_CODE < KERNEL_VERSION(4,20,0))
157 | #undef NEED_SKB_FRAG_OFF
158 | #endif /* > 4.19.200 && < 4.20.0 */
159 | 
160 | #define NEED_FLOW_INDR_BLOCK_CB_REGISTER
161 | #else /* >= 5.4.0 */
162 | #define HAVE_FLOW_INDR_BLOCK_LOCK
163 | #define HAVE_XSK_UNALIGNED_CHUNK_PLACEMENT
164 | #endif /* 5.4.0 */
165 | 
166 | /*****************************************************************************/
167 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,7,0))
168 | #define NEED_DEVLINK_REGION_CREATE_OPS
169 | #define NEED_CPU_LATENCY_QOS_RENAME
170 | #else /* >= 5.7.0 */
171 | #define HAVE_PTP_FIND_PIN_UNLOCKED
172 | #endif /* 5.7.0 */
173 | 
174 | /*****************************************************************************/
175 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,8,0))
176 | #define NEED_XSK_UMEM_GET_RX_FRAME_SIZE
177 | #else /* >= 5.8.0 */
178 | #undef HAVE_XSK_UNALIGNED_CHUNK_PLACEMENT
179 | #endif /* 5.8.0 */
180 | 
181 | /*****************************************************************************/
182 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,9,0))
183 | #define NEED_DEVLINK_PORT_ATTRS_SET_STRUCT
184 | #define HAVE_XDP_QUERY_PROG
185 | #define NEED_INDIRECT_CALL_3_AND_4
186 | #else /* >= 5.9.0 */
187 | #define HAVE_TASKLET_SETUP
188 | #endif /* 5.9.0 */
189 | 
190 | /*****************************************************************************/
191 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0))
192 | #define NEED_DEVLINK_FLASH_UPDATE_TIMEOUT_NOTIFY
193 | #define NEED_XSK_BUFF_DMA_SYNC_FOR_CPU
194 | #define NEED_XSK_BUFF_POOL_RENAME
195 | #else /* >= 5.10.0 */
196 | #define HAVE_UDP_TUNNEL_NIC_SHARED
197 | #define HAVE_NETDEV_BPF_XSK_POOL
198 | #endif /* 5.10.0 */
199 | 
200 | /*****************************************************************************/
201 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,11,0))
202 | #else /* >= 5.11.0 */
203 | #define HAVE_XSK_BATCHED_DESCRIPTOR_INTERFACES
204 | #define HAVE_PASID_SUPPORT
205 | #undef HAVE_XDP_RXQ_INFO_REG_3_PARAMS
206 | #define HAVE_XSK_TX_PEEK_RELEASE_DESC_BATCH_3_PARAMS
207 | #endif /* 5.11.0 */
208 | 
209 | /*****************************************************************************/
210 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,12,0))
211 | #define NEED_EXPORT_INDIRECT_CALLABLE
212 | #else /* >= 5.12.0 */
213 | #define HAVE_DEVLINK_OPS_CREATE_DEL
214 | #endif /* 5.12.0 */
215 | 
216 | /*****************************************************************************/
217 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,13,0))
218 | /* HAVE_KOBJ_IN_MDEV_PARENT_OPS_CREATE
219 |  *
220 |  * create api changed as part of the commit c2ef2f50ad0c( vfio/mdev: Remove
221 |  * kobj from mdev_parent_ops->create())
222 |  *
223 |  * if flag is defined use the old API else new API
224 |  */
225 | #define HAVE_KOBJ_IN_MDEV_PARENT_OPS_CREATE
226 | #define HAVE_DEV_IN_MDEV_API
227 | #else /* >= 5.13.0 */
228 | #define HAVE_XPS_MAP_TYPE
229 | #endif /* 5.13.0 */
230 | 
231 | /*****************************************************************************/
232 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0))
233 | #else /* >= 5.14.0 */
234 | #define HAVE_TTY_WRITE_ROOM_UINT
235 | #endif /* 5.14.0 */
236 | 
237 | /*****************************************************************************/
238 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,15,0))
239 | #define NEED_DEVLINK_ALLOC_SETS_DEV
240 | #else /* >= 5.15.0 */
241 | #define HAVE_ETHTOOL_COALESCE_EXTACK
242 | #define HAVE_DEVICE_IN_MDEV_PARENT_OPS
243 | #define NEED_PCI_IOV_VF_ID
244 | #define HAVE_DEVLINK_SET_STATE_3_PARAM
245 | #endif /* 5.15.0 */
246 | 
247 | /*****************************************************************************/
248 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0))
249 | #else /* >= 5.16.0 */
250 | #undef HAVE_PASID_SUPPORT
251 | #define HAVE_XSK_BATCHED_RX_ALLOC
252 | #endif /* 5.16.0 */
253 | 
254 | /*****************************************************************************/
255 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(5,18,0))
256 | #else /* >=5.18.0*/
257 | #undef NEED_PCI_IOV_VF_ID
258 | #define HAVE_GTP_SUPPORT
259 | #undef HAVE_XSK_TX_PEEK_RELEASE_DESC_BATCH_3_PARAMS
260 | #endif /* 5.18.0 */
261 | 
262 | /*****************************************************************************/
263 | #if (LINUX_VERSION_CODE < KERNEL_VERSION(6,1,0))
264 | #else /* >=6.1.0 */
265 | #define HAVE_FLOW_DISSECTOR_KEY_L2TPV3
266 | #define HAVE_TTY_TERMIOS_CONST_STRUCT
267 | #endif /* 6.1.0 */
268 | 
269 | #endif /* _KCOMPAT_STD_DEFS_H_ */
270 | 


--------------------------------------------------------------------------------
/src/kcompat_ubuntu_defs.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _KCOMPAT_UBUNTU_DEFS_H_
 5 | #define _KCOMPAT_UBUNTU_DEFS_H_
 6 | 
 7 | /* This file contains the definitions for the Ubuntu specific distribution of
 8 |  * the Linux kernel.
 9 |  *
10 |  * It checks the UBUNTU_VERSION_CODE to decide which features are available in
11 |  * the target kernel. It assumes that kcompat_std_defs.h has already been
12 |  * processed, and will #define or #undef the relevant flags based on what
13 |  * features were backported by Ubuntu.
14 |  */
15 | 
16 | #if !UTS_UBUNTU_RELEASE_ABI
17 | #error "UTS_UBUNTU_RELEASE_ABI is 0 or undefined"
18 | #endif
19 | 
20 | #if !UBUNTU_VERSION_CODE
21 | #error "UBUNTU_VERSION_CODE is 0 or undefined"
22 | #endif
23 | 
24 | #ifndef UBUNTU_VERSION
25 | #error "UBUNTU_VERSION is undefined"
26 | #endif
27 | 
28 | /*****************************************************************************/
29 | #if (UBUNTU_VERSION_CODE >= UBUNTU_VERSION(4,15,0,159) && \
30 |      UBUNTU_VERSION_CODE < UBUNTU_VERSION(4,15,0,999))
31 | #undef NEED_SKB_FRAG_OFF
32 | #endif
33 | 
34 | /*****************************************************************************/
35 | #endif /* _KCOMPAT_UBUNTU_DEFS_H_ */
36 | 


--------------------------------------------------------------------------------
/src/kcompat_vfd.h:
--------------------------------------------------------------------------------
  1 | /* SPDX-License-Identifier: GPL-2.0-only */
  2 | /* Copyright (C) 2013-2023 Intel Corporation */
  3 | 
  4 | #ifndef _KCOMPAT_VFD_H_
  5 | #define _KCOMPAT_VFD_H_
  6 | 
  7 | #define VFD_PROMISC_OFF		0x00
  8 | #define VFD_PROMISC_UNICAST	0x01
  9 | #define VFD_PROMISC_MULTICAST	0x02
 10 | 
 11 | #define VFD_LINKSTATE_OFF	0x00
 12 | #define VFD_LINKSTATE_ON	0x01
 13 | #define VFD_LINKSTATE_AUTO	0x02
 14 | 
 15 | #define VFD_EGRESS_MIRROR_OFF	-1
 16 | #define VFD_INGRESS_MIRROR_OFF	-1
 17 | 
 18 | #define VFD_QUEUE_TYPE_RSS	0x00
 19 | #define VFD_QUEUE_TYPE_QOS	0x01
 20 | 
 21 | #define VFD_NUM_TC		0x8
 22 | 
 23 | /**
 24 |  * struct vfd_objects - VF-d kobjects information struct
 25 |  * @num_vfs:	number of VFs allocated
 26 |  * @sriov_kobj:	pointer to the top sriov kobject
 27 |  * @vf_kobj:	array of pointer to each VF's kobjects
 28 |  */
 29 | struct vfd_objects {
 30 | 	int num_vfs;
 31 | 	struct kobject *sriov_kobj;
 32 | 	struct vfd_vf_obj *vfs;
 33 | 	struct vfd_qos_objects *qos;
 34 | };
 35 | 
 36 | /**
 37 |  * struct vfd_vf_obj - VF-d VF kobjects information struct
 38 |  * @vf_kobj:		pointer to VF qos kobject
 39 |  * @vf_qos_kobj:	pointer to VF kobject
 40 |  * @vf_tc_kobj:		pointer to VF TC kobjects
 41 |  */
 42 | struct vfd_vf_obj {
 43 | 	struct kobject *vf_qos_kobj;
 44 | 	struct kobject *vf_kobj;
 45 | 	struct kobject *vf_tc_kobjs[VFD_NUM_TC];
 46 | };
 47 | 
 48 | /**
 49 |  * struct vfd_qos_objects - VF-d qos kobjects information struct
 50 |  * @qos_kobj:		pointer to PF qos kobject
 51 |  * @pf_qos_kobj:	pointer to PF TC kobjects
 52 |  */
 53 | struct vfd_qos_objects {
 54 | 	struct kobject *qos_kobj;
 55 | 	struct kobject *pf_qos_kobjs[VFD_NUM_TC];
 56 | };
 57 | 
 58 | struct vfd_macaddr {
 59 | 	u8 mac[ETH_ALEN];
 60 | 	struct list_head list;
 61 | };
 62 | 
 63 | #define VFD_LINK_SPEED_2_5GB_SHIFT		0x0
 64 | #define VFD_LINK_SPEED_100MB_SHIFT		0x1
 65 | #define VFD_LINK_SPEED_1GB_SHIFT		0x2
 66 | #define VFD_LINK_SPEED_10GB_SHIFT		0x3
 67 | #define VFD_LINK_SPEED_40GB_SHIFT		0x4
 68 | #define VFD_LINK_SPEED_20GB_SHIFT		0x5
 69 | #define VFD_LINK_SPEED_25GB_SHIFT		0x6
 70 | #define VFD_LINK_SPEED_5GB_SHIFT		0x7
 71 | 
 72 | 
 73 | enum vfd_link_speed {
 74 | 	VFD_LINK_SPEED_UNKNOWN	= 0,
 75 | 	VFD_LINK_SPEED_100MB	= BIT(VFD_LINK_SPEED_100MB_SHIFT),
 76 | 	VFD_LINK_SPEED_1GB	= BIT(VFD_LINK_SPEED_1GB_SHIFT),
 77 | 	VFD_LINK_SPEED_2_5GB	= BIT(VFD_LINK_SPEED_2_5GB_SHIFT),
 78 | 	VFD_LINK_SPEED_5GB	= BIT(VFD_LINK_SPEED_5GB_SHIFT),
 79 | 	VFD_LINK_SPEED_10GB	= BIT(VFD_LINK_SPEED_10GB_SHIFT),
 80 | 	VFD_LINK_SPEED_40GB	= BIT(VFD_LINK_SPEED_40GB_SHIFT),
 81 | 	VFD_LINK_SPEED_20GB	= BIT(VFD_LINK_SPEED_20GB_SHIFT),
 82 | 	VFD_LINK_SPEED_25GB	= BIT(VFD_LINK_SPEED_25GB_SHIFT),
 83 | };
 84 | 
 85 | struct vfd_ops {
 86 | 	int (*get_trunk)(struct pci_dev *pdev, int vf_id, unsigned long *buff);
 87 | 	int (*set_trunk)(struct pci_dev *pdev, int vf_id,
 88 | 			 const unsigned long *buff);
 89 | 	int (*get_vlan_mirror)(struct pci_dev *pdev, int vf_id,
 90 | 			       unsigned long *buff);
 91 | 	int (*set_vlan_mirror)(struct pci_dev *pdev, int vf_id,
 92 | 			       const unsigned long *buff);
 93 | 	int (*get_egress_mirror)(struct pci_dev *pdev, int vf_id, int *data);
 94 | 	int (*set_egress_mirror)(struct pci_dev *pdev, int vf_id,
 95 | 				 const int data);
 96 | 	int (*get_ingress_mirror)(struct pci_dev *pdev, int vf_id, int *data);
 97 | 	int (*set_ingress_mirror)(struct pci_dev *pdev, int vf_id,
 98 | 				  const int data);
 99 | 	int (*get_mac_anti_spoof)(struct pci_dev *pdev, int vf_id, bool *data);
100 | 	int (*set_mac_anti_spoof)(struct pci_dev *pdev, int vf_id,
101 | 				  const bool data);
102 | 	int (*get_vlan_anti_spoof)(struct pci_dev *pdev, int vf_id, bool *data);
103 | 	int (*set_vlan_anti_spoof)(struct pci_dev *pdev, int vf_id,
104 | 				   const bool data);
105 | 	int (*get_allow_untagged)(struct pci_dev *pdev, int vf_id, bool *data);
106 | 	int (*set_allow_untagged)(struct pci_dev *pdev, int vf_id,
107 | 				  const bool data);
108 | 	int (*get_loopback)(struct pci_dev *pdev, int vf_id, bool *data);
109 | 	int (*set_loopback)(struct pci_dev *pdev, int vf_id, const bool data);
110 | 	int (*get_mac)(struct pci_dev *pdev, int vf_id, u8 *macaddr);
111 | 	int (*set_mac)(struct pci_dev *pdev, int vf_id, const u8 *macaddr);
112 | 	int (*get_mac_list)(struct pci_dev *pdev, int vf_id,
113 | 			    struct list_head *mac_list);
114 | 	int (*add_macs_to_list)(struct pci_dev *pdev, int vf_id,
115 | 				struct list_head *mac_list);
116 | 	int (*rem_macs_from_list)(struct pci_dev *pdev, int vf_id,
117 | 				  struct list_head *mac_list);
118 | 	int (*get_promisc)(struct pci_dev *pdev, int vf_id, u8 *data);
119 | 	int (*set_promisc)(struct pci_dev *pdev, int vf_id, const u8 data);
120 | 	int (*get_vlan_strip)(struct pci_dev *pdev, int vf_id, bool *data);
121 | 	int (*set_vlan_strip)(struct pci_dev *pdev, int vf_id, const bool data);
122 | 	int (*get_link_state)(struct pci_dev *pdev, int vf_id, bool *enabled,
123 | 			      enum vfd_link_speed *link_speed);
124 | 	int (*set_link_state)(struct pci_dev *pdev, int vf_id, const u8 data);
125 | 	int (*get_max_tx_rate)(struct pci_dev *pdev, int vf_id,
126 | 			       unsigned int *max_tx_rate);
127 | 	int (*set_max_tx_rate)(struct pci_dev *pdev, int vf_id,
128 | 			       unsigned int *max_tx_rate);
129 | 	int (*get_min_tx_rate)(struct kobject *,
130 | 			       struct kobj_attribute *, char *);
131 | 	int (*set_min_tx_rate)(struct kobject *, struct kobj_attribute *,
132 | 			       const char *, size_t);
133 | 	int (*get_spoofcheck)(struct kobject *,
134 | 			      struct kobj_attribute *, char *);
135 | 	int (*set_spoofcheck)(struct kobject *, struct kobj_attribute *,
136 | 			      const char *, size_t);
137 | 	int (*get_trust)(struct kobject *,
138 | 			 struct kobj_attribute *, char *);
139 | 	int (*set_trust)(struct kobject *, struct kobj_attribute *,
140 | 			 const char *, size_t);
141 | 	int (*get_vf_enable)(struct pci_dev *pdev, int vf_id, bool *data);
142 | 	int (*set_vf_enable)(struct pci_dev *pdev, int vf_id, const bool data);
143 | 	int (*get_rx_bytes)  (struct pci_dev *pdev, int vf_id, u64 *data);
144 | 	int (*get_rx_dropped)(struct pci_dev *pdev, int vf_id, u64 *data);
145 | 	int (*get_rx_packets)(struct pci_dev *pdev, int vf_id, u64 *data);
146 | 	int (*get_tx_bytes)  (struct pci_dev *pdev, int vf_id, u64 *data);
147 | 	int (*get_tx_dropped)(struct pci_dev *pdev, int vf_id, u64 *data);
148 | 	int (*get_tx_packets)(struct pci_dev *pdev, int vf_id, u64 *data);
149 | 	int (*get_tx_spoofed)(struct pci_dev *pdev, int vf_id, u64 *data);
150 | 	int (*get_tx_errors)(struct pci_dev *pdev, int vf_id, u64 *data);
151 | 	int (*reset_stats)(struct pci_dev *pdev, int vf_id);
152 | 	int (*set_vf_bw_share)(struct pci_dev *pdev, int vf_id, u8 bw_share);
153 | 	int (*get_vf_bw_share)(struct pci_dev *pdev, int vf_id, u8 *bw_share);
154 | 	int (*set_pf_qos_apply)(struct pci_dev *pdev);
155 | 	int (*get_pf_ingress_mirror)(struct pci_dev *pdev, int *data);
156 | 	int (*set_pf_ingress_mirror)(struct pci_dev *pdev, const int data);
157 | 	int (*get_pf_egress_mirror)(struct pci_dev *pdev, int *data);
158 | 	int (*set_pf_egress_mirror)(struct pci_dev *pdev, const int data);
159 | 	int (*get_pf_tpid)(struct pci_dev *pdev, u16 *data);
160 | 	int (*set_pf_tpid)(struct pci_dev *pdev, const u16 data);
161 | 	int (*get_num_queues)(struct pci_dev *pdev, int vf_id, int *num_queues);
162 | 	int (*set_num_queues)(struct pci_dev *pdev, int vf_id, const int num_queues);
163 | 	int (*get_trust_state)(struct pci_dev *pdev, int vf_id, bool *data);
164 | 	int (*set_trust_state)(struct pci_dev *pdev, int vf_id, bool data);
165 | 	int (*get_queue_type)(struct pci_dev *pdev, int vf_id, u8 *data);
166 | 	int (*set_queue_type)(struct pci_dev *pdev, int vf_id, const u8 data);
167 | 	int (*get_allow_bcast)(struct pci_dev *pdev, int vf_id, bool *data);
168 | 	int (*set_allow_bcast)(struct pci_dev *pdev, int vf_id, const bool data);
169 | 	int (*get_pf_qos_tc_max_bw)(struct pci_dev *pdev, int tc, u16 *req_bw);
170 | 	int (*set_pf_qos_tc_max_bw)(struct pci_dev *pdev, int tc, u16 req_bw);
171 | 	int (*get_pf_qos_tc_lsp)(struct pci_dev *pdev, int tc, bool *on);
172 | 	int (*set_pf_qos_tc_lsp)(struct pci_dev *pdev, int tc, bool on);
173 | 	int (*get_pf_qos_tc_priority)(struct pci_dev *pdev, int tc,
174 | 				      char *tc_bitmap);
175 | 	int (*set_pf_qos_tc_priority)(struct pci_dev *pdev, int tc,
176 | 				      char tc_bitmap);
177 | 	int (*get_vf_qos_tc_share)(struct pci_dev *pdev, int vf_id, int tc,
178 | 				   u8 *share);
179 | 	int (*set_vf_qos_tc_share)(struct pci_dev *pdev, int vf_id, int tc,
180 | 				   u8 share);
181 | 	int (*get_vf_max_tc_tx_rate)(struct pci_dev *pdev, int vf_id, int tc,
182 | 				     int *rate);
183 | 	int (*set_vf_max_tc_tx_rate)(struct pci_dev *pdev, int vf_id, int tc,
184 | 				     int rate);
185 | };
186 | 
187 | extern const struct vfd_ops *vfd_ops;
188 | 
189 | #endif /* _KCOMPAT_VFD_H_ */
190 | 


--------------------------------------------------------------------------------
/src/linux/auxiliary_bus.h:
--------------------------------------------------------------------------------
 1 | /* SPDX-License-Identifier: GPL-2.0-only */
 2 | /* Copyright (C) 2013-2023 Intel Corporation */
 3 | 
 4 | #ifndef _AUXILIARY_BUS_H_
 5 | #define _AUXILIARY_BUS_H_
 6 | 
 7 | /* The CRC of the exported symbols which depend on 'struct device' can change
 8 |  * if the definition of 'struct dev_pm_qos' is not included in this file, i.e.
 9 |  * if we don't include this file.
10 |  */
11 | #include <linux/pm_qos.h>
12 | #include <linux/device.h>
13 | #include <linux/mod_devicetable.h>
14 | 
15 | #define AUXILIARY_NAME_SIZE 38
16 | #define AUXILIARY_MODULE_PREFIX "intel_auxiliary:"
17 | 
18 | #define AUX_PREFIX(func) intel_ ## func
19 | 
20 | #define auxiliary_device_init AUX_PREFIX(auxiliary_device_init)
21 | #define __auxiliary_device_add AUX_PREFIX(__auxiliary_device_add)
22 | #define auxiliary_find_device AUX_PREFIX(auxiliary_find_device)
23 | #define __auxiliary_driver_register AUX_PREFIX(__auxiliary_driver_register)
24 | #define auxiliary_driver_unregister AUX_PREFIX(auxiliary_driver_unregister)
25 | 
26 | struct auxiliary_device_id {
27 | 	char name[AUXILIARY_NAME_SIZE];
28 | 	kernel_ulong_t driver_data;
29 | };
30 | 
31 | struct auxiliary_device {
32 | 	struct device dev;
33 | 	const char *name;
34 | 	u32 id;
35 | };
36 | 
37 | struct auxiliary_driver {
38 | 	int (*probe)(struct auxiliary_device *auxdev, const struct auxiliary_device_id *id);
39 | 	void (*remove)(struct auxiliary_device *auxdev);
40 | 	void (*shutdown)(struct auxiliary_device *auxdev);
41 | 	int (*suspend)(struct auxiliary_device *auxdev, pm_message_t state);
42 | 	int (*resume)(struct auxiliary_device *auxdev);
43 | 	const char *name;
44 | 	struct device_driver driver;
45 | 	const struct auxiliary_device_id *id_table;
46 | };
47 | 
48 | static inline struct auxiliary_device *to_auxiliary_dev(struct device *dev)
49 | {
50 | 	return container_of(dev, struct auxiliary_device, dev);
51 | }
52 | 
53 | static inline struct auxiliary_driver *to_auxiliary_drv(struct device_driver *drv)
54 | {
55 | 	return container_of(drv, struct auxiliary_driver, driver);
56 | }
57 | 
58 | int auxiliary_device_init(struct auxiliary_device *auxdev);
59 | int __auxiliary_device_add(struct auxiliary_device *auxdev, const char *modname);
60 | #define auxiliary_device_add(auxdev) __auxiliary_device_add(auxdev, KBUILD_MODNAME)
61 | 
62 | static inline void auxiliary_device_uninit(struct auxiliary_device *auxdev)
63 | {
64 | 	put_device(&auxdev->dev);
65 | }
66 | 
67 | static inline void auxiliary_device_delete(struct auxiliary_device *auxdev)
68 | {
69 | 	device_del(&auxdev->dev);
70 | }
71 | 
72 | int __auxiliary_driver_register(struct auxiliary_driver *auxdrv, struct module *owner,
73 | 				const char *modname);
74 | #define auxiliary_driver_register(auxdrv) \
75 | 	__auxiliary_driver_register(auxdrv, THIS_MODULE, KBUILD_MODNAME)
76 | 
77 | void auxiliary_driver_unregister(struct auxiliary_driver *auxdrv);
78 | 
79 | /**
80 |  * module_auxiliary_driver() - Helper macro for registering an auxiliary driver
81 |  * @__auxiliary_driver: auxiliary driver struct
82 |  *
83 |  * Helper macro for auxiliary drivers which do not do anything special in
84 |  * module init/exit. This eliminates a lot of boilerplate. Each module may only
85 |  * use this macro once, and calling it replaces module_init() and module_exit()
86 |  */
87 | #define module_auxiliary_driver(__auxiliary_driver) \
88 | 	module_driver(__auxiliary_driver, auxiliary_driver_register, auxiliary_driver_unregister)
89 | 
90 | struct auxiliary_device *auxiliary_find_device(struct device *start,
91 | 					       const void *data,
92 | 					       int (*match)(struct device *dev, const void *data));
93 | 
94 | #endif /* _AUXILIARY_BUS_H_ */
95 | 


--------------------------------------------------------------------------------