mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2025-01-03 19:55:31 +00:00
Networking fixes for 5.11-rc3, including fixes from netfilter, wireless
and bpf trees.
Current release - regressions:
- mt76: - usb: fix NULL pointer dereference in mt76u_status_worker
- sdio: fix NULL pointer dereference in mt76s_process_tx_queue
- net: ipa: fix interconnect enable bug
Current release - always broken:
- netfilter: ipset: fixes possible oops in mtype_resize
- ath11k: fix number of coding issues found by static analysis tools
and spurious error messages
Previous releases - regressions:
- e1000e: re-enable s0ix power saving flows for systems with
the Intel i219-LM Ethernet controllers to fix power
use regression
- virtio_net: fix recursive call to cpus_read_lock() to avoid
a deadlock
- ipv4: ignore ECN bits for fib lookups in fib_compute_spec_dst()
- net-sysfs: take the rtnl lock around XPS configuration
- xsk: - fix memory leak for failed bind
- rollback reservation at NETDEV_TX_BUSY
- r8169: work around power-saving bug on some chip versions
Previous releases - always broken:
- dcb: validate netlink message in DCB handler
- tun: fix return value when the number of iovs exceeds MAX_SKB_FRAGS
to prevent unnecessary retries
- vhost_net: fix ubuf refcount when sendmsg fails
- bpf: save correct stopping point in file seq iteration
- ncsi: use real net-device for response handler
- neighbor: fix div by zero caused by a data race (TOCTOU)
- bareudp: - fix use of incorrect min_headroom size
- fix false positive lockdep splat from the TX lock
- net: mvpp2: - clear force link UP during port init procedure
in case bootloader had set it
- add TCAM entry to drop flow control pause frames
- fix PPPoE with ipv6 packet parsing
- fix GoP Networking Complex Control config of port 3
- fix pkt coalescing IRQ-threshold configuration
- xsk: fix race in SKB mode transmit with shared cq
- ionic: account for vlan tag len in rx buffer len
- net: stmmac: ignore the second clock input, current clock framework
does not handle exclusive clock use well, other drivers
may reconfigure the second clock
Misc:
- ppp: change PPPIOCUNBRIDGECHAN ioctl request number to follow
existing scheme
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEE6jPA+I1ugmIBA4hXMUZtbf5SIrsFAl/zsqQACgkQMUZtbf5S
IrvfqA/+MbjN9TRccZRgYVzPVzlP5jswi7VZIjikPrNxCdwgQd8bDMfeaD6I1PcX
WHf35vtD8zh729qz9DheWXFp7kDQ1fY0Z59KA25xf/ulFEkZPl3RBg70rSgv4rc+
T82dVo6x33DPe6NkspDC+Uhjz2IxcS/P7F9N7DtbavrfNuDyX8+0U/FFQIL0xOyG
DuhwecCh0vJFGcWXTWtK1vP1CPD98L28KS2Od+EZsUUZOKt1WMyGrAgNcT6uYXmO
NIYNy+FPyvvIwTLupoFE7oU4LA0sZozyvzcTDugXBF5EKoR8BwBFk0FfWzN9Oxge
LrmhNBSTeYyiw8XMOwSIfxwZnBm7mJFQqTHR1+Y83Qw1SR6PfSUZgkEkW2SYgprL
9CzE3O3P3Ci7TSx7fvZUn8B1q5J0DfZR6ZYyor9zl55e+ikraRYtXsk47bf9AGXl
owpHXEYWHFmgOP+LVdf1BUjuiE3vnCBJBsHlMbRkxiNPKravWtPSiM2yTu6fEbpT
pMXCgFQBL/IqwzX01zuw7teg40YLVaFnmFdQbYDwA5p9VODlQvHzn2K4GyuktswX
wxHYU5WRWtCkBfE+nbAROKzE7MuH9jtPtV1ZeuseTqYGBRuvEvudX8ypEvKS45pP
OWkzFsSXd9q7M6cxftipwjcyLiIO+UGdizNHvDUyEQOPAyYPKb4=
=N4/x
-----END PGP SIGNATURE-----
Merge tag 'net-5.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
Pull networking fixes from Jakub Kicinski:
"Networking fixes, including fixes from netfilter, wireless and bpf
trees.
Current release - regressions:
- mt76: fix NULL pointer dereference in mt76u_status_worker and
mt76s_process_tx_queue
- net: ipa: fix interconnect enable bug
Current release - always broken:
- netfilter: fixes possible oops in mtype_resize in ipset
- ath11k: fix number of coding issues found by static analysis tools
and spurious error messages
Previous releases - regressions:
- e1000e: re-enable s0ix power saving flows for systems with the
Intel i219-LM Ethernet controllers to fix power use regression
- virtio_net: fix recursive call to cpus_read_lock() to avoid a
deadlock
- ipv4: ignore ECN bits for fib lookups in fib_compute_spec_dst()
- sysfs: take the rtnl lock around XPS configuration
- xsk: fix memory leak for failed bind and rollback reservation at
NETDEV_TX_BUSY
- r8169: work around power-saving bug on some chip versions
Previous releases - always broken:
- dcb: validate netlink message in DCB handler
- tun: fix return value when the number of iovs exceeds MAX_SKB_FRAGS
to prevent unnecessary retries
- vhost_net: fix ubuf refcount when sendmsg fails
- bpf: save correct stopping point in file seq iteration
- ncsi: use real net-device for response handler
- neighbor: fix div by zero caused by a data race (TOCTOU)
- bareudp: fix use of incorrect min_headroom size and a false
positive lockdep splat from the TX lock
- mvpp2:
- clear force link UP during port init procedure in case
bootloader had set it
- add TCAM entry to drop flow control pause frames
- fix PPPoE with ipv6 packet parsing
- fix GoP Networking Complex Control config of port 3
- fix pkt coalescing IRQ-threshold configuration
- xsk: fix race in SKB mode transmit with shared cq
- ionic: account for vlan tag len in rx buffer len
- stmmac: ignore the second clock input, current clock framework does
not handle exclusive clock use well, other drivers may reconfigure
the second clock
Misc:
- ppp: change PPPIOCUNBRIDGECHAN ioctl request number to follow
existing scheme"
* tag 'net-5.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (99 commits)
net: dsa: lantiq_gswip: Fix GSWIP_MII_CFG(p) register access
net: dsa: lantiq_gswip: Enable GSWIP_MII_CFG_EN also for internal PHYs
net: lapb: Decrease the refcount of "struct lapb_cb" in lapb_device_event
r8169: work around power-saving bug on some chip versions
net: usb: qmi_wwan: add Quectel EM160R-GL
selftests: mlxsw: Set headroom size of correct port
net: macb: Correct usage of MACB_CAPS_CLK_HW_CHG flag
ibmvnic: fix: NULL pointer dereference.
docs: networking: packet_mmap: fix old config reference
docs: networking: packet_mmap: fix formatting for C macros
vhost_net: fix ubuf refcount incorrectly when sendmsg fails
bareudp: Fix use of incorrect min_headroom size
bareudp: set NETIF_F_LLTX flag
net: hdlc_ppp: Fix issues when mod_timer is called while timer is running
atlantic: remove architecture depends
erspan: fix version 1 check in gre_parse_header()
net: hns: fix return value check in __lb_other_process()
net: sched: prevent invalid Scell_log shift count
net: neighbor: fix a crash caused by mod zero
ipv4: Ignore ECN bits for fib lookups in fib_compute_spec_dst()
...
This commit is contained in:
Linus Torvalds
commit
aa35e45cd4
@ -6,9 +6,9 @@
|
||||
netdev FAQ
|
||||
==========
|
||||
|
||||
Q: What is netdev?
|
||||
------------------
|
||||
A: It is a mailing list for all network-related Linux stuff. This
|
||||
What is netdev?
|
||||
---------------
|
||||
It is a mailing list for all network-related Linux stuff. This
|
||||
includes anything found under net/ (i.e. core code like IPv6) and
|
||||
drivers/net (i.e. hardware specific drivers) in the Linux source tree.
|
||||
|
||||
@ -25,9 +25,9 @@ Aside from subsystems like that mentioned above, all network-related
|
||||
Linux development (i.e. RFC, review, comments, etc.) takes place on
|
||||
netdev.
|
||||
|
||||
Q: How do the changes posted to netdev make their way into Linux?
|
||||
-----------------------------------------------------------------
|
||||
A: There are always two trees (git repositories) in play. Both are
|
||||
How do the changes posted to netdev make their way into Linux?
|
||||
--------------------------------------------------------------
|
||||
There are always two trees (git repositories) in play. Both are
|
||||
driven by David Miller, the main network maintainer. There is the
|
||||
``net`` tree, and the ``net-next`` tree. As you can probably guess from
|
||||
the names, the ``net`` tree is for fixes to existing code already in the
|
||||
@ -37,9 +37,9 @@ for the future release. You can find the trees here:
|
||||
- https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
|
||||
- https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
|
||||
|
||||
Q: How often do changes from these trees make it to the mainline Linus tree?
|
||||
----------------------------------------------------------------------------
|
||||
A: To understand this, you need to know a bit of background information on
|
||||
How often do changes from these trees make it to the mainline Linus tree?
|
||||
-------------------------------------------------------------------------
|
||||
To understand this, you need to know a bit of background information on
|
||||
the cadence of Linux development. Each new release starts off with a
|
||||
two week "merge window" where the main maintainers feed their new stuff
|
||||
to Linus for merging into the mainline tree. After the two weeks, the
|
||||
@ -81,7 +81,8 @@ focus for ``net`` is on stabilization and bug fixes.
|
||||
|
||||
Finally, the vX.Y gets released, and the whole cycle starts over.
|
||||
|
||||
Q: So where are we now in this cycle?
|
||||
So where are we now in this cycle?
|
||||
----------------------------------
|
||||
|
||||
Load the mainline (Linus) page here:
|
||||
|
||||
@ -91,9 +92,9 @@ and note the top of the "tags" section. If it is rc1, it is early in
|
||||
the dev cycle. If it was tagged rc7 a week ago, then a release is
|
||||
probably imminent.
|
||||
|
||||
Q: How do I indicate which tree (net vs. net-next) my patch should be in?
|
||||
-------------------------------------------------------------------------
|
||||
A: Firstly, think whether you have a bug fix or new "next-like" content.
|
||||
How do I indicate which tree (net vs. net-next) my patch should be in?
|
||||
----------------------------------------------------------------------
|
||||
Firstly, think whether you have a bug fix or new "next-like" content.
|
||||
Then once decided, assuming that you use git, use the prefix flag, i.e.
|
||||
::
|
||||
|
||||
@ -105,48 +106,45 @@ in the above is just the subject text of the outgoing e-mail, and you
|
||||
can manually change it yourself with whatever MUA you are comfortable
|
||||
with.
|
||||
|
||||
Q: I sent a patch and I'm wondering what happened to it?
|
||||
--------------------------------------------------------
|
||||
Q: How can I tell whether it got merged?
|
||||
A: Start by looking at the main patchworks queue for netdev:
|
||||
I sent a patch and I'm wondering what happened to it - how can I tell whether it got merged?
|
||||
--------------------------------------------------------------------------------------------
|
||||
Start by looking at the main patchworks queue for netdev:
|
||||
|
||||
https://patchwork.kernel.org/project/netdevbpf/list/
|
||||
|
||||
The "State" field will tell you exactly where things are at with your
|
||||
patch.
|
||||
|
||||
Q: The above only says "Under Review". How can I find out more?
|
||||
----------------------------------------------------------------
|
||||
A: Generally speaking, the patches get triaged quickly (in less than
|
||||
The above only says "Under Review". How can I find out more?
|
||||
-------------------------------------------------------------
|
||||
Generally speaking, the patches get triaged quickly (in less than
|
||||
48h). So be patient. Asking the maintainer for status updates on your
|
||||
patch is a good way to ensure your patch is ignored or pushed to the
|
||||
bottom of the priority list.
|
||||
|
||||
Q: I submitted multiple versions of the patch series
|
||||
----------------------------------------------------
|
||||
Q: should I directly update patchwork for the previous versions of these
|
||||
patch series?
|
||||
A: No, please don't interfere with the patch status on patchwork, leave
|
||||
I submitted multiple versions of the patch series. Should I directly update patchwork for the previous versions of these patch series?
|
||||
--------------------------------------------------------------------------------------------------------------------------------------
|
||||
No, please don't interfere with the patch status on patchwork, leave
|
||||
it to the maintainer to figure out what is the most recent and current
|
||||
version that should be applied. If there is any doubt, the maintainer
|
||||
will reply and ask what should be done.
|
||||
|
||||
Q: I made changes to only a few patches in a patch series should I resend only those changed?
|
||||
---------------------------------------------------------------------------------------------
|
||||
A: No, please resend the entire patch series and make sure you do number your
|
||||
I made changes to only a few patches in a patch series should I resend only those changed?
|
||||
------------------------------------------------------------------------------------------
|
||||
No, please resend the entire patch series and make sure you do number your
|
||||
patches such that it is clear this is the latest and greatest set of patches
|
||||
that can be applied.
|
||||
|
||||
Q: I submitted multiple versions of a patch series and it looks like a version other than the last one has been accepted, what should I do?
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------
|
||||
A: There is no revert possible, once it is pushed out, it stays like that.
|
||||
I submitted multiple versions of a patch series and it looks like a version other than the last one has been accepted, what should I do?
|
||||
----------------------------------------------------------------------------------------------------------------------------------------
|
||||
There is no revert possible, once it is pushed out, it stays like that.
|
||||
Please send incremental versions on top of what has been merged in order to fix
|
||||
the patches the way they would look like if your latest patch series was to be
|
||||
merged.
|
||||
|
||||
Q: How can I tell what patches are queued up for backporting to the various stable releases?
|
||||
--------------------------------------------------------------------------------------------
|
||||
A: Normally Greg Kroah-Hartman collects stable commits himself, but for
|
||||
How can I tell what patches are queued up for backporting to the various stable releases?
|
||||
-----------------------------------------------------------------------------------------
|
||||
Normally Greg Kroah-Hartman collects stable commits himself, but for
|
||||
networking, Dave collects up patches he deems critical for the
|
||||
networking subsystem, and then hands them off to Greg.
|
||||
|
||||
@ -169,11 +167,9 @@ simply clone the repo, and then git grep the mainline commit ID, e.g.
|
||||
releases/3.9.8/ipv6-fix-possible-crashes-in-ip6_cork_release.patch
|
||||
stable/stable-queue$
|
||||
|
||||
Q: I see a network patch and I think it should be backported to stable.
|
||||
-----------------------------------------------------------------------
|
||||
Q: Should I request it via stable@vger.kernel.org like the references in
|
||||
the kernel's Documentation/process/stable-kernel-rules.rst file say?
|
||||
A: No, not for networking. Check the stable queues as per above first
|
||||
I see a network patch and I think it should be backported to stable. Should I request it via stable@vger.kernel.org like the references in the kernel's Documentation/process/stable-kernel-rules.rst file say?
|
||||
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
No, not for networking. Check the stable queues as per above first
|
||||
to see if it is already queued. If not, then send a mail to netdev,
|
||||
listing the upstream commit ID and why you think it should be a stable
|
||||
candidate.
|
||||
@ -190,11 +186,9 @@ mainline, the better the odds that it is an OK candidate for stable. So
|
||||
scrambling to request a commit be added the day after it appears should
|
||||
be avoided.
|
||||
|
||||
Q: I have created a network patch and I think it should be backported to stable.
|
||||
--------------------------------------------------------------------------------
|
||||
Q: Should I add a Cc: stable@vger.kernel.org like the references in the
|
||||
kernel's Documentation/ directory say?
|
||||
A: No. See above answer. In short, if you think it really belongs in
|
||||
I have created a network patch and I think it should be backported to stable. Should I add a Cc: stable@vger.kernel.org like the references in the kernel's Documentation/ directory say?
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
No. See above answer. In short, if you think it really belongs in
|
||||
stable, then ensure you write a decent commit log that describes who
|
||||
gets impacted by the bug fix and how it manifests itself, and when the
|
||||
bug was introduced. If you do that properly, then the commit will get
|
||||
@ -207,18 +201,18 @@ marker line as described in
|
||||
:ref:`Documentation/process/submitting-patches.rst <the_canonical_patch_format>`
|
||||
to temporarily embed that information into the patch that you send.
|
||||
|
||||
Q: Are all networking bug fixes backported to all stable releases?
|
||||
------------------------------------------------------------------
|
||||
A: Due to capacity, Dave could only take care of the backports for the
|
||||
Are all networking bug fixes backported to all stable releases?
|
||||
---------------------------------------------------------------
|
||||
Due to capacity, Dave could only take care of the backports for the
|
||||
last two stable releases. For earlier stable releases, each stable
|
||||
branch maintainer is supposed to take care of them. If you find any
|
||||
patch is missing from an earlier stable branch, please notify
|
||||
stable@vger.kernel.org with either a commit ID or a formal patch
|
||||
backported, and CC Dave and other relevant networking developers.
|
||||
|
||||
Q: Is the comment style convention different for the networking content?
|
||||
------------------------------------------------------------------------
|
||||
A: Yes, in a largely trivial way. Instead of this::
|
||||
Is the comment style convention different for the networking content?
|
||||
---------------------------------------------------------------------
|
||||
Yes, in a largely trivial way. Instead of this::
|
||||
|
||||
/*
|
||||
* foobar blah blah blah
|
||||
@ -231,32 +225,30 @@ it is requested that you make it look like this::
|
||||
* another line of text
|
||||
*/
|
||||
|
||||
Q: I am working in existing code that has the former comment style and not the latter.
|
||||
--------------------------------------------------------------------------------------
|
||||
Q: Should I submit new code in the former style or the latter?
|
||||
A: Make it the latter style, so that eventually all code in the domain
|
||||
I am working in existing code that has the former comment style and not the latter. Should I submit new code in the former style or the latter?
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Make it the latter style, so that eventually all code in the domain
|
||||
of netdev is of this format.
|
||||
|
||||
Q: I found a bug that might have possible security implications or similar.
|
||||
---------------------------------------------------------------------------
|
||||
Q: Should I mail the main netdev maintainer off-list?**
|
||||
A: No. The current netdev maintainer has consistently requested that
|
||||
I found a bug that might have possible security implications or similar. Should I mail the main netdev maintainer off-list?
|
||||
---------------------------------------------------------------------------------------------------------------------------
|
||||
No. The current netdev maintainer has consistently requested that
|
||||
people use the mailing lists and not reach out directly. If you aren't
|
||||
OK with that, then perhaps consider mailing security@kernel.org or
|
||||
reading about http://oss-security.openwall.org/wiki/mailing-lists/distros
|
||||
as possible alternative mechanisms.
|
||||
|
||||
Q: What level of testing is expected before I submit my change?
|
||||
---------------------------------------------------------------
|
||||
A: If your changes are against ``net-next``, the expectation is that you
|
||||
What level of testing is expected before I submit my change?
|
||||
------------------------------------------------------------
|
||||
If your changes are against ``net-next``, the expectation is that you
|
||||
have tested by layering your changes on top of ``net-next``. Ideally
|
||||
you will have done run-time testing specific to your change, but at a
|
||||
minimum, your changes should survive an ``allyesconfig`` and an
|
||||
``allmodconfig`` build without new warnings or failures.
|
||||
|
||||
Q: How do I post corresponding changes to user space components?
|
||||
----------------------------------------------------------------
|
||||
A: User space code exercising kernel features should be posted
|
||||
How do I post corresponding changes to user space components?
|
||||
-------------------------------------------------------------
|
||||
User space code exercising kernel features should be posted
|
||||
alongside kernel patches. This gives reviewers a chance to see
|
||||
how any new interface is used and how well it works.
|
||||
|
||||
@ -280,9 +272,9 @@ to the mailing list, e.g.::
|
||||
Posting as one thread is discouraged because it confuses patchwork
|
||||
(as of patchwork 2.2.2).
|
||||
|
||||
Q: Any other tips to help ensure my net/net-next patch gets OK'd?
|
||||
-----------------------------------------------------------------
|
||||
A: Attention to detail. Re-read your own work as if you were the
|
||||
Any other tips to help ensure my net/net-next patch gets OK'd?
|
||||
--------------------------------------------------------------
|
||||
Attention to detail. Re-read your own work as if you were the
|
||||
reviewer. You can start with using ``checkpatch.pl``, perhaps even with
|
||||
the ``--strict`` flag. But do not be mindlessly robotic in doing so.
|
||||
If your change is a bug fix, make sure your commit log indicates the
|
||||
|
||||
@ -8,7 +8,7 @@ Abstract
|
||||
========
|
||||
|
||||
This file documents the mmap() facility available with the PACKET
|
||||
socket interface on 2.4/2.6/3.x kernels. This type of sockets is used for
|
||||
socket interface. This type of sockets is used for
|
||||
|
||||
i) capture network traffic with utilities like tcpdump,
|
||||
ii) transmit network traffic, or any other that needs raw
|
||||
@ -25,12 +25,12 @@ Please send your comments to
|
||||
Why use PACKET_MMAP
|
||||
===================
|
||||
|
||||
In Linux 2.4/2.6/3.x if PACKET_MMAP is not enabled, the capture process is very
|
||||
Non PACKET_MMAP capture process (plain AF_PACKET) is very
|
||||
inefficient. It uses very limited buffers and requires one system call to
|
||||
capture each packet, it requires two if you want to get packet's timestamp
|
||||
(like libpcap always does).
|
||||
|
||||
In the other hand PACKET_MMAP is very efficient. PACKET_MMAP provides a size
|
||||
On the other hand PACKET_MMAP is very efficient. PACKET_MMAP provides a size
|
||||
configurable circular buffer mapped in user space that can be used to either
|
||||
send or receive packets. This way reading packets just needs to wait for them,
|
||||
most of the time there is no need to issue a single system call. Concerning
|
||||
@ -252,8 +252,7 @@ PACKET_MMAP setting constraints
|
||||
|
||||
In kernel versions prior to 2.4.26 (for the 2.4 branch) and 2.6.5 (2.6 branch),
|
||||
the PACKET_MMAP buffer could hold only 32768 frames in a 32 bit architecture or
|
||||
16384 in a 64 bit architecture. For information on these kernel versions
|
||||
see http://pusa.uv.es/~ulisses/packet_mmap/packet_mmap.pre-2.4.26_2.6.5.txt
|
||||
16384 in a 64 bit architecture.
|
||||
|
||||
Block size limit
|
||||
----------------
|
||||
@ -437,7 +436,7 @@ and the following flags apply:
|
||||
Capture process
|
||||
^^^^^^^^^^^^^^^
|
||||
|
||||
from include/linux/if_packet.h
|
||||
From include/linux/if_packet.h::
|
||||
|
||||
#define TP_STATUS_COPY (1 << 1)
|
||||
#define TP_STATUS_LOSING (1 << 2)
|
||||
|
||||
26
MAINTAINERS
26
MAINTAINERS
@ -203,8 +203,8 @@ F: include/uapi/linux/nl80211.h
|
||||
F: net/wireless/
|
||||
|
||||
8169 10/100/1000 GIGABIT ETHERNET DRIVER
|
||||
M: Realtek linux nic maintainers <nic_swsd@realtek.com>
|
||||
M: Heiner Kallweit <hkallweit1@gmail.com>
|
||||
M: nic_swsd@realtek.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: drivers/net/ethernet/realtek/r8169*
|
||||
@ -2119,7 +2119,7 @@ N: atmel
|
||||
ARM/Microchip Sparx5 SoC support
|
||||
M: Lars Povlsen <lars.povlsen@microchip.com>
|
||||
M: Steen Hegelund <Steen.Hegelund@microchip.com>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
|
||||
S: Supported
|
||||
T: git git://github.com/microchip-ung/linux-upstream.git
|
||||
@ -3556,7 +3556,7 @@ S: Supported
|
||||
F: drivers/net/ethernet/broadcom/bnxt/
|
||||
|
||||
BROADCOM BRCM80211 IEEE802.11n WIRELESS DRIVER
|
||||
M: Arend van Spriel <arend.vanspriel@broadcom.com>
|
||||
M: Arend van Spriel <aspriel@gmail.com>
|
||||
M: Franky Lin <franky.lin@broadcom.com>
|
||||
M: Hante Meuleman <hante.meuleman@broadcom.com>
|
||||
M: Chi-hsien Lin <chi-hsien.lin@infineon.com>
|
||||
@ -3961,7 +3961,7 @@ F: net/can/
|
||||
CAN-J1939 NETWORK LAYER
|
||||
M: Robin van der Gracht <robin@protonic.nl>
|
||||
M: Oleksij Rempel <o.rempel@pengutronix.de>
|
||||
R: Pengutronix Kernel Team <kernel@pengutronix.de>
|
||||
R: kernel@pengutronix.de
|
||||
L: linux-can@vger.kernel.org
|
||||
S: Maintained
|
||||
F: Documentation/networking/j1939.rst
|
||||
@ -11667,7 +11667,7 @@ F: drivers/media/platform/atmel/atmel-isi.h
|
||||
|
||||
MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER
|
||||
M: Woojung Huh <woojung.huh@microchip.com>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: Documentation/devicetree/bindings/net/dsa/microchip,ksz.yaml
|
||||
@ -11677,7 +11677,7 @@ F: net/dsa/tag_ksz.c
|
||||
|
||||
MICROCHIP LAN743X ETHERNET DRIVER
|
||||
M: Bryan Whitehead <bryan.whitehead@microchip.com>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: drivers/net/ethernet/microchip/lan743x_*
|
||||
@ -11771,7 +11771,7 @@ F: drivers/net/wireless/microchip/wilc1000/
|
||||
|
||||
MICROSEMI MIPS SOCS
|
||||
M: Alexandre Belloni <alexandre.belloni@bootlin.com>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: linux-mips@vger.kernel.org
|
||||
S: Supported
|
||||
F: Documentation/devicetree/bindings/mips/mscc.txt
|
||||
@ -12825,10 +12825,10 @@ F: tools/objtool/
|
||||
F: include/linux/objtool.h
|
||||
|
||||
OCELOT ETHERNET SWITCH DRIVER
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: Vladimir Oltean <vladimir.oltean@nxp.com>
|
||||
M: Claudiu Manoil <claudiu.manoil@nxp.com>
|
||||
M: Alexandre Belloni <alexandre.belloni@bootlin.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Supported
|
||||
F: drivers/net/dsa/ocelot/*
|
||||
@ -13890,7 +13890,7 @@ F: drivers/platform/x86/peaq-wmi.c
|
||||
|
||||
PENSANDO ETHERNET DRIVERS
|
||||
M: Shannon Nelson <snelson@pensando.io>
|
||||
M: Pensando Drivers <drivers@pensando.io>
|
||||
M: drivers@pensando.io
|
||||
L: netdev@vger.kernel.org
|
||||
S: Supported
|
||||
F: Documentation/networking/device_drivers/ethernet/pensando/ionic.rst
|
||||
@ -14669,7 +14669,7 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
|
||||
F: drivers/net/wireless/ath/ath11k/
|
||||
|
||||
QUALCOMM ATHEROS ATH9K WIRELESS DRIVER
|
||||
M: QCA ath9k Development <ath9k-devel@qca.qualcomm.com>
|
||||
M: ath9k-devel@qca.qualcomm.com
|
||||
L: linux-wireless@vger.kernel.org
|
||||
S: Supported
|
||||
W: https://wireless.wiki.kernel.org/en/users/Drivers/ath9k
|
||||
@ -18370,7 +18370,7 @@ F: include/linux/usb/isp116x.h
|
||||
|
||||
USB LAN78XX ETHERNET DRIVER
|
||||
M: Woojung Huh <woojung.huh@microchip.com>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: Documentation/devicetree/bindings/net/microchip,lan78xx.txt
|
||||
@ -18484,7 +18484,7 @@ F: drivers/net/usb/smsc75xx.*
|
||||
|
||||
USB SMSC95XX ETHERNET DRIVER
|
||||
M: Steve Glendinning <steve.glendinning@shawell.net>
|
||||
M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
|
||||
M: UNGLinuxDriver@microchip.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: drivers/net/usb/smsc95xx.*
|
||||
@ -19031,7 +19031,7 @@ F: drivers/input/mouse/vmmouse.h
|
||||
|
||||
VMWARE VMXNET3 ETHERNET DRIVER
|
||||
M: Ronak Doshi <doshir@vmware.com>
|
||||
M: "VMware, Inc." <pv-drivers@vmware.com>
|
||||
M: pv-drivers@vmware.com
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: drivers/net/vmxnet3/
|
||||
|
||||
@ -3607,7 +3607,7 @@ static int idt77252_init_one(struct pci_dev *pcidev,
|
||||
|
||||
if ((err = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32)))) {
|
||||
printk("idt77252: can't enable DMA for PCI device at %s\n", pci_name(pcidev));
|
||||
return err;
|
||||
goto err_out_disable_pdev;
|
||||
}
|
||||
|
||||
card = kzalloc(sizeof(struct idt77252_dev), GFP_KERNEL);
|
||||
|
||||
@ -380,7 +380,7 @@ static int bareudp6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
|
||||
goto free_dst;
|
||||
|
||||
min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
|
||||
BAREUDP_BASE_HLEN + info->options_len + sizeof(struct iphdr);
|
||||
BAREUDP_BASE_HLEN + info->options_len + sizeof(struct ipv6hdr);
|
||||
|
||||
err = skb_cow_head(skb, min_headroom);
|
||||
if (unlikely(err))
|
||||
@ -534,6 +534,7 @@ static void bareudp_setup(struct net_device *dev)
|
||||
SET_NETDEV_DEVTYPE(dev, &bareudp_type);
|
||||
dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
|
||||
dev->features |= NETIF_F_RXCSUM;
|
||||
dev->features |= NETIF_F_LLTX;
|
||||
dev->features |= NETIF_F_GSO_SOFTWARE;
|
||||
dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
|
||||
dev->hw_features |= NETIF_F_GSO_SOFTWARE;
|
||||
|
||||
@ -92,9 +92,7 @@
|
||||
GSWIP_MDIO_PHY_FDUP_MASK)
|
||||
|
||||
/* GSWIP MII Registers */
|
||||
#define GSWIP_MII_CFG0 0x00
|
||||
#define GSWIP_MII_CFG1 0x02
|
||||
#define GSWIP_MII_CFG5 0x04
|
||||
#define GSWIP_MII_CFGp(p) (0x2 * (p))
|
||||
#define GSWIP_MII_CFG_EN BIT(14)
|
||||
#define GSWIP_MII_CFG_LDCLKDIS BIT(12)
|
||||
#define GSWIP_MII_CFG_MODE_MIIP 0x0
|
||||
@ -392,17 +390,9 @@ static void gswip_mii_mask(struct gswip_priv *priv, u32 clear, u32 set,
|
||||
static void gswip_mii_mask_cfg(struct gswip_priv *priv, u32 clear, u32 set,
|
||||
int port)
|
||||
{
|
||||
switch (port) {
|
||||
case 0:
|
||||
gswip_mii_mask(priv, clear, set, GSWIP_MII_CFG0);
|
||||
break;
|
||||
case 1:
|
||||
gswip_mii_mask(priv, clear, set, GSWIP_MII_CFG1);
|
||||
break;
|
||||
case 5:
|
||||
gswip_mii_mask(priv, clear, set, GSWIP_MII_CFG5);
|
||||
break;
|
||||
}
|
||||
/* There's no MII_CFG register for the CPU port */
|
||||
if (!dsa_is_cpu_port(priv->ds, port))
|
||||
gswip_mii_mask(priv, clear, set, GSWIP_MII_CFGp(port));
|
||||
}
|
||||
|
||||
static void gswip_mii_mask_pcdu(struct gswip_priv *priv, u32 clear, u32 set,
|
||||
@ -822,9 +812,8 @@ static int gswip_setup(struct dsa_switch *ds)
|
||||
gswip_mdio_mask(priv, 0xff, 0x09, GSWIP_MDIO_MDC_CFG1);
|
||||
|
||||
/* Disable the xMII link */
|
||||
gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_EN, 0, 0);
|
||||
gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_EN, 0, 1);
|
||||
gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_EN, 0, 5);
|
||||
for (i = 0; i < priv->hw_info->max_ports; i++)
|
||||
gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_EN, 0, i);
|
||||
|
||||
/* enable special tag insertion on cpu port */
|
||||
gswip_switch_mask(priv, 0, GSWIP_FDMA_PCTRL_STEN,
|
||||
@ -1541,9 +1530,7 @@ static void gswip_phylink_mac_link_up(struct dsa_switch *ds, int port,
|
||||
{
|
||||
struct gswip_priv *priv = ds->priv;
|
||||
|
||||
/* Enable the xMII interface only for the external PHY */
|
||||
if (interface != PHY_INTERFACE_MODE_INTERNAL)
|
||||
gswip_mii_mask_cfg(priv, 0, GSWIP_MII_CFG_EN, port);
|
||||
gswip_mii_mask_cfg(priv, 0, GSWIP_MII_CFG_EN, port);
|
||||
}
|
||||
|
||||
static void gswip_get_strings(struct dsa_switch *ds, int port, u32 stringset,
|
||||
|
||||
@ -19,7 +19,6 @@ if NET_VENDOR_AQUANTIA
|
||||
config AQTION
|
||||
tristate "aQuantia AQtion(tm) Support"
|
||||
depends on PCI
|
||||
depends on X86_64 || ARM64 || COMPILE_TEST
|
||||
depends on MACSEC || MACSEC=n
|
||||
help
|
||||
This enables the support for the aQuantia AQtion(tm) Ethernet card.
|
||||
|
||||
@ -2577,6 +2577,7 @@ static int bcm_sysport_probe(struct platform_device *pdev)
|
||||
NETIF_F_HW_VLAN_CTAG_TX;
|
||||
dev->hw_features |= dev->features;
|
||||
dev->vlan_features |= dev->features;
|
||||
dev->max_mtu = UMAC_MAX_MTU_SIZE;
|
||||
|
||||
/* Request the WOL interrupt and advertise suspend if available */
|
||||
priv->wol_irq_disabled = 1;
|
||||
|
||||
@ -6790,8 +6790,10 @@ static int bnxt_hwrm_func_backing_store_qcaps(struct bnxt *bp)
|
||||
ctx->tqm_fp_rings_count = resp->tqm_fp_rings_count;
|
||||
if (!ctx->tqm_fp_rings_count)
|
||||
ctx->tqm_fp_rings_count = bp->max_q;
|
||||
else if (ctx->tqm_fp_rings_count > BNXT_MAX_TQM_FP_RINGS)
|
||||
ctx->tqm_fp_rings_count = BNXT_MAX_TQM_FP_RINGS;
|
||||
|
||||
tqm_rings = ctx->tqm_fp_rings_count + 1;
|
||||
tqm_rings = ctx->tqm_fp_rings_count + BNXT_MAX_TQM_SP_RINGS;
|
||||
ctx_pg = kcalloc(tqm_rings, sizeof(*ctx_pg), GFP_KERNEL);
|
||||
if (!ctx_pg) {
|
||||
kfree(ctx);
|
||||
@ -6925,7 +6927,8 @@ static int bnxt_hwrm_func_backing_store_cfg(struct bnxt *bp, u32 enables)
|
||||
pg_attr = &req.tqm_sp_pg_size_tqm_sp_lvl,
|
||||
pg_dir = &req.tqm_sp_page_dir,
|
||||
ena = FUNC_BACKING_STORE_CFG_REQ_ENABLES_TQM_SP;
|
||||
i < 9; i++, num_entries++, pg_attr++, pg_dir++, ena <<= 1) {
|
||||
i < BNXT_MAX_TQM_RINGS;
|
||||
i++, num_entries++, pg_attr++, pg_dir++, ena <<= 1) {
|
||||
if (!(enables & ena))
|
||||
continue;
|
||||
|
||||
@ -12887,10 +12890,10 @@ static pci_ers_result_t bnxt_io_error_detected(struct pci_dev *pdev,
|
||||
*/
|
||||
static pci_ers_result_t bnxt_io_slot_reset(struct pci_dev *pdev)
|
||||
{
|
||||
pci_ers_result_t result = PCI_ERS_RESULT_DISCONNECT;
|
||||
struct net_device *netdev = pci_get_drvdata(pdev);
|
||||
struct bnxt *bp = netdev_priv(netdev);
|
||||
int err = 0, off;
|
||||
pci_ers_result_t result = PCI_ERS_RESULT_DISCONNECT;
|
||||
|
||||
netdev_info(bp->dev, "PCI Slot Reset\n");
|
||||
|
||||
@ -12919,22 +12922,8 @@ static pci_ers_result_t bnxt_io_slot_reset(struct pci_dev *pdev)
|
||||
pci_save_state(pdev);
|
||||
|
||||
err = bnxt_hwrm_func_reset(bp);
|
||||
if (!err) {
|
||||
err = bnxt_hwrm_func_qcaps(bp);
|
||||
if (!err && netif_running(netdev))
|
||||
err = bnxt_open(netdev);
|
||||
}
|
||||
bnxt_ulp_start(bp, err);
|
||||
if (!err) {
|
||||
bnxt_reenable_sriov(bp);
|
||||
if (!err)
|
||||
result = PCI_ERS_RESULT_RECOVERED;
|
||||
}
|
||||
}
|
||||
|
||||
if (result != PCI_ERS_RESULT_RECOVERED) {
|
||||
if (netif_running(netdev))
|
||||
dev_close(netdev);
|
||||
pci_disable_device(pdev);
|
||||
}
|
||||
|
||||
rtnl_unlock();
|
||||
@ -12952,10 +12941,21 @@ static pci_ers_result_t bnxt_io_slot_reset(struct pci_dev *pdev)
|
||||
static void bnxt_io_resume(struct pci_dev *pdev)
|
||||
{
|
||||
struct net_device *netdev = pci_get_drvdata(pdev);
|
||||
struct bnxt *bp = netdev_priv(netdev);
|
||||
int err;
|
||||
|
||||
netdev_info(bp->dev, "PCI Slot Resume\n");
|
||||
rtnl_lock();
|
||||
|
||||
netif_device_attach(netdev);
|
||||
err = bnxt_hwrm_func_qcaps(bp);
|
||||
if (!err && netif_running(netdev))
|
||||
err = bnxt_open(netdev);
|
||||
|
||||
bnxt_ulp_start(bp, err);
|
||||
if (!err) {
|
||||
bnxt_reenable_sriov(bp);
|
||||
netif_device_attach(netdev);
|
||||
}
|
||||
|
||||
rtnl_unlock();
|
||||
}
|
||||
|
||||
@ -1436,6 +1436,11 @@ struct bnxt_ctx_pg_info {
|
||||
struct bnxt_ctx_pg_info **ctx_pg_tbl;
|
||||
};
|
||||
|
||||
#define BNXT_MAX_TQM_SP_RINGS 1
|
||||
#define BNXT_MAX_TQM_FP_RINGS 8
|
||||
#define BNXT_MAX_TQM_RINGS \
|
||||
(BNXT_MAX_TQM_SP_RINGS + BNXT_MAX_TQM_FP_RINGS)
|
||||
|
||||
struct bnxt_ctx_mem_info {
|
||||
u32 qp_max_entries;
|
||||
u16 qp_min_qp1_entries;
|
||||
@ -1474,7 +1479,7 @@ struct bnxt_ctx_mem_info {
|
||||
struct bnxt_ctx_pg_info stat_mem;
|
||||
struct bnxt_ctx_pg_info mrav_mem;
|
||||
struct bnxt_ctx_pg_info tim_mem;
|
||||
struct bnxt_ctx_pg_info *tqm_mem[9];
|
||||
struct bnxt_ctx_pg_info *tqm_mem[BNXT_MAX_TQM_RINGS];
|
||||
};
|
||||
|
||||
struct bnxt_fw_health {
|
||||
|
||||
@ -467,7 +467,7 @@ static void macb_set_tx_clk(struct macb *bp, int speed)
|
||||
{
|
||||
long ferr, rate, rate_rounded;
|
||||
|
||||
if (!bp->tx_clk || !(bp->caps & MACB_CAPS_CLK_HW_CHG))
|
||||
if (!bp->tx_clk || (bp->caps & MACB_CAPS_CLK_HW_CHG))
|
||||
return;
|
||||
|
||||
switch (speed) {
|
||||
|
||||
@ -1211,7 +1211,7 @@ static int ethoc_probe(struct platform_device *pdev)
|
||||
ret = mdiobus_register(priv->mdio);
|
||||
if (ret) {
|
||||
dev_err(&netdev->dev, "failed to register MDIO bus\n");
|
||||
goto free2;
|
||||
goto free3;
|
||||
}
|
||||
|
||||
ret = ethoc_mdio_probe(netdev);
|
||||
@ -1243,6 +1243,7 @@ static int ethoc_probe(struct platform_device *pdev)
|
||||
netif_napi_del(&priv->napi);
|
||||
error:
|
||||
mdiobus_unregister(priv->mdio);
|
||||
free3:
|
||||
mdiobus_free(priv->mdio);
|
||||
free2:
|
||||
clk_disable_unprepare(priv->clk);
|
||||
|
||||
@ -3889,6 +3889,7 @@ static int ucc_geth_probe(struct platform_device* ofdev)
|
||||
INIT_WORK(&ugeth->timeout_work, ucc_geth_timeout_work);
|
||||
netif_napi_add(dev, &ugeth->napi, ucc_geth_poll, 64);
|
||||
dev->mtu = 1500;
|
||||
dev->max_mtu = 1518;
|
||||
|
||||
ugeth->msg_enable = netif_msg_init(debug.msg_enable, UGETH_MSG_DEFAULT);
|
||||
ugeth->phy_interface = phy_interface;
|
||||
@ -3934,12 +3935,12 @@ static int ucc_geth_remove(struct platform_device* ofdev)
|
||||
struct device_node *np = ofdev->dev.of_node;
|
||||
|
||||
unregister_netdev(dev);
|
||||
free_netdev(dev);
|
||||
ucc_geth_memclean(ugeth);
|
||||
if (of_phy_is_fixed_link(np))
|
||||
of_phy_deregister_fixed_link(np);
|
||||
of_node_put(ugeth->ug_info->tbi_node);
|
||||
of_node_put(ugeth->ug_info->phy_node);
|
||||
free_netdev(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -575,7 +575,14 @@ struct ucc_geth_tx_global_pram {
|
||||
u32 vtagtable[0x8]; /* 8 4-byte VLAN tags */
|
||||
u32 tqptr; /* a base pointer to the Tx Queues Memory
|
||||
Region */
|
||||
u8 res2[0x80 - 0x74];
|
||||
u8 res2[0x78 - 0x74];
|
||||
u64 snums_en;
|
||||
u32 l2l3baseptr; /* top byte consists of a few other bit fields */
|
||||
|
||||
u16 mtu[8];
|
||||
u8 res3[0xa8 - 0x94];
|
||||
u32 wrrtablebase; /* top byte is reserved */
|
||||
u8 res4[0xc0 - 0xac];
|
||||
} __packed;
|
||||
|
||||
/* structure representing Extended Filtering Global Parameters in PRAM */
|
||||
|
||||
@ -415,6 +415,10 @@ static void __lb_other_process(struct hns_nic_ring_data *ring_data,
|
||||
/* for mutl buffer*/
|
||||
new_skb = skb_copy(skb, GFP_ATOMIC);
|
||||
dev_kfree_skb_any(skb);
|
||||
if (!new_skb) {
|
||||
netdev_err(ndev, "skb alloc failed\n");
|
||||
return;
|
||||
}
|
||||
skb = new_skb;
|
||||
|
||||
check_ok = 0;
|
||||
|
||||
@ -955,6 +955,7 @@ static void release_resources(struct ibmvnic_adapter *adapter)
|
||||
release_rx_pools(adapter);
|
||||
|
||||
release_napi(adapter);
|
||||
release_login_buffer(adapter);
|
||||
release_login_rsp_buffer(adapter);
|
||||
}
|
||||
|
||||
@ -2341,8 +2342,7 @@ static void __ibmvnic_reset(struct work_struct *work)
|
||||
set_current_state(TASK_UNINTERRUPTIBLE);
|
||||
schedule_timeout(60 * HZ);
|
||||
}
|
||||
} else if (!(rwi->reset_reason == VNIC_RESET_FATAL &&
|
||||
adapter->from_passive_init)) {
|
||||
} else {
|
||||
rc = do_reset(adapter, rwi, reset_state);
|
||||
}
|
||||
kfree(rwi);
|
||||
@ -2981,9 +2981,7 @@ static int reset_one_sub_crq_queue(struct ibmvnic_adapter *adapter,
|
||||
int rc;
|
||||
|
||||
if (!scrq) {
|
||||
netdev_dbg(adapter->netdev,
|
||||
"Invalid scrq reset. irq (%d) or msgs (%p).\n",
|
||||
scrq->irq, scrq->msgs);
|
||||
netdev_dbg(adapter->netdev, "Invalid scrq reset.\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -3873,7 +3871,9 @@ static int send_login(struct ibmvnic_adapter *adapter)
|
||||
return -1;
|
||||
}
|
||||
|
||||
release_login_buffer(adapter);
|
||||
release_login_rsp_buffer(adapter);
|
||||
|
||||
client_data_len = vnic_client_data_len(adapter);
|
||||
|
||||
buffer_size =
|
||||
|
||||
@ -436,6 +436,7 @@ s32 e1000e_get_base_timinca(struct e1000_adapter *adapter, u32 *timinca);
|
||||
#define FLAG2_DFLT_CRC_STRIPPING BIT(12)
|
||||
#define FLAG2_CHECK_RX_HWTSTAMP BIT(13)
|
||||
#define FLAG2_CHECK_SYSTIM_OVERFLOW BIT(14)
|
||||
#define FLAG2_ENABLE_S0IX_FLOWS BIT(15)
|
||||
|
||||
#define E1000_RX_DESC_PS(R, i) \
|
||||
(&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
|
||||
|
||||
@ -23,6 +23,13 @@ struct e1000_stats {
|
||||
int stat_offset;
|
||||
};
|
||||
|
||||
static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {
|
||||
#define E1000E_PRIV_FLAGS_S0IX_ENABLED BIT(0)
|
||||
"s0ix-enabled",
|
||||
};
|
||||
|
||||
#define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)
|
||||
|
||||
#define E1000_STAT(str, m) { \
|
||||
.stat_string = str, \
|
||||
.type = E1000_STATS, \
|
||||
@ -1776,6 +1783,8 @@ static int e1000e_get_sset_count(struct net_device __always_unused *netdev,
|
||||
return E1000_TEST_LEN;
|
||||
case ETH_SS_STATS:
|
||||
return E1000_STATS_LEN;
|
||||
case ETH_SS_PRIV_FLAGS:
|
||||
return E1000E_PRIV_FLAGS_STR_LEN;
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
@ -2097,6 +2106,10 @@ static void e1000_get_strings(struct net_device __always_unused *netdev,
|
||||
p += ETH_GSTRING_LEN;
|
||||
}
|
||||
break;
|
||||
case ETH_SS_PRIV_FLAGS:
|
||||
memcpy(data, e1000e_priv_flags_strings,
|
||||
E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2305,6 +2318,37 @@ static int e1000e_get_ts_info(struct net_device *netdev,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static u32 e1000e_get_priv_flags(struct net_device *netdev)
|
||||
{
|
||||
struct e1000_adapter *adapter = netdev_priv(netdev);
|
||||
u32 priv_flags = 0;
|
||||
|
||||
if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
|
||||
priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;
|
||||
|
||||
return priv_flags;
|
||||
}
|
||||
|
||||
static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
|
||||
{
|
||||
struct e1000_adapter *adapter = netdev_priv(netdev);
|
||||
unsigned int flags2 = adapter->flags2;
|
||||
|
||||
flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
|
||||
if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
|
||||
struct e1000_hw *hw = &adapter->hw;
|
||||
|
||||
if (hw->mac.type < e1000_pch_cnp)
|
||||
return -EINVAL;
|
||||
flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
|
||||
}
|
||||
|
||||
if (flags2 != adapter->flags2)
|
||||
adapter->flags2 = flags2;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct ethtool_ops e1000_ethtool_ops = {
|
||||
.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
|
||||
.get_drvinfo = e1000_get_drvinfo,
|
||||
@ -2336,6 +2380,8 @@ static const struct ethtool_ops e1000_ethtool_ops = {
|
||||
.set_eee = e1000e_set_eee,
|
||||
.get_link_ksettings = e1000_get_link_ksettings,
|
||||
.set_link_ksettings = e1000_set_link_ksettings,
|
||||
.get_priv_flags = e1000e_get_priv_flags,
|
||||
.set_priv_flags = e1000e_set_priv_flags,
|
||||
};
|
||||
|
||||
void e1000e_set_ethtool_ops(struct net_device *netdev)
|
||||
|
||||
@ -1240,6 +1240,9 @@ static s32 e1000_disable_ulp_lpt_lp(struct e1000_hw *hw, bool force)
|
||||
return 0;
|
||||
|
||||
if (er32(FWSM) & E1000_ICH_FWSM_FW_VALID) {
|
||||
struct e1000_adapter *adapter = hw->adapter;
|
||||
bool firmware_bug = false;
|
||||
|
||||
if (force) {
|
||||
/* Request ME un-configure ULP mode in the PHY */
|
||||
mac_reg = er32(H2ME);
|
||||
@ -1248,16 +1251,24 @@ static s32 e1000_disable_ulp_lpt_lp(struct e1000_hw *hw, bool force)
|
||||
ew32(H2ME, mac_reg);
|
||||
}
|
||||
|
||||
/* Poll up to 300msec for ME to clear ULP_CFG_DONE. */
|
||||
/* Poll up to 2.5 seconds for ME to clear ULP_CFG_DONE.
|
||||
* If this takes more than 1 second, show a warning indicating a
|
||||
* firmware bug
|
||||
*/
|
||||
while (er32(FWSM) & E1000_FWSM_ULP_CFG_DONE) {
|
||||
if (i++ == 30) {
|
||||
if (i++ == 250) {
|
||||
ret_val = -E1000_ERR_PHY;
|
||||
goto out;
|
||||
}
|
||||
if (i > 100 && !firmware_bug)
|
||||
firmware_bug = true;
|
||||
|
||||
usleep_range(10000, 11000);
|
||||
}
|
||||
e_dbg("ULP_CONFIG_DONE cleared after %dmsec\n", i * 10);
|
||||
if (firmware_bug)
|
||||
e_warn("ULP_CONFIG_DONE took %dmsec. This is a firmware bug\n", i * 10);
|
||||
else
|
||||
e_dbg("ULP_CONFIG_DONE cleared after %dmsec\n", i * 10);
|
||||
|
||||
if (force) {
|
||||
mac_reg = er32(H2ME);
|
||||
|
||||
@ -103,45 +103,6 @@ static const struct e1000_reg_info e1000_reg_info_tbl[] = {
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
struct e1000e_me_supported {
|
||||
u16 device_id; /* supported device ID */
|
||||
};
|
||||
|
||||
static const struct e1000e_me_supported me_supported[] = {
|
||||
{E1000_DEV_ID_PCH_LPT_I217_LM},
|
||||
{E1000_DEV_ID_PCH_LPTLP_I218_LM},
|
||||
{E1000_DEV_ID_PCH_I218_LM2},
|
||||
{E1000_DEV_ID_PCH_I218_LM3},
|
||||
{E1000_DEV_ID_PCH_SPT_I219_LM},
|
||||
{E1000_DEV_ID_PCH_SPT_I219_LM2},
|
||||
{E1000_DEV_ID_PCH_LBG_I219_LM3},
|
||||
{E1000_DEV_ID_PCH_SPT_I219_LM4},
|
||||
{E1000_DEV_ID_PCH_SPT_I219_LM5},
|
||||
{E1000_DEV_ID_PCH_CNP_I219_LM6},
|
||||
{E1000_DEV_ID_PCH_CNP_I219_LM7},
|
||||
{E1000_DEV_ID_PCH_ICP_I219_LM8},
|
||||
{E1000_DEV_ID_PCH_ICP_I219_LM9},
|
||||
{E1000_DEV_ID_PCH_CMP_I219_LM10},
|
||||
{E1000_DEV_ID_PCH_CMP_I219_LM11},
|
||||
{E1000_DEV_ID_PCH_CMP_I219_LM12},
|
||||
{E1000_DEV_ID_PCH_TGP_I219_LM13},
|
||||
{E1000_DEV_ID_PCH_TGP_I219_LM14},
|
||||
{E1000_DEV_ID_PCH_TGP_I219_LM15},
|
||||
{0}
|
||||
};
|
||||
|
||||
static bool e1000e_check_me(u16 device_id)
|
||||
{
|
||||
struct e1000e_me_supported *id;
|
||||
|
||||
for (id = (struct e1000e_me_supported *)me_supported;
|
||||
id->device_id; id++)
|
||||
if (device_id == id->device_id)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* __ew32_prepare - prepare to write to MAC CSR register on certain parts
|
||||
* @hw: pointer to the HW structure
|
||||
@ -6962,7 +6923,6 @@ static __maybe_unused int e1000e_pm_suspend(struct device *dev)
|
||||
struct net_device *netdev = pci_get_drvdata(to_pci_dev(dev));
|
||||
struct e1000_adapter *adapter = netdev_priv(netdev);
|
||||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
struct e1000_hw *hw = &adapter->hw;
|
||||
int rc;
|
||||
|
||||
e1000e_flush_lpic(pdev);
|
||||
@ -6970,13 +6930,13 @@ static __maybe_unused int e1000e_pm_suspend(struct device *dev)
|
||||
e1000e_pm_freeze(dev);
|
||||
|
||||
rc = __e1000_shutdown(pdev, false);
|
||||
if (rc)
|
||||
if (rc) {
|
||||
e1000e_pm_thaw(dev);
|
||||
|
||||
/* Introduce S0ix implementation */
|
||||
if (hw->mac.type >= e1000_pch_cnp &&
|
||||
!e1000e_check_me(hw->adapter->pdev->device))
|
||||
e1000e_s0ix_entry_flow(adapter);
|
||||
} else {
|
||||
/* Introduce S0ix implementation */
|
||||
if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
|
||||
e1000e_s0ix_entry_flow(adapter);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
@ -6986,12 +6946,10 @@ static __maybe_unused int e1000e_pm_resume(struct device *dev)
|
||||
struct net_device *netdev = pci_get_drvdata(to_pci_dev(dev));
|
||||
struct e1000_adapter *adapter = netdev_priv(netdev);
|
||||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
struct e1000_hw *hw = &adapter->hw;
|
||||
int rc;
|
||||
|
||||
/* Introduce S0ix implementation */
|
||||
if (hw->mac.type >= e1000_pch_cnp &&
|
||||
!e1000e_check_me(hw->adapter->pdev->device))
|
||||
if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
|
||||
e1000e_s0ix_exit_flow(adapter);
|
||||
|
||||
rc = __e1000_resume(pdev);
|
||||
@ -7655,6 +7613,9 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
||||
if (!(adapter->flags & FLAG_HAS_AMT))
|
||||
e1000e_get_hw_control(adapter);
|
||||
|
||||
if (hw->mac.type >= e1000_pch_cnp)
|
||||
adapter->flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
|
||||
|
||||
strlcpy(netdev->name, "eth%d", sizeof(netdev->name));
|
||||
err = register_netdev(netdev);
|
||||
if (err)
|
||||
|
||||
@ -120,6 +120,7 @@ enum i40e_state_t {
|
||||
__I40E_RESET_INTR_RECEIVED,
|
||||
__I40E_REINIT_REQUESTED,
|
||||
__I40E_PF_RESET_REQUESTED,
|
||||
__I40E_PF_RESET_AND_REBUILD_REQUESTED,
|
||||
__I40E_CORE_RESET_REQUESTED,
|
||||
__I40E_GLOBAL_RESET_REQUESTED,
|
||||
__I40E_EMP_RESET_INTR_RECEIVED,
|
||||
@ -146,6 +147,8 @@ enum i40e_state_t {
|
||||
};
|
||||
|
||||
#define I40E_PF_RESET_FLAG BIT_ULL(__I40E_PF_RESET_REQUESTED)
|
||||
#define I40E_PF_RESET_AND_REBUILD_FLAG \
|
||||
BIT_ULL(__I40E_PF_RESET_AND_REBUILD_REQUESTED)
|
||||
|
||||
/* VSI state flags */
|
||||
enum i40e_vsi_state_t {
|
||||
|
||||
@ -36,6 +36,8 @@ static int i40e_setup_misc_vector(struct i40e_pf *pf);
|
||||
static void i40e_determine_queue_usage(struct i40e_pf *pf);
|
||||
static int i40e_setup_pf_filter_control(struct i40e_pf *pf);
|
||||
static void i40e_prep_for_reset(struct i40e_pf *pf, bool lock_acquired);
|
||||
static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit,
|
||||
bool lock_acquired);
|
||||
static int i40e_reset(struct i40e_pf *pf);
|
||||
static void i40e_rebuild(struct i40e_pf *pf, bool reinit, bool lock_acquired);
|
||||
static int i40e_setup_misc_vector_for_recovery_mode(struct i40e_pf *pf);
|
||||
@ -8536,6 +8538,14 @@ void i40e_do_reset(struct i40e_pf *pf, u32 reset_flags, bool lock_acquired)
|
||||
"FW LLDP is disabled\n" :
|
||||
"FW LLDP is enabled\n");
|
||||
|
||||
} else if (reset_flags & I40E_PF_RESET_AND_REBUILD_FLAG) {
|
||||
/* Request a PF Reset
|
||||
*
|
||||
* Resets PF and reinitializes PFs VSI.
|
||||
*/
|
||||
i40e_prep_for_reset(pf, lock_acquired);
|
||||
i40e_reset_and_rebuild(pf, true, lock_acquired);
|
||||
|
||||
} else if (reset_flags & BIT_ULL(__I40E_REINIT_REQUESTED)) {
|
||||
int v;
|
||||
|
||||
|
||||
@ -1772,7 +1772,7 @@ int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
|
||||
if (num_vfs) {
|
||||
if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) {
|
||||
pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
|
||||
i40e_do_reset_safe(pf, I40E_PF_RESET_FLAG);
|
||||
i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
|
||||
}
|
||||
ret = i40e_pci_sriov_enable(pdev, num_vfs);
|
||||
goto sriov_configure_out;
|
||||
@ -1781,7 +1781,7 @@ int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
|
||||
if (!pci_vfs_assigned(pf->pdev)) {
|
||||
i40e_free_vfs(pf);
|
||||
pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
|
||||
i40e_do_reset_safe(pf, I40E_PF_RESET_FLAG);
|
||||
i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
|
||||
} else {
|
||||
dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n");
|
||||
ret = -EINVAL;
|
||||
|
||||
@ -1834,11 +1834,9 @@ static int iavf_init_get_resources(struct iavf_adapter *adapter)
|
||||
netif_tx_stop_all_queues(netdev);
|
||||
if (CLIENT_ALLOWED(adapter)) {
|
||||
err = iavf_lan_add_device(adapter);
|
||||
if (err) {
|
||||
rtnl_unlock();
|
||||
if (err)
|
||||
dev_info(&pdev->dev, "Failed to add VF to client API service list: %d\n",
|
||||
err);
|
||||
}
|
||||
}
|
||||
dev_info(&pdev->dev, "MAC address: %pM\n", adapter->hw.mac.addr);
|
||||
if (netdev->features & NETIF_F_GRO)
|
||||
|
||||
@ -5255,7 +5255,7 @@ static int mvneta_probe(struct platform_device *pdev)
|
||||
err = mvneta_port_power_up(pp, pp->phy_interface);
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "can't power up port\n");
|
||||
return err;
|
||||
goto err_netdev;
|
||||
}
|
||||
|
||||
/* Armada3700 network controller does not support per-cpu
|
||||
|
||||
@ -1231,7 +1231,7 @@ static void mvpp22_gop_init_rgmii(struct mvpp2_port *port)
|
||||
|
||||
regmap_read(priv->sysctrl_base, GENCONF_CTRL0, &val);
|
||||
if (port->gop_id == 2)
|
||||
val |= GENCONF_CTRL0_PORT0_RGMII | GENCONF_CTRL0_PORT1_RGMII;
|
||||
val |= GENCONF_CTRL0_PORT0_RGMII;
|
||||
else if (port->gop_id == 3)
|
||||
val |= GENCONF_CTRL0_PORT1_RGMII_MII;
|
||||
regmap_write(priv->sysctrl_base, GENCONF_CTRL0, val);
|
||||
@ -2370,17 +2370,18 @@ static void mvpp2_rx_pkts_coal_set(struct mvpp2_port *port,
|
||||
static void mvpp2_tx_pkts_coal_set(struct mvpp2_port *port,
|
||||
struct mvpp2_tx_queue *txq)
|
||||
{
|
||||
unsigned int thread = mvpp2_cpu_to_thread(port->priv, get_cpu());
|
||||
unsigned int thread;
|
||||
u32 val;
|
||||
|
||||
if (txq->done_pkts_coal > MVPP2_TXQ_THRESH_MASK)
|
||||
txq->done_pkts_coal = MVPP2_TXQ_THRESH_MASK;
|
||||
|
||||
val = (txq->done_pkts_coal << MVPP2_TXQ_THRESH_OFFSET);
|
||||
mvpp2_thread_write(port->priv, thread, MVPP2_TXQ_NUM_REG, txq->id);
|
||||
mvpp2_thread_write(port->priv, thread, MVPP2_TXQ_THRESH_REG, val);
|
||||
|
||||
put_cpu();
|
||||
/* PKT-coalescing registers are per-queue + per-thread */
|
||||
for (thread = 0; thread < MVPP2_MAX_THREADS; thread++) {
|
||||
mvpp2_thread_write(port->priv, thread, MVPP2_TXQ_NUM_REG, txq->id);
|
||||
mvpp2_thread_write(port->priv, thread, MVPP2_TXQ_THRESH_REG, val);
|
||||
}
|
||||
}
|
||||
|
||||
static u32 mvpp2_usec_to_cycles(u32 usec, unsigned long clk_hz)
|
||||
@ -5487,7 +5488,7 @@ static int mvpp2_port_init(struct mvpp2_port *port)
|
||||
struct mvpp2 *priv = port->priv;
|
||||
struct mvpp2_txq_pcpu *txq_pcpu;
|
||||
unsigned int thread;
|
||||
int queue, err;
|
||||
int queue, err, val;
|
||||
|
||||
/* Checks for hardware constraints */
|
||||
if (port->first_rxq + port->nrxqs >
|
||||
@ -5501,6 +5502,18 @@ static int mvpp2_port_init(struct mvpp2_port *port)
|
||||
mvpp2_egress_disable(port);
|
||||
mvpp2_port_disable(port);
|
||||
|
||||
if (mvpp2_is_xlg(port->phy_interface)) {
|
||||
val = readl(port->base + MVPP22_XLG_CTRL0_REG);
|
||||
val &= ~MVPP22_XLG_CTRL0_FORCE_LINK_PASS;
|
||||
val |= MVPP22_XLG_CTRL0_FORCE_LINK_DOWN;
|
||||
writel(val, port->base + MVPP22_XLG_CTRL0_REG);
|
||||
} else {
|
||||
val = readl(port->base + MVPP2_GMAC_AUTONEG_CONFIG);
|
||||
val &= ~MVPP2_GMAC_FORCE_LINK_PASS;
|
||||
val |= MVPP2_GMAC_FORCE_LINK_DOWN;
|
||||
writel(val, port->base + MVPP2_GMAC_AUTONEG_CONFIG);
|
||||
}
|
||||
|
||||
port->tx_time_coal = MVPP2_TXDONE_COAL_USEC;
|
||||
|
||||
port->txqs = devm_kcalloc(dev, port->ntxqs, sizeof(*port->txqs),
|
||||
|
||||
@ -405,6 +405,38 @@ static int mvpp2_prs_tcam_first_free(struct mvpp2 *priv, unsigned char start,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Drop flow control pause frames */
|
||||
static void mvpp2_prs_drop_fc(struct mvpp2 *priv)
|
||||
{
|
||||
unsigned char da[ETH_ALEN] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x01 };
|
||||
struct mvpp2_prs_entry pe;
|
||||
unsigned int len;
|
||||
|
||||
memset(&pe, 0, sizeof(pe));
|
||||
|
||||
/* For all ports - drop flow control frames */
|
||||
pe.index = MVPP2_PE_FC_DROP;
|
||||
mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC);
|
||||
|
||||
/* Set match on DA */
|
||||
len = ETH_ALEN;
|
||||
while (len--)
|
||||
mvpp2_prs_tcam_data_byte_set(&pe, len, da[len], 0xff);
|
||||
|
||||
mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK,
|
||||
MVPP2_PRS_RI_DROP_MASK);
|
||||
|
||||
mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1);
|
||||
mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS);
|
||||
|
||||
/* Mask all ports */
|
||||
mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK);
|
||||
|
||||
/* Update shadow table and hw entry */
|
||||
mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC);
|
||||
mvpp2_prs_hw_write(priv, &pe);
|
||||
}
|
||||
|
||||
/* Enable/disable dropping all mac da's */
|
||||
static void mvpp2_prs_mac_drop_all_set(struct mvpp2 *priv, int port, bool add)
|
||||
{
|
||||
@ -1162,6 +1194,7 @@ static void mvpp2_prs_mac_init(struct mvpp2 *priv)
|
||||
mvpp2_prs_hw_write(priv, &pe);
|
||||
|
||||
/* Create dummy entries for drop all and promiscuous modes */
|
||||
mvpp2_prs_drop_fc(priv);
|
||||
mvpp2_prs_mac_drop_all_set(priv, 0, false);
|
||||
mvpp2_prs_mac_promisc_set(priv, 0, MVPP2_PRS_L2_UNI_CAST, false);
|
||||
mvpp2_prs_mac_promisc_set(priv, 0, MVPP2_PRS_L2_MULTI_CAST, false);
|
||||
@ -1647,8 +1680,9 @@ static int mvpp2_prs_pppoe_init(struct mvpp2 *priv)
|
||||
mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6);
|
||||
mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP6,
|
||||
MVPP2_PRS_RI_L3_PROTO_MASK);
|
||||
/* Skip eth_type + 4 bytes of IPv6 header */
|
||||
mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 4,
|
||||
/* Jump to DIP of IPV6 header */
|
||||
mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 8 +
|
||||
MVPP2_MAX_L3_ADDR_SIZE,
|
||||
MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD);
|
||||
/* Set L3 offset */
|
||||
mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3,
|
||||
|
||||
@ -129,7 +129,7 @@
|
||||
#define MVPP2_PE_VID_EDSA_FLTR_DEFAULT (MVPP2_PRS_TCAM_SRAM_SIZE - 7)
|
||||
#define MVPP2_PE_VLAN_DBL (MVPP2_PRS_TCAM_SRAM_SIZE - 6)
|
||||
#define MVPP2_PE_VLAN_NONE (MVPP2_PRS_TCAM_SRAM_SIZE - 5)
|
||||
/* reserved */
|
||||
#define MVPP2_PE_FC_DROP (MVPP2_PRS_TCAM_SRAM_SIZE - 4)
|
||||
#define MVPP2_PE_MAC_MC_PROMISCUOUS (MVPP2_PRS_TCAM_SRAM_SIZE - 3)
|
||||
#define MVPP2_PE_MAC_UC_PROMISCUOUS (MVPP2_PRS_TCAM_SRAM_SIZE - 2)
|
||||
#define MVPP2_PE_MAC_NON_PROMISCUOUS (MVPP2_PRS_TCAM_SRAM_SIZE - 1)
|
||||
|
||||
@ -337,7 +337,7 @@ void ionic_rx_fill(struct ionic_queue *q)
|
||||
unsigned int i, j;
|
||||
unsigned int len;
|
||||
|
||||
len = netdev->mtu + ETH_HLEN;
|
||||
len = netdev->mtu + ETH_HLEN + VLAN_HLEN;
|
||||
nfrags = round_up(len, PAGE_SIZE) / PAGE_SIZE;
|
||||
|
||||
for (i = ionic_q_space_avail(q); i; i--) {
|
||||
|
||||
@ -1799,6 +1799,11 @@ netdev_features_t qede_features_check(struct sk_buff *skb,
|
||||
ntohs(udp_hdr(skb)->dest) != gnv_port))
|
||||
return features & ~(NETIF_F_CSUM_MASK |
|
||||
NETIF_F_GSO_MASK);
|
||||
} else if (l4_proto == IPPROTO_IPIP) {
|
||||
/* IPIP tunnels are unknown to the device or at least unsupported natively,
|
||||
* offloads for them can't be done trivially, so disable them for such skb.
|
||||
*/
|
||||
return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2207,7 +2207,8 @@ static void rtl_pll_power_down(struct rtl8169_private *tp)
|
||||
}
|
||||
|
||||
switch (tp->mac_version) {
|
||||
case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33:
|
||||
case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_26:
|
||||
case RTL_GIGA_MAC_VER_32 ... RTL_GIGA_MAC_VER_33:
|
||||
case RTL_GIGA_MAC_VER_37:
|
||||
case RTL_GIGA_MAC_VER_39:
|
||||
case RTL_GIGA_MAC_VER_43:
|
||||
@ -2233,7 +2234,8 @@ static void rtl_pll_power_down(struct rtl8169_private *tp)
|
||||
static void rtl_pll_power_up(struct rtl8169_private *tp)
|
||||
{
|
||||
switch (tp->mac_version) {
|
||||
case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33:
|
||||
case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_26:
|
||||
case RTL_GIGA_MAC_VER_32 ... RTL_GIGA_MAC_VER_33:
|
||||
case RTL_GIGA_MAC_VER_37:
|
||||
case RTL_GIGA_MAC_VER_39:
|
||||
case RTL_GIGA_MAC_VER_43:
|
||||
|
||||
@ -721,6 +721,8 @@ static SIMPLE_DEV_PM_OPS(intel_eth_pm_ops, intel_eth_pci_suspend,
|
||||
#define PCI_DEVICE_ID_INTEL_EHL_PSE1_RGMII1G_ID 0x4bb0
|
||||
#define PCI_DEVICE_ID_INTEL_EHL_PSE1_SGMII1G_ID 0x4bb1
|
||||
#define PCI_DEVICE_ID_INTEL_EHL_PSE1_SGMII2G5_ID 0x4bb2
|
||||
#define PCI_DEVICE_ID_INTEL_TGLH_SGMII1G_0_ID 0x43ac
|
||||
#define PCI_DEVICE_ID_INTEL_TGLH_SGMII1G_1_ID 0x43a2
|
||||
#define PCI_DEVICE_ID_INTEL_TGL_SGMII1G_ID 0xa0ac
|
||||
|
||||
static const struct pci_device_id intel_eth_pci_id_table[] = {
|
||||
@ -735,6 +737,8 @@ static const struct pci_device_id intel_eth_pci_id_table[] = {
|
||||
{ PCI_DEVICE_DATA(INTEL, EHL_PSE1_SGMII1G_ID, &ehl_pse1_sgmii1g_info) },
|
||||
{ PCI_DEVICE_DATA(INTEL, EHL_PSE1_SGMII2G5_ID, &ehl_pse1_sgmii1g_info) },
|
||||
{ PCI_DEVICE_DATA(INTEL, TGL_SGMII1G_ID, &tgl_sgmii1g_info) },
|
||||
{ PCI_DEVICE_DATA(INTEL, TGLH_SGMII1G_0_ID, &tgl_sgmii1g_info) },
|
||||
{ PCI_DEVICE_DATA(INTEL, TGLH_SGMII1G_1_ID, &tgl_sgmii1g_info) },
|
||||
{}
|
||||
};
|
||||
MODULE_DEVICE_TABLE(pci, intel_eth_pci_id_table);
|
||||
|
||||
@ -135,7 +135,7 @@ static int meson8b_init_rgmii_tx_clk(struct meson8b_dwmac *dwmac)
|
||||
struct device *dev = dwmac->dev;
|
||||
static const struct clk_parent_data mux_parents[] = {
|
||||
{ .fw_name = "clkin0", },
|
||||
{ .fw_name = "clkin1", },
|
||||
{ .index = -1, },
|
||||
};
|
||||
static const struct clk_div_table div_table[] = {
|
||||
{ .div = 2, .val = 2, },
|
||||
|
||||
@ -599,6 +599,7 @@ void cpts_unregister(struct cpts *cpts)
|
||||
|
||||
ptp_clock_unregister(cpts->clock);
|
||||
cpts->clock = NULL;
|
||||
cpts->phc_index = -1;
|
||||
|
||||
cpts_write32(cpts, 0, int_enable);
|
||||
cpts_write32(cpts, 0, control);
|
||||
@ -784,6 +785,7 @@ struct cpts *cpts_create(struct device *dev, void __iomem *regs,
|
||||
cpts->cc.read = cpts_systim_read;
|
||||
cpts->cc.mask = CLOCKSOURCE_MASK(32);
|
||||
cpts->info = cpts_info;
|
||||
cpts->phc_index = -1;
|
||||
|
||||
if (n_ext_ts)
|
||||
cpts->info.n_ext_ts = n_ext_ts;
|
||||
|
||||
@ -326,8 +326,8 @@ gsi_evt_ring_state(struct gsi *gsi, u32 evt_ring_id)
|
||||
}
|
||||
|
||||
/* Issue an event ring command and wait for it to complete */
|
||||
static int evt_ring_command(struct gsi *gsi, u32 evt_ring_id,
|
||||
enum gsi_evt_cmd_opcode opcode)
|
||||
static void evt_ring_command(struct gsi *gsi, u32 evt_ring_id,
|
||||
enum gsi_evt_cmd_opcode opcode)
|
||||
{
|
||||
struct gsi_evt_ring *evt_ring = &gsi->evt_ring[evt_ring_id];
|
||||
struct completion *completion = &evt_ring->completion;
|
||||
@ -340,7 +340,13 @@ static int evt_ring_command(struct gsi *gsi, u32 evt_ring_id,
|
||||
* is issued here. Only permit *this* event ring to trigger
|
||||
* an interrupt, and only enable the event control IRQ type
|
||||
* when we expect it to occur.
|
||||
*
|
||||
* There's a small chance that a previous command completed
|
||||
* after the interrupt was disabled, so make sure we have no
|
||||
* pending interrupts before we enable them.
|
||||
*/
|
||||
iowrite32(~0, gsi->virt + GSI_CNTXT_SRC_EV_CH_IRQ_CLR_OFFSET);
|
||||
|
||||
val = BIT(evt_ring_id);
|
||||
iowrite32(val, gsi->virt + GSI_CNTXT_SRC_EV_CH_IRQ_MSK_OFFSET);
|
||||
gsi_irq_type_enable(gsi, GSI_EV_CTRL);
|
||||
@ -355,19 +361,16 @@ static int evt_ring_command(struct gsi *gsi, u32 evt_ring_id,
|
||||
iowrite32(0, gsi->virt + GSI_CNTXT_SRC_EV_CH_IRQ_MSK_OFFSET);
|
||||
|
||||
if (success)
|
||||
return 0;
|
||||
return;
|
||||
|
||||
dev_err(dev, "GSI command %u for event ring %u timed out, state %u\n",
|
||||
opcode, evt_ring_id, evt_ring->state);
|
||||
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
/* Allocate an event ring in NOT_ALLOCATED state */
|
||||
static int gsi_evt_ring_alloc_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
{
|
||||
struct gsi_evt_ring *evt_ring = &gsi->evt_ring[evt_ring_id];
|
||||
int ret;
|
||||
|
||||
/* Get initial event ring state */
|
||||
evt_ring->state = gsi_evt_ring_state(gsi, evt_ring_id);
|
||||
@ -377,14 +380,16 @@ static int gsi_evt_ring_alloc_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = evt_ring_command(gsi, evt_ring_id, GSI_EVT_ALLOCATE);
|
||||
if (!ret && evt_ring->state != GSI_EVT_RING_STATE_ALLOCATED) {
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after alloc\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
ret = -EIO;
|
||||
}
|
||||
evt_ring_command(gsi, evt_ring_id, GSI_EVT_ALLOCATE);
|
||||
|
||||
return ret;
|
||||
/* If successful the event ring state will have changed */
|
||||
if (evt_ring->state == GSI_EVT_RING_STATE_ALLOCATED)
|
||||
return 0;
|
||||
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after alloc\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* Reset a GSI event ring in ALLOCATED or ERROR state. */
|
||||
@ -392,7 +397,6 @@ static void gsi_evt_ring_reset_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
{
|
||||
struct gsi_evt_ring *evt_ring = &gsi->evt_ring[evt_ring_id];
|
||||
enum gsi_evt_ring_state state = evt_ring->state;
|
||||
int ret;
|
||||
|
||||
if (state != GSI_EVT_RING_STATE_ALLOCATED &&
|
||||
state != GSI_EVT_RING_STATE_ERROR) {
|
||||
@ -401,17 +405,20 @@ static void gsi_evt_ring_reset_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
return;
|
||||
}
|
||||
|
||||
ret = evt_ring_command(gsi, evt_ring_id, GSI_EVT_RESET);
|
||||
if (!ret && evt_ring->state != GSI_EVT_RING_STATE_ALLOCATED)
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after reset\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
evt_ring_command(gsi, evt_ring_id, GSI_EVT_RESET);
|
||||
|
||||
/* If successful the event ring state will have changed */
|
||||
if (evt_ring->state == GSI_EVT_RING_STATE_ALLOCATED)
|
||||
return;
|
||||
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after reset\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
}
|
||||
|
||||
/* Issue a hardware de-allocation request for an allocated event ring */
|
||||
static void gsi_evt_ring_de_alloc_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
{
|
||||
struct gsi_evt_ring *evt_ring = &gsi->evt_ring[evt_ring_id];
|
||||
int ret;
|
||||
|
||||
if (evt_ring->state != GSI_EVT_RING_STATE_ALLOCATED) {
|
||||
dev_err(gsi->dev, "event ring %u state %u before dealloc\n",
|
||||
@ -419,10 +426,14 @@ static void gsi_evt_ring_de_alloc_command(struct gsi *gsi, u32 evt_ring_id)
|
||||
return;
|
||||
}
|
||||
|
||||
ret = evt_ring_command(gsi, evt_ring_id, GSI_EVT_DE_ALLOC);
|
||||
if (!ret && evt_ring->state != GSI_EVT_RING_STATE_NOT_ALLOCATED)
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after dealloc\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
evt_ring_command(gsi, evt_ring_id, GSI_EVT_DE_ALLOC);
|
||||
|
||||
/* If successful the event ring state will have changed */
|
||||
if (evt_ring->state == GSI_EVT_RING_STATE_NOT_ALLOCATED)
|
||||
return;
|
||||
|
||||
dev_err(gsi->dev, "event ring %u bad state %u after dealloc\n",
|
||||
evt_ring_id, evt_ring->state);
|
||||
}
|
||||
|
||||
/* Fetch the current state of a channel from hardware */
|
||||
@ -438,7 +449,7 @@ static enum gsi_channel_state gsi_channel_state(struct gsi_channel *channel)
|
||||
}
|
||||
|
||||
/* Issue a channel command and wait for it to complete */
|
||||
static int
|
||||
static void
|
||||
gsi_channel_command(struct gsi_channel *channel, enum gsi_ch_cmd_opcode opcode)
|
||||
{
|
||||
struct completion *completion = &channel->completion;
|
||||
@ -453,7 +464,13 @@ gsi_channel_command(struct gsi_channel *channel, enum gsi_ch_cmd_opcode opcode)
|
||||
* issued here. So we only permit *this* channel to trigger
|
||||
* an interrupt and only enable the channel control IRQ type
|
||||
* when we expect it to occur.
|
||||
*
|
||||
* There's a small chance that a previous command completed
|
||||
* after the interrupt was disabled, so make sure we have no
|
||||
* pending interrupts before we enable them.
|
||||
*/
|
||||
iowrite32(~0, gsi->virt + GSI_CNTXT_SRC_CH_IRQ_CLR_OFFSET);
|
||||
|
||||
val = BIT(channel_id);
|
||||
iowrite32(val, gsi->virt + GSI_CNTXT_SRC_CH_IRQ_MSK_OFFSET);
|
||||
gsi_irq_type_enable(gsi, GSI_CH_CTRL);
|
||||
@ -467,12 +484,10 @@ gsi_channel_command(struct gsi_channel *channel, enum gsi_ch_cmd_opcode opcode)
|
||||
iowrite32(0, gsi->virt + GSI_CNTXT_SRC_CH_IRQ_MSK_OFFSET);
|
||||
|
||||
if (success)
|
||||
return 0;
|
||||
return;
|
||||
|
||||
dev_err(dev, "GSI command %u for channel %u timed out, state %u\n",
|
||||
opcode, channel_id, gsi_channel_state(channel));
|
||||
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
/* Allocate GSI channel in NOT_ALLOCATED state */
|
||||
@ -481,7 +496,6 @@ static int gsi_channel_alloc_command(struct gsi *gsi, u32 channel_id)
|
||||
struct gsi_channel *channel = &gsi->channel[channel_id];
|
||||
struct device *dev = gsi->dev;
|
||||
enum gsi_channel_state state;
|
||||
int ret;
|
||||
|
||||
/* Get initial channel state */
|
||||
state = gsi_channel_state(channel);
|
||||
@ -491,17 +505,17 @@ static int gsi_channel_alloc_command(struct gsi *gsi, u32 channel_id)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = gsi_channel_command(channel, GSI_CH_ALLOCATE);
|
||||
gsi_channel_command(channel, GSI_CH_ALLOCATE);
|
||||
|
||||
/* Channel state will normally have been updated */
|
||||
/* If successful the channel state will have changed */
|
||||
state = gsi_channel_state(channel);
|
||||
if (!ret && state != GSI_CHANNEL_STATE_ALLOCATED) {
|
||||
dev_err(dev, "channel %u bad state %u after alloc\n",
|
||||
channel_id, state);
|
||||
ret = -EIO;
|
||||
}
|
||||
if (state == GSI_CHANNEL_STATE_ALLOCATED)
|
||||
return 0;
|
||||
|
||||
return ret;
|
||||
dev_err(dev, "channel %u bad state %u after alloc\n",
|
||||
channel_id, state);
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* Start an ALLOCATED channel */
|
||||
@ -509,7 +523,6 @@ static int gsi_channel_start_command(struct gsi_channel *channel)
|
||||
{
|
||||
struct device *dev = channel->gsi->dev;
|
||||
enum gsi_channel_state state;
|
||||
int ret;
|
||||
|
||||
state = gsi_channel_state(channel);
|
||||
if (state != GSI_CHANNEL_STATE_ALLOCATED &&
|
||||
@ -519,17 +532,17 @@ static int gsi_channel_start_command(struct gsi_channel *channel)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = gsi_channel_command(channel, GSI_CH_START);
|
||||
gsi_channel_command(channel, GSI_CH_START);
|
||||
|
||||
/* Channel state will normally have been updated */
|
||||
/* If successful the channel state will have changed */
|
||||
state = gsi_channel_state(channel);
|
||||
if (!ret && state != GSI_CHANNEL_STATE_STARTED) {
|
||||
dev_err(dev, "channel %u bad state %u after start\n",
|
||||
gsi_channel_id(channel), state);
|
||||
ret = -EIO;
|
||||
}
|
||||
if (state == GSI_CHANNEL_STATE_STARTED)
|
||||
return 0;
|
||||
|
||||
return ret;
|
||||
dev_err(dev, "channel %u bad state %u after start\n",
|
||||
gsi_channel_id(channel), state);
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* Stop a GSI channel in STARTED state */
|
||||
@ -537,7 +550,6 @@ static int gsi_channel_stop_command(struct gsi_channel *channel)
|
||||
{
|
||||
struct device *dev = channel->gsi->dev;
|
||||
enum gsi_channel_state state;
|
||||
int ret;
|
||||
|
||||
state = gsi_channel_state(channel);
|
||||
|
||||
@ -554,12 +566,12 @@ static int gsi_channel_stop_command(struct gsi_channel *channel)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = gsi_channel_command(channel, GSI_CH_STOP);
|
||||
gsi_channel_command(channel, GSI_CH_STOP);
|
||||
|
||||
/* Channel state will normally have been updated */
|
||||
/* If successful the channel state will have changed */
|
||||
state = gsi_channel_state(channel);
|
||||
if (ret || state == GSI_CHANNEL_STATE_STOPPED)
|
||||
return ret;
|
||||
if (state == GSI_CHANNEL_STATE_STOPPED)
|
||||
return 0;
|
||||
|
||||
/* We may have to try again if stop is in progress */
|
||||
if (state == GSI_CHANNEL_STATE_STOP_IN_PROC)
|
||||
@ -576,7 +588,6 @@ static void gsi_channel_reset_command(struct gsi_channel *channel)
|
||||
{
|
||||
struct device *dev = channel->gsi->dev;
|
||||
enum gsi_channel_state state;
|
||||
int ret;
|
||||
|
||||
msleep(1); /* A short delay is required before a RESET command */
|
||||
|
||||
@ -590,11 +601,11 @@ static void gsi_channel_reset_command(struct gsi_channel *channel)
|
||||
return;
|
||||
}
|
||||
|
||||
ret = gsi_channel_command(channel, GSI_CH_RESET);
|
||||
gsi_channel_command(channel, GSI_CH_RESET);
|
||||
|
||||
/* Channel state will normally have been updated */
|
||||
/* If successful the channel state will have changed */
|
||||
state = gsi_channel_state(channel);
|
||||
if (!ret && state != GSI_CHANNEL_STATE_ALLOCATED)
|
||||
if (state != GSI_CHANNEL_STATE_ALLOCATED)
|
||||
dev_err(dev, "channel %u bad state %u after reset\n",
|
||||
gsi_channel_id(channel), state);
|
||||
}
|
||||
@ -605,7 +616,6 @@ static void gsi_channel_de_alloc_command(struct gsi *gsi, u32 channel_id)
|
||||
struct gsi_channel *channel = &gsi->channel[channel_id];
|
||||
struct device *dev = gsi->dev;
|
||||
enum gsi_channel_state state;
|
||||
int ret;
|
||||
|
||||
state = gsi_channel_state(channel);
|
||||
if (state != GSI_CHANNEL_STATE_ALLOCATED) {
|
||||
@ -614,11 +624,12 @@ static void gsi_channel_de_alloc_command(struct gsi *gsi, u32 channel_id)
|
||||
return;
|
||||
}
|
||||
|
||||
ret = gsi_channel_command(channel, GSI_CH_DE_ALLOC);
|
||||
gsi_channel_command(channel, GSI_CH_DE_ALLOC);
|
||||
|
||||
/* Channel state will normally have been updated */
|
||||
/* If successful the channel state will have changed */
|
||||
state = gsi_channel_state(channel);
|
||||
if (!ret && state != GSI_CHANNEL_STATE_NOT_ALLOCATED)
|
||||
|
||||
if (state != GSI_CHANNEL_STATE_NOT_ALLOCATED)
|
||||
dev_err(dev, "channel %u bad state %u after dealloc\n",
|
||||
channel_id, state);
|
||||
}
|
||||
|
||||
@ -115,13 +115,13 @@ static int ipa_interconnect_enable(struct ipa *ipa)
|
||||
return ret;
|
||||
|
||||
data = &clock->interconnect_data[IPA_INTERCONNECT_IMEM];
|
||||
ret = icc_set_bw(clock->memory_path, data->average_rate,
|
||||
ret = icc_set_bw(clock->imem_path, data->average_rate,
|
||||
data->peak_rate);
|
||||
if (ret)
|
||||
goto err_memory_path_disable;
|
||||
|
||||
data = &clock->interconnect_data[IPA_INTERCONNECT_CONFIG];
|
||||
ret = icc_set_bw(clock->memory_path, data->average_rate,
|
||||
ret = icc_set_bw(clock->config_path, data->average_rate,
|
||||
data->peak_rate);
|
||||
if (ret)
|
||||
goto err_imem_path_disable;
|
||||
|
||||
@ -1365,7 +1365,7 @@ static struct sk_buff *tun_napi_alloc_frags(struct tun_file *tfile,
|
||||
int i;
|
||||
|
||||
if (it->nr_segs > MAX_SKB_FRAGS + 1)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
return ERR_PTR(-EMSGSIZE);
|
||||
|
||||
local_bh_disable();
|
||||
skb = napi_get_frags(&tfile->napi);
|
||||
|
||||
@ -1863,9 +1863,6 @@ static void cdc_ncm_status(struct usbnet *dev, struct urb *urb)
|
||||
* USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be
|
||||
* sent by device after USB_CDC_NOTIFY_SPEED_CHANGE.
|
||||
*/
|
||||
netif_info(dev, link, dev->net,
|
||||
"network connection: %sconnected\n",
|
||||
!!event->wValue ? "" : "dis");
|
||||
usbnet_link_change(dev, !!event->wValue, 0);
|
||||
break;
|
||||
|
||||
|
||||
@ -1013,6 +1013,7 @@ static const struct usb_device_id products[] = {
|
||||
{QMI_MATCH_FF_FF_FF(0x2c7c, 0x0125)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */
|
||||
{QMI_MATCH_FF_FF_FF(0x2c7c, 0x0306)}, /* Quectel EP06/EG06/EM06 */
|
||||
{QMI_MATCH_FF_FF_FF(0x2c7c, 0x0512)}, /* Quectel EG12/EM12 */
|
||||
{QMI_MATCH_FF_FF_FF(0x2c7c, 0x0620)}, /* Quectel EM160R-GL */
|
||||
{QMI_MATCH_FF_FF_FF(0x2c7c, 0x0800)}, /* Quectel RM500Q-GL */
|
||||
|
||||
/* 3. Combined interface devices matching on interface number */
|
||||
|
||||
@ -2093,14 +2093,16 @@ static int virtnet_set_channels(struct net_device *dev,
|
||||
|
||||
get_online_cpus();
|
||||
err = _virtnet_set_queues(vi, queue_pairs);
|
||||
if (!err) {
|
||||
netif_set_real_num_tx_queues(dev, queue_pairs);
|
||||
netif_set_real_num_rx_queues(dev, queue_pairs);
|
||||
|
||||
virtnet_set_affinity(vi);
|
||||
if (err) {
|
||||
put_online_cpus();
|
||||
goto err;
|
||||
}
|
||||
virtnet_set_affinity(vi);
|
||||
put_online_cpus();
|
||||
|
||||
netif_set_real_num_tx_queues(dev, queue_pairs);
|
||||
netif_set_real_num_rx_queues(dev, queue_pairs);
|
||||
err:
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
@ -569,6 +569,13 @@ static void ppp_timer(struct timer_list *t)
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&ppp->lock, flags);
|
||||
/* mod_timer could be called after we entered this function but
|
||||
* before we got the lock.
|
||||
*/
|
||||
if (timer_pending(&proto->timer)) {
|
||||
spin_unlock_irqrestore(&ppp->lock, flags);
|
||||
return;
|
||||
}
|
||||
switch (proto->state) {
|
||||
case STOPPING:
|
||||
case REQ_SENT:
|
||||
|
||||
@ -185,7 +185,7 @@ int ath11k_core_suspend(struct ath11k_base *ab)
|
||||
ath11k_hif_ce_irq_disable(ab);
|
||||
|
||||
ret = ath11k_hif_suspend(ab);
|
||||
if (!ret) {
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "failed to suspend hif: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -2294,6 +2294,7 @@ static void ath11k_dp_rx_h_ppdu(struct ath11k *ar, struct hal_rx_desc *rx_desc,
|
||||
{
|
||||
u8 channel_num;
|
||||
u32 center_freq;
|
||||
struct ieee80211_channel *channel;
|
||||
|
||||
rx_status->freq = 0;
|
||||
rx_status->rate_idx = 0;
|
||||
@ -2314,9 +2315,12 @@ static void ath11k_dp_rx_h_ppdu(struct ath11k *ar, struct hal_rx_desc *rx_desc,
|
||||
rx_status->band = NL80211_BAND_5GHZ;
|
||||
} else {
|
||||
spin_lock_bh(&ar->data_lock);
|
||||
rx_status->band = ar->rx_channel->band;
|
||||
channel_num =
|
||||
ieee80211_frequency_to_channel(ar->rx_channel->center_freq);
|
||||
channel = ar->rx_channel;
|
||||
if (channel) {
|
||||
rx_status->band = channel->band;
|
||||
channel_num =
|
||||
ieee80211_frequency_to_channel(channel->center_freq);
|
||||
}
|
||||
spin_unlock_bh(&ar->data_lock);
|
||||
ath11k_dbg_dump(ar->ab, ATH11K_DBG_DATA, NULL, "rx_desc: ",
|
||||
rx_desc, sizeof(struct hal_rx_desc));
|
||||
|
||||
@ -3021,6 +3021,7 @@ static int ath11k_mac_station_add(struct ath11k *ar,
|
||||
}
|
||||
|
||||
if (ab->hw_params.vdev_start_delay &&
|
||||
!arvif->is_started &&
|
||||
arvif->vdev_type != WMI_VDEV_TYPE_AP) {
|
||||
ret = ath11k_start_vdev_delay(ar->hw, vif);
|
||||
if (ret) {
|
||||
@ -5284,7 +5285,8 @@ ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
|
||||
/* for QCA6390 bss peer must be created before vdev_start */
|
||||
if (ab->hw_params.vdev_start_delay &&
|
||||
arvif->vdev_type != WMI_VDEV_TYPE_AP &&
|
||||
arvif->vdev_type != WMI_VDEV_TYPE_MONITOR) {
|
||||
arvif->vdev_type != WMI_VDEV_TYPE_MONITOR &&
|
||||
!ath11k_peer_find_by_vdev_id(ab, arvif->vdev_id)) {
|
||||
memcpy(&arvif->chanctx, ctx, sizeof(*ctx));
|
||||
ret = 0;
|
||||
goto out;
|
||||
@ -5295,7 +5297,9 @@ ath11k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (ab->hw_params.vdev_start_delay) {
|
||||
if (ab->hw_params.vdev_start_delay &&
|
||||
(arvif->vdev_type == WMI_VDEV_TYPE_AP ||
|
||||
arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)) {
|
||||
param.vdev_id = arvif->vdev_id;
|
||||
param.peer_type = WMI_PEER_TYPE_DEFAULT;
|
||||
param.peer_addr = ar->mac_addr;
|
||||
|
||||
@ -274,7 +274,7 @@ static int ath11k_pci_fix_l1ss(struct ath11k_base *ab)
|
||||
PCIE_QSERDES_COM_SYSCLK_EN_SEL_REG,
|
||||
PCIE_QSERDES_COM_SYSCLK_EN_SEL_VAL,
|
||||
PCIE_QSERDES_COM_SYSCLK_EN_SEL_MSK);
|
||||
if (!ret) {
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "failed to set sysclk: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
@ -283,7 +283,7 @@ static int ath11k_pci_fix_l1ss(struct ath11k_base *ab)
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG1_REG,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG1_VAL,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG_MSK);
|
||||
if (!ret) {
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "failed to set dtct config1 error: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
@ -292,7 +292,7 @@ static int ath11k_pci_fix_l1ss(struct ath11k_base *ab)
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG2_REG,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG2_VAL,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG_MSK);
|
||||
if (!ret) {
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "failed to set dtct config2: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
@ -301,7 +301,7 @@ static int ath11k_pci_fix_l1ss(struct ath11k_base *ab)
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG4_REG,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG4_VAL,
|
||||
PCIE_USB3_PCS_MISC_OSC_DTCT_CONFIG_MSK);
|
||||
if (!ret) {
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "failed to set dtct config4: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
@ -886,6 +886,32 @@ static void ath11k_pci_free_region(struct ath11k_pci *ab_pci)
|
||||
pci_disable_device(pci_dev);
|
||||
}
|
||||
|
||||
static void ath11k_pci_aspm_disable(struct ath11k_pci *ab_pci)
|
||||
{
|
||||
struct ath11k_base *ab = ab_pci->ab;
|
||||
|
||||
pcie_capability_read_word(ab_pci->pdev, PCI_EXP_LNKCTL,
|
||||
&ab_pci->link_ctl);
|
||||
|
||||
ath11k_dbg(ab, ATH11K_DBG_PCI, "pci link_ctl 0x%04x L0s %d L1 %d\n",
|
||||
ab_pci->link_ctl,
|
||||
u16_get_bits(ab_pci->link_ctl, PCI_EXP_LNKCTL_ASPM_L0S),
|
||||
u16_get_bits(ab_pci->link_ctl, PCI_EXP_LNKCTL_ASPM_L1));
|
||||
|
||||
/* disable L0s and L1 */
|
||||
pcie_capability_write_word(ab_pci->pdev, PCI_EXP_LNKCTL,
|
||||
ab_pci->link_ctl & ~PCI_EXP_LNKCTL_ASPMC);
|
||||
|
||||
set_bit(ATH11K_PCI_ASPM_RESTORE, &ab_pci->flags);
|
||||
}
|
||||
|
||||
static void ath11k_pci_aspm_restore(struct ath11k_pci *ab_pci)
|
||||
{
|
||||
if (test_and_clear_bit(ATH11K_PCI_ASPM_RESTORE, &ab_pci->flags))
|
||||
pcie_capability_write_word(ab_pci->pdev, PCI_EXP_LNKCTL,
|
||||
ab_pci->link_ctl);
|
||||
}
|
||||
|
||||
static int ath11k_pci_power_up(struct ath11k_base *ab)
|
||||
{
|
||||
struct ath11k_pci *ab_pci = ath11k_pci_priv(ab);
|
||||
@ -895,6 +921,11 @@ static int ath11k_pci_power_up(struct ath11k_base *ab)
|
||||
clear_bit(ATH11K_PCI_FLAG_INIT_DONE, &ab_pci->flags);
|
||||
ath11k_pci_sw_reset(ab_pci->ab, true);
|
||||
|
||||
/* Disable ASPM during firmware download due to problems switching
|
||||
* to AMSS state.
|
||||
*/
|
||||
ath11k_pci_aspm_disable(ab_pci);
|
||||
|
||||
ret = ath11k_mhi_start(ab_pci);
|
||||
if (ret) {
|
||||
ath11k_err(ab, "failed to start mhi: %d\n", ret);
|
||||
@ -908,6 +939,9 @@ static void ath11k_pci_power_down(struct ath11k_base *ab)
|
||||
{
|
||||
struct ath11k_pci *ab_pci = ath11k_pci_priv(ab);
|
||||
|
||||
/* restore aspm in case firmware bootup fails */
|
||||
ath11k_pci_aspm_restore(ab_pci);
|
||||
|
||||
ath11k_pci_force_wake(ab_pci->ab);
|
||||
ath11k_mhi_stop(ab_pci);
|
||||
clear_bit(ATH11K_PCI_FLAG_INIT_DONE, &ab_pci->flags);
|
||||
@ -965,6 +999,8 @@ static int ath11k_pci_start(struct ath11k_base *ab)
|
||||
|
||||
set_bit(ATH11K_PCI_FLAG_INIT_DONE, &ab_pci->flags);
|
||||
|
||||
ath11k_pci_aspm_restore(ab_pci);
|
||||
|
||||
ath11k_pci_ce_irqs_enable(ab);
|
||||
ath11k_ce_rx_post_buf(ab);
|
||||
|
||||
|
||||
@ -63,6 +63,7 @@ struct ath11k_msi_config {
|
||||
enum ath11k_pci_flags {
|
||||
ATH11K_PCI_FLAG_INIT_DONE,
|
||||
ATH11K_PCI_FLAG_IS_MSI_64,
|
||||
ATH11K_PCI_ASPM_RESTORE,
|
||||
};
|
||||
|
||||
struct ath11k_pci {
|
||||
@ -80,6 +81,7 @@ struct ath11k_pci {
|
||||
|
||||
/* enum ath11k_pci_flags */
|
||||
unsigned long flags;
|
||||
u16 link_ctl;
|
||||
};
|
||||
|
||||
static inline struct ath11k_pci *ath11k_pci_priv(struct ath11k_base *ab)
|
||||
|
||||
@ -76,6 +76,23 @@ struct ath11k_peer *ath11k_peer_find_by_id(struct ath11k_base *ab,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct ath11k_peer *ath11k_peer_find_by_vdev_id(struct ath11k_base *ab,
|
||||
int vdev_id)
|
||||
{
|
||||
struct ath11k_peer *peer;
|
||||
|
||||
spin_lock_bh(&ab->base_lock);
|
||||
|
||||
list_for_each_entry(peer, &ab->peers, list) {
|
||||
if (vdev_id == peer->vdev_id) {
|
||||
spin_unlock_bh(&ab->base_lock);
|
||||
return peer;
|
||||
}
|
||||
}
|
||||
spin_unlock_bh(&ab->base_lock);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ath11k_peer_unmap_event(struct ath11k_base *ab, u16 peer_id)
|
||||
{
|
||||
struct ath11k_peer *peer;
|
||||
|
||||
@ -43,5 +43,7 @@ int ath11k_peer_create(struct ath11k *ar, struct ath11k_vif *arvif,
|
||||
struct ieee80211_sta *sta, struct peer_create_params *param);
|
||||
int ath11k_wait_for_peer_delete_done(struct ath11k *ar, u32 vdev_id,
|
||||
const u8 *addr);
|
||||
struct ath11k_peer *ath11k_peer_find_by_vdev_id(struct ath11k_base *ab,
|
||||
int vdev_id);
|
||||
|
||||
#endif /* _PEER_H_ */
|
||||
|
||||
@ -1660,6 +1660,7 @@ static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
|
||||
struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
|
||||
struct qmi_txn txn = {};
|
||||
int ret = 0, i;
|
||||
bool delayed;
|
||||
|
||||
req = kzalloc(sizeof(*req), GFP_KERNEL);
|
||||
if (!req)
|
||||
@ -1672,11 +1673,13 @@ static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
|
||||
* failure to FW and FW will then request mulitple blocks of small
|
||||
* chunk size memory.
|
||||
*/
|
||||
if (!ab->bus_params.fixed_mem_region && ab->qmi.mem_seg_count <= 2) {
|
||||
if (!ab->bus_params.fixed_mem_region && ab->qmi.target_mem_delayed) {
|
||||
delayed = true;
|
||||
ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi delays mem_request %d\n",
|
||||
ab->qmi.mem_seg_count);
|
||||
memset(req, 0, sizeof(*req));
|
||||
} else {
|
||||
delayed = false;
|
||||
req->mem_seg_len = ab->qmi.mem_seg_count;
|
||||
|
||||
for (i = 0; i < req->mem_seg_len ; i++) {
|
||||
@ -1708,6 +1711,12 @@ static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
|
||||
}
|
||||
|
||||
if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
|
||||
/* the error response is expected when
|
||||
* target_mem_delayed is true.
|
||||
*/
|
||||
if (delayed && resp.resp.error == 0)
|
||||
goto out;
|
||||
|
||||
ath11k_warn(ab, "Respond mem req failed, result: %d, err: %d\n",
|
||||
resp.resp.result, resp.resp.error);
|
||||
ret = -EINVAL;
|
||||
@ -1742,6 +1751,8 @@ static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
|
||||
int i;
|
||||
struct target_mem_chunk *chunk;
|
||||
|
||||
ab->qmi.target_mem_delayed = false;
|
||||
|
||||
for (i = 0; i < ab->qmi.mem_seg_count; i++) {
|
||||
chunk = &ab->qmi.target_mem[i];
|
||||
chunk->vaddr = dma_alloc_coherent(ab->dev,
|
||||
@ -1749,6 +1760,15 @@ static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
|
||||
&chunk->paddr,
|
||||
GFP_KERNEL);
|
||||
if (!chunk->vaddr) {
|
||||
if (ab->qmi.mem_seg_count <= 2) {
|
||||
ath11k_dbg(ab, ATH11K_DBG_QMI,
|
||||
"qmi dma allocation failed (%d B type %u), will try later with small size\n",
|
||||
chunk->size,
|
||||
chunk->type);
|
||||
ath11k_qmi_free_target_mem_chunk(ab);
|
||||
ab->qmi.target_mem_delayed = true;
|
||||
return 0;
|
||||
}
|
||||
ath11k_err(ab, "failed to alloc memory, size: 0x%x, type: %u\n",
|
||||
chunk->size,
|
||||
chunk->type);
|
||||
@ -2517,7 +2537,7 @@ static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
|
||||
ret);
|
||||
return;
|
||||
}
|
||||
} else if (msg->mem_seg_len > 2) {
|
||||
} else {
|
||||
ret = ath11k_qmi_alloc_target_mem_chunk(ab);
|
||||
if (ret) {
|
||||
ath11k_warn(ab, "qmi failed to alloc target memory: %d\n",
|
||||
|
||||
@ -125,6 +125,7 @@ struct ath11k_qmi {
|
||||
struct target_mem_chunk target_mem[ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01];
|
||||
u32 mem_seg_count;
|
||||
u32 target_mem_mode;
|
||||
bool target_mem_delayed;
|
||||
u8 cal_done;
|
||||
struct target_info target;
|
||||
struct m3_mem_region m3_mem;
|
||||
|
||||
@ -3460,6 +3460,9 @@ int ath11k_wmi_set_hw_mode(struct ath11k_base *ab,
|
||||
len = sizeof(*cmd);
|
||||
|
||||
skb = ath11k_wmi_alloc_skb(wmi_ab, len);
|
||||
if (!skb)
|
||||
return -ENOMEM;
|
||||
|
||||
cmd = (struct wmi_pdev_set_hw_mode_cmd_param *)skb->data;
|
||||
|
||||
cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_HW_MODE_CMD) |
|
||||
|
||||
@ -40,9 +40,9 @@ static const struct ieee80211_iface_limit if_limits[] = {
|
||||
.types = BIT(NL80211_IFTYPE_ADHOC)
|
||||
}, {
|
||||
.max = 16,
|
||||
.types = BIT(NL80211_IFTYPE_AP) |
|
||||
.types = BIT(NL80211_IFTYPE_AP)
|
||||
#ifdef CONFIG_MAC80211_MESH
|
||||
BIT(NL80211_IFTYPE_MESH_POINT)
|
||||
| BIT(NL80211_IFTYPE_MESH_POINT)
|
||||
#endif
|
||||
}, {
|
||||
.max = MT7915_MAX_INTERFACES,
|
||||
|
||||
@ -157,10 +157,14 @@ static void mt76s_net_worker(struct mt76_worker *w)
|
||||
|
||||
static int mt76s_process_tx_queue(struct mt76_dev *dev, struct mt76_queue *q)
|
||||
{
|
||||
bool wake, mcu = q == dev->q_mcu[MT_MCUQ_WM];
|
||||
struct mt76_queue_entry entry;
|
||||
int nframes = 0;
|
||||
bool mcu;
|
||||
|
||||
if (!q)
|
||||
return 0;
|
||||
|
||||
mcu = q == dev->q_mcu[MT_MCUQ_WM];
|
||||
while (q->queued > 0) {
|
||||
if (!q->entry[q->tail].done)
|
||||
break;
|
||||
@ -177,21 +181,12 @@ static int mt76s_process_tx_queue(struct mt76_dev *dev, struct mt76_queue *q)
|
||||
nframes++;
|
||||
}
|
||||
|
||||
wake = q->stopped && q->queued < q->ndesc - 8;
|
||||
if (wake)
|
||||
q->stopped = false;
|
||||
|
||||
if (!q->queued)
|
||||
wake_up(&dev->tx_wait);
|
||||
|
||||
if (mcu)
|
||||
goto out;
|
||||
if (!mcu)
|
||||
mt76_txq_schedule(&dev->phy, q->qid);
|
||||
|
||||
mt76_txq_schedule(&dev->phy, q->qid);
|
||||
|
||||
if (wake)
|
||||
ieee80211_wake_queue(dev->hw, q->qid);
|
||||
out:
|
||||
return nframes;
|
||||
}
|
||||
|
||||
|
||||
@ -811,11 +811,12 @@ static void mt76u_status_worker(struct mt76_worker *w)
|
||||
struct mt76_dev *dev = container_of(usb, struct mt76_dev, usb);
|
||||
struct mt76_queue_entry entry;
|
||||
struct mt76_queue *q;
|
||||
bool wake;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < IEEE80211_NUM_ACS; i++) {
|
||||
q = dev->phy.q_tx[i];
|
||||
if (!q)
|
||||
continue;
|
||||
|
||||
while (q->queued > 0) {
|
||||
if (!q->entry[q->tail].done)
|
||||
@ -827,10 +828,6 @@ static void mt76u_status_worker(struct mt76_worker *w)
|
||||
mt76_queue_tx_complete(dev, q, &entry);
|
||||
}
|
||||
|
||||
wake = q->stopped && q->queued < q->ndesc - 8;
|
||||
if (wake)
|
||||
q->stopped = false;
|
||||
|
||||
if (!q->queued)
|
||||
wake_up(&dev->tx_wait);
|
||||
|
||||
@ -839,8 +836,6 @@ static void mt76u_status_worker(struct mt76_worker *w)
|
||||
if (dev->drv->tx_status_data &&
|
||||
!test_and_set_bit(MT76_READING_STATS, &dev->phy.state))
|
||||
queue_work(dev->wq, &dev->usb.stat_work);
|
||||
if (wake)
|
||||
ieee80211_wake_queue(dev->hw, i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -78,7 +78,6 @@ static void rtl_fw_do_work(const struct firmware *firmware, void *context,
|
||||
|
||||
rtl_dbg(rtlpriv, COMP_ERR, DBG_LOUD,
|
||||
"Firmware callback routine entered!\n");
|
||||
complete(&rtlpriv->firmware_loading_complete);
|
||||
if (!firmware) {
|
||||
if (rtlpriv->cfg->alt_fw_name) {
|
||||
err = request_firmware(&firmware,
|
||||
@ -91,13 +90,13 @@ static void rtl_fw_do_work(const struct firmware *firmware, void *context,
|
||||
}
|
||||
pr_err("Selected firmware is not available\n");
|
||||
rtlpriv->max_fw_size = 0;
|
||||
return;
|
||||
goto exit;
|
||||
}
|
||||
found_alt:
|
||||
if (firmware->size > rtlpriv->max_fw_size) {
|
||||
pr_err("Firmware is too big!\n");
|
||||
release_firmware(firmware);
|
||||
return;
|
||||
goto exit;
|
||||
}
|
||||
if (!is_wow) {
|
||||
memcpy(rtlpriv->rtlhal.pfirmware, firmware->data,
|
||||
@ -109,6 +108,9 @@ static void rtl_fw_do_work(const struct firmware *firmware, void *context,
|
||||
rtlpriv->rtlhal.wowlan_fwsize = firmware->size;
|
||||
}
|
||||
release_firmware(firmware);
|
||||
|
||||
exit:
|
||||
complete(&rtlpriv->firmware_loading_complete);
|
||||
}
|
||||
|
||||
void rtl_fw_cb(const struct firmware *firmware, void *context)
|
||||
|
||||
@ -863,6 +863,7 @@ static void handle_tx_zerocopy(struct vhost_net *net, struct socket *sock)
|
||||
size_t len, total_len = 0;
|
||||
int err;
|
||||
struct vhost_net_ubuf_ref *ubufs;
|
||||
struct ubuf_info *ubuf;
|
||||
bool zcopy_used;
|
||||
int sent_pkts = 0;
|
||||
|
||||
@ -895,9 +896,7 @@ static void handle_tx_zerocopy(struct vhost_net *net, struct socket *sock)
|
||||
|
||||
/* use msg_control to pass vhost zerocopy ubuf info to skb */
|
||||
if (zcopy_used) {
|
||||
struct ubuf_info *ubuf;
|
||||
ubuf = nvq->ubuf_info + nvq->upend_idx;
|
||||
|
||||
vq->heads[nvq->upend_idx].id = cpu_to_vhost32(vq, head);
|
||||
vq->heads[nvq->upend_idx].len = VHOST_DMA_IN_PROGRESS;
|
||||
ubuf->callback = vhost_zerocopy_callback;
|
||||
@ -927,7 +926,8 @@ static void handle_tx_zerocopy(struct vhost_net *net, struct socket *sock)
|
||||
err = sock->ops->sendmsg(sock, &msg, len);
|
||||
if (unlikely(err < 0)) {
|
||||
if (zcopy_used) {
|
||||
vhost_net_ubuf_put(ubufs);
|
||||
if (vq->heads[ubuf->desc].len == VHOST_DMA_IN_PROGRESS)
|
||||
vhost_net_ubuf_put(ubufs);
|
||||
nvq->upend_idx = ((unsigned)nvq->upend_idx - 1)
|
||||
% UIO_MAXIOV;
|
||||
}
|
||||
|
||||
@ -168,12 +168,14 @@ static inline void red_set_vars(struct red_vars *v)
|
||||
v->qcount = -1;
|
||||
}
|
||||
|
||||
static inline bool red_check_params(u32 qth_min, u32 qth_max, u8 Wlog)
|
||||
static inline bool red_check_params(u32 qth_min, u32 qth_max, u8 Wlog, u8 Scell_log)
|
||||
{
|
||||
if (fls(qth_min) + Wlog > 32)
|
||||
return false;
|
||||
if (fls(qth_max) + Wlog > 32)
|
||||
return false;
|
||||
if (Scell_log >= 32)
|
||||
return false;
|
||||
if (qth_max < qth_min)
|
||||
return false;
|
||||
return true;
|
||||
|
||||
@ -58,10 +58,6 @@ struct xdp_sock {
|
||||
|
||||
struct xsk_queue *tx ____cacheline_aligned_in_smp;
|
||||
struct list_head tx_list;
|
||||
/* Mutual exclusion of NAPI TX thread and sendmsg error paths
|
||||
* in the SKB destructor callback.
|
||||
*/
|
||||
spinlock_t tx_completion_lock;
|
||||
/* Protects generic receive. */
|
||||
spinlock_t rx_lock;
|
||||
|
||||
|
||||
@ -73,6 +73,11 @@ struct xsk_buff_pool {
|
||||
bool dma_need_sync;
|
||||
bool unaligned;
|
||||
void *addrs;
|
||||
/* Mutual exclusion of the completion ring in the SKB mode. Two cases to protect:
|
||||
* NAPI TX thread and sendmsg error paths in the SKB destructor callback and when
|
||||
* sockets share a single cq when the same netdev and queue id is shared.
|
||||
*/
|
||||
spinlock_t cq_lock;
|
||||
struct xdp_buff_xsk *free_heads[];
|
||||
};
|
||||
|
||||
|
||||
@ -293,6 +293,7 @@ enum nft_rule_compat_attributes {
|
||||
* @NFT_SET_EVAL: set can be updated from the evaluation path
|
||||
* @NFT_SET_OBJECT: set contains stateful objects
|
||||
* @NFT_SET_CONCAT: set contains a concatenation
|
||||
* @NFT_SET_EXPR: set contains expressions
|
||||
*/
|
||||
enum nft_set_flags {
|
||||
NFT_SET_ANONYMOUS = 0x1,
|
||||
@ -303,6 +304,7 @@ enum nft_set_flags {
|
||||
NFT_SET_EVAL = 0x20,
|
||||
NFT_SET_OBJECT = 0x40,
|
||||
NFT_SET_CONCAT = 0x80,
|
||||
NFT_SET_EXPR = 0x100,
|
||||
};
|
||||
|
||||
/**
|
||||
@ -706,6 +708,7 @@ enum nft_dynset_ops {
|
||||
|
||||
enum nft_dynset_flags {
|
||||
NFT_DYNSET_F_INV = (1 << 0),
|
||||
NFT_DYNSET_F_EXPR = (1 << 1),
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@ -116,7 +116,7 @@ struct pppol2tp_ioc_stats {
|
||||
#define PPPIOCGCHAN _IOR('t', 55, int) /* get ppp channel number */
|
||||
#define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats)
|
||||
#define PPPIOCBRIDGECHAN _IOW('t', 53, int) /* bridge one channel to another */
|
||||
#define PPPIOCUNBRIDGECHAN _IO('t', 54) /* unbridge channel */
|
||||
#define PPPIOCUNBRIDGECHAN _IO('t', 52) /* unbridge channel */
|
||||
|
||||
#define SIOCGPPPSTATS (SIOCDEVPRIVATE + 0)
|
||||
#define SIOCGPPPVER (SIOCDEVPRIVATE + 1) /* NEVER change this!! */
|
||||
|
||||
@ -152,6 +152,7 @@ static void htab_init_buckets(struct bpf_htab *htab)
|
||||
lockdep_set_class(&htab->buckets[i].lock,
|
||||
&htab->lockdep_key);
|
||||
}
|
||||
cond_resched();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -17,7 +17,6 @@
|
||||
#include <linux/fs.h>
|
||||
#include <linux/license.h>
|
||||
#include <linux/filter.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/idr.h>
|
||||
#include <linux/cred.h>
|
||||
|
||||
@ -37,7 +37,7 @@ static struct task_struct *task_seq_get_next(struct pid_namespace *ns,
|
||||
if (!task) {
|
||||
++*tid;
|
||||
goto retry;
|
||||
} else if (skip_if_dup_files && task->tgid != task->pid &&
|
||||
} else if (skip_if_dup_files && !thread_group_leader(task) &&
|
||||
task->files == task->group_leader->files) {
|
||||
put_task_struct(task);
|
||||
task = NULL;
|
||||
@ -151,14 +151,14 @@ task_file_seq_get_next(struct bpf_iter_seq_task_file_info *info)
|
||||
curr_task = info->task;
|
||||
curr_fd = info->fd;
|
||||
} else {
|
||||
curr_task = task_seq_get_next(ns, &curr_tid, true);
|
||||
if (!curr_task) {
|
||||
info->task = NULL;
|
||||
return NULL;
|
||||
}
|
||||
curr_task = task_seq_get_next(ns, &curr_tid, true);
|
||||
if (!curr_task) {
|
||||
info->task = NULL;
|
||||
info->tid = curr_tid;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* set info->task and info->tid */
|
||||
info->task = curr_task;
|
||||
/* set info->task and info->tid */
|
||||
if (curr_tid == info->tid) {
|
||||
curr_fd = info->fd;
|
||||
} else {
|
||||
|
||||
@ -1569,10 +1569,8 @@ static void neigh_proxy_process(struct timer_list *t)
|
||||
void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
|
||||
struct sk_buff *skb)
|
||||
{
|
||||
unsigned long now = jiffies;
|
||||
|
||||
unsigned long sched_next = now + (prandom_u32() %
|
||||
NEIGH_VAR(p, PROXY_DELAY));
|
||||
unsigned long sched_next = jiffies +
|
||||
prandom_u32_max(NEIGH_VAR(p, PROXY_DELAY));
|
||||
|
||||
if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) {
|
||||
kfree_skb(skb);
|
||||
|
||||
@ -1317,8 +1317,8 @@ static const struct attribute_group dql_group = {
|
||||
static ssize_t xps_cpus_show(struct netdev_queue *queue,
|
||||
char *buf)
|
||||
{
|
||||
int cpu, len, ret, num_tc = 1, tc = 0;
|
||||
struct net_device *dev = queue->dev;
|
||||
int cpu, len, num_tc = 1, tc = 0;
|
||||
struct xps_dev_maps *dev_maps;
|
||||
cpumask_var_t mask;
|
||||
unsigned long index;
|
||||
@ -1328,22 +1328,31 @@ static ssize_t xps_cpus_show(struct netdev_queue *queue,
|
||||
|
||||
index = get_netdev_queue_index(queue);
|
||||
|
||||
if (!rtnl_trylock())
|
||||
return restart_syscall();
|
||||
|
||||
if (dev->num_tc) {
|
||||
/* Do not allow XPS on subordinate device directly */
|
||||
num_tc = dev->num_tc;
|
||||
if (num_tc < 0)
|
||||
return -EINVAL;
|
||||
if (num_tc < 0) {
|
||||
ret = -EINVAL;
|
||||
goto err_rtnl_unlock;
|
||||
}
|
||||
|
||||
/* If queue belongs to subordinate dev use its map */
|
||||
dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
|
||||
|
||||
tc = netdev_txq_to_tc(dev, index);
|
||||
if (tc < 0)
|
||||
return -EINVAL;
|
||||
if (tc < 0) {
|
||||
ret = -EINVAL;
|
||||
goto err_rtnl_unlock;
|
||||
}
|
||||
}
|
||||
|
||||
if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
|
||||
return -ENOMEM;
|
||||
if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
|
||||
ret = -ENOMEM;
|
||||
goto err_rtnl_unlock;
|
||||
}
|
||||
|
||||
rcu_read_lock();
|
||||
dev_maps = rcu_dereference(dev->xps_cpus_map);
|
||||
@ -1366,9 +1375,15 @@ static ssize_t xps_cpus_show(struct netdev_queue *queue,
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
rtnl_unlock();
|
||||
|
||||
len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
|
||||
free_cpumask_var(mask);
|
||||
return len < PAGE_SIZE ? len : -EINVAL;
|
||||
|
||||
err_rtnl_unlock:
|
||||
rtnl_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t xps_cpus_store(struct netdev_queue *queue,
|
||||
@ -1396,7 +1411,13 @@ static ssize_t xps_cpus_store(struct netdev_queue *queue,
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!rtnl_trylock()) {
|
||||
free_cpumask_var(mask);
|
||||
return restart_syscall();
|
||||
}
|
||||
|
||||
err = netif_set_xps_queue(dev, mask, index);
|
||||
rtnl_unlock();
|
||||
|
||||
free_cpumask_var(mask);
|
||||
|
||||
@ -1408,22 +1429,29 @@ static struct netdev_queue_attribute xps_cpus_attribute __ro_after_init
|
||||
|
||||
static ssize_t xps_rxqs_show(struct netdev_queue *queue, char *buf)
|
||||
{
|
||||
int j, len, ret, num_tc = 1, tc = 0;
|
||||
struct net_device *dev = queue->dev;
|
||||
struct xps_dev_maps *dev_maps;
|
||||
unsigned long *mask, index;
|
||||
int j, len, num_tc = 1, tc = 0;
|
||||
|
||||
index = get_netdev_queue_index(queue);
|
||||
|
||||
if (!rtnl_trylock())
|
||||
return restart_syscall();
|
||||
|
||||
if (dev->num_tc) {
|
||||
num_tc = dev->num_tc;
|
||||
tc = netdev_txq_to_tc(dev, index);
|
||||
if (tc < 0)
|
||||
return -EINVAL;
|
||||
if (tc < 0) {
|
||||
ret = -EINVAL;
|
||||
goto err_rtnl_unlock;
|
||||
}
|
||||
}
|
||||
mask = bitmap_zalloc(dev->num_rx_queues, GFP_KERNEL);
|
||||
if (!mask)
|
||||
return -ENOMEM;
|
||||
if (!mask) {
|
||||
ret = -ENOMEM;
|
||||
goto err_rtnl_unlock;
|
||||
}
|
||||
|
||||
rcu_read_lock();
|
||||
dev_maps = rcu_dereference(dev->xps_rxqs_map);
|
||||
@ -1449,10 +1477,16 @@ static ssize_t xps_rxqs_show(struct netdev_queue *queue, char *buf)
|
||||
out_no_maps:
|
||||
rcu_read_unlock();
|
||||
|
||||
rtnl_unlock();
|
||||
|
||||
len = bitmap_print_to_pagebuf(false, buf, mask, dev->num_rx_queues);
|
||||
bitmap_free(mask);
|
||||
|
||||
return len < PAGE_SIZE ? len : -EINVAL;
|
||||
|
||||
err_rtnl_unlock:
|
||||
rtnl_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,
|
||||
@ -1478,10 +1512,17 @@ static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!rtnl_trylock()) {
|
||||
bitmap_free(mask);
|
||||
return restart_syscall();
|
||||
}
|
||||
|
||||
cpus_read_lock();
|
||||
err = __netif_set_xps_queue(dev, mask, index, true);
|
||||
cpus_read_unlock();
|
||||
|
||||
rtnl_unlock();
|
||||
|
||||
bitmap_free(mask);
|
||||
return err ? : len;
|
||||
}
|
||||
|
||||
@ -1765,6 +1765,8 @@ static int dcb_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
fn = &reply_funcs[dcb->cmd];
|
||||
if (!fn->cb)
|
||||
return -EOPNOTSUPP;
|
||||
if (fn->type != nlh->nlmsg_type)
|
||||
return -EPERM;
|
||||
|
||||
if (!tb[DCB_ATTR_IFNAME])
|
||||
return -EINVAL;
|
||||
|
||||
@ -292,7 +292,7 @@ __be32 fib_compute_spec_dst(struct sk_buff *skb)
|
||||
.flowi4_iif = LOOPBACK_IFINDEX,
|
||||
.flowi4_oif = l3mdev_master_ifindex_rcu(dev),
|
||||
.daddr = ip_hdr(skb)->saddr,
|
||||
.flowi4_tos = RT_TOS(ip_hdr(skb)->tos),
|
||||
.flowi4_tos = ip_hdr(skb)->tos & IPTOS_RT_MASK,
|
||||
.flowi4_scope = scope,
|
||||
.flowi4_mark = vmark ? skb->mark : 0,
|
||||
};
|
||||
|
||||
@ -128,7 +128,7 @@ int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
|
||||
* to 0 and sets the configured key in the
|
||||
* inner erspan header field
|
||||
*/
|
||||
if (greh->protocol == htons(ETH_P_ERSPAN) ||
|
||||
if ((greh->protocol == htons(ETH_P_ERSPAN) && hdr_len != 4) ||
|
||||
greh->protocol == htons(ETH_P_ERSPAN2)) {
|
||||
struct erspan_base_hdr *ershdr;
|
||||
|
||||
|
||||
@ -1379,7 +1379,7 @@ static int compat_get_entries(struct net *net,
|
||||
xt_compat_lock(NFPROTO_ARP);
|
||||
t = xt_find_table_lock(net, NFPROTO_ARP, get.name);
|
||||
if (!IS_ERR(t)) {
|
||||
const struct xt_table_info *private = t->private;
|
||||
const struct xt_table_info *private = xt_table_get_private_protected(t);
|
||||
struct xt_table_info info;
|
||||
|
||||
ret = compat_table_info(private, &info);
|
||||
|
||||
@ -1589,7 +1589,7 @@ compat_get_entries(struct net *net, struct compat_ipt_get_entries __user *uptr,
|
||||
xt_compat_lock(AF_INET);
|
||||
t = xt_find_table_lock(net, AF_INET, get.name);
|
||||
if (!IS_ERR(t)) {
|
||||
const struct xt_table_info *private = t->private;
|
||||
const struct xt_table_info *private = xt_table_get_private_protected(t);
|
||||
struct xt_table_info info;
|
||||
ret = compat_table_info(private, &info);
|
||||
if (!ret && get.size == info.size)
|
||||
|
||||
@ -1598,7 +1598,7 @@ compat_get_entries(struct net *net, struct compat_ip6t_get_entries __user *uptr,
|
||||
xt_compat_lock(AF_INET6);
|
||||
t = xt_find_table_lock(net, AF_INET6, get.name);
|
||||
if (!IS_ERR(t)) {
|
||||
const struct xt_table_info *private = t->private;
|
||||
const struct xt_table_info *private = xt_table_get_private_protected(t);
|
||||
struct xt_table_info info;
|
||||
ret = compat_table_info(private, &info);
|
||||
if (!ret && get.size == info.size)
|
||||
|
||||
@ -489,6 +489,7 @@ static int lapb_device_event(struct notifier_block *this, unsigned long event,
|
||||
break;
|
||||
}
|
||||
|
||||
lapb_put(lapb);
|
||||
return NOTIFY_DONE;
|
||||
}
|
||||
|
||||
|
||||
@ -877,6 +877,9 @@ static void __mptcp_wmem_reserve(struct sock *sk, int size)
|
||||
struct mptcp_sock *msk = mptcp_sk(sk);
|
||||
|
||||
WARN_ON_ONCE(msk->wmem_reserved);
|
||||
if (WARN_ON_ONCE(amount < 0))
|
||||
amount = 0;
|
||||
|
||||
if (amount <= sk->sk_forward_alloc)
|
||||
goto reserve;
|
||||
|
||||
@ -1587,7 +1590,7 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
|
||||
if (msg->msg_flags & ~(MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
mptcp_lock_sock(sk, __mptcp_wmem_reserve(sk, len));
|
||||
mptcp_lock_sock(sk, __mptcp_wmem_reserve(sk, min_t(size_t, 1 << 20, len)));
|
||||
|
||||
timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
|
||||
|
||||
|
||||
@ -1120,7 +1120,7 @@ int ncsi_rcv_rsp(struct sk_buff *skb, struct net_device *dev,
|
||||
int payload, i, ret;
|
||||
|
||||
/* Find the NCSI device */
|
||||
nd = ncsi_find_dev(dev);
|
||||
nd = ncsi_find_dev(orig_dev);
|
||||
ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
|
||||
if (!ndp)
|
||||
return -ENODEV;
|
||||
|
||||
@ -141,20 +141,6 @@ htable_size(u8 hbits)
|
||||
return hsize * sizeof(struct hbucket *) + sizeof(struct htable);
|
||||
}
|
||||
|
||||
/* Compute htable_bits from the user input parameter hashsize */
|
||||
static u8
|
||||
htable_bits(u32 hashsize)
|
||||
{
|
||||
/* Assume that hashsize == 2^htable_bits */
|
||||
u8 bits = fls(hashsize - 1);
|
||||
|
||||
if (jhash_size(bits) != hashsize)
|
||||
/* Round up to the first 2^n value */
|
||||
bits = fls(hashsize);
|
||||
|
||||
return bits;
|
||||
}
|
||||
|
||||
#ifdef IP_SET_HASH_WITH_NETS
|
||||
#if IPSET_NET_COUNT > 1
|
||||
#define __CIDR(cidr, i) (cidr[i])
|
||||
@ -640,7 +626,7 @@ mtype_resize(struct ip_set *set, bool retried)
|
||||
struct htype *h = set->data;
|
||||
struct htable *t, *orig;
|
||||
u8 htable_bits;
|
||||
size_t dsize = set->dsize;
|
||||
size_t hsize, dsize = set->dsize;
|
||||
#ifdef IP_SET_HASH_WITH_NETS
|
||||
u8 flags;
|
||||
struct mtype_elem *tmp;
|
||||
@ -664,14 +650,12 @@ mtype_resize(struct ip_set *set, bool retried)
|
||||
retry:
|
||||
ret = 0;
|
||||
htable_bits++;
|
||||
if (!htable_bits) {
|
||||
/* In case we have plenty of memory :-) */
|
||||
pr_warn("Cannot increase the hashsize of set %s further\n",
|
||||
set->name);
|
||||
ret = -IPSET_ERR_HASH_FULL;
|
||||
goto out;
|
||||
}
|
||||
t = ip_set_alloc(htable_size(htable_bits));
|
||||
if (!htable_bits)
|
||||
goto hbwarn;
|
||||
hsize = htable_size(htable_bits);
|
||||
if (!hsize)
|
||||
goto hbwarn;
|
||||
t = ip_set_alloc(hsize);
|
||||
if (!t) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
@ -813,6 +797,12 @@ mtype_resize(struct ip_set *set, bool retried)
|
||||
if (ret == -EAGAIN)
|
||||
goto retry;
|
||||
goto out;
|
||||
|
||||
hbwarn:
|
||||
/* In case we have plenty of memory :-) */
|
||||
pr_warn("Cannot increase the hashsize of set %s further\n", set->name);
|
||||
ret = -IPSET_ERR_HASH_FULL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Get the current number of elements and ext_size in the set */
|
||||
@ -1521,7 +1511,11 @@ IPSET_TOKEN(HTYPE, _create)(struct net *net, struct ip_set *set,
|
||||
if (!h)
|
||||
return -ENOMEM;
|
||||
|
||||
hbits = htable_bits(hashsize);
|
||||
/* Compute htable_bits from the user input parameter hashsize.
|
||||
* Assume that hashsize == 2^htable_bits,
|
||||
* otherwise round up to the first 2^n value.
|
||||
*/
|
||||
hbits = fls(hashsize - 1);
|
||||
hsize = htable_size(hbits);
|
||||
if (hsize == 0) {
|
||||
kfree(h);
|
||||
|
||||
@ -4162,7 +4162,7 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk,
|
||||
if (flags & ~(NFT_SET_ANONYMOUS | NFT_SET_CONSTANT |
|
||||
NFT_SET_INTERVAL | NFT_SET_TIMEOUT |
|
||||
NFT_SET_MAP | NFT_SET_EVAL |
|
||||
NFT_SET_OBJECT | NFT_SET_CONCAT))
|
||||
NFT_SET_OBJECT | NFT_SET_CONCAT | NFT_SET_EXPR))
|
||||
return -EOPNOTSUPP;
|
||||
/* Only one of these operations is supported */
|
||||
if ((flags & (NFT_SET_MAP | NFT_SET_OBJECT)) ==
|
||||
@ -4304,6 +4304,10 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk,
|
||||
struct nlattr *tmp;
|
||||
int left;
|
||||
|
||||
if (!(flags & NFT_SET_EXPR)) {
|
||||
err = -EINVAL;
|
||||
goto err_set_alloc_name;
|
||||
}
|
||||
i = 0;
|
||||
nla_for_each_nested(tmp, nla[NFTA_SET_EXPRESSIONS], left) {
|
||||
if (i == NFT_SET_EXPR_MAX) {
|
||||
@ -5254,8 +5258,8 @@ static int nft_set_elem_expr_clone(const struct nft_ctx *ctx,
|
||||
return 0;
|
||||
|
||||
err_expr:
|
||||
for (k = i - 1; k >= 0; k++)
|
||||
nft_expr_destroy(ctx, expr_array[i]);
|
||||
for (k = i - 1; k >= 0; k--)
|
||||
nft_expr_destroy(ctx, expr_array[k]);
|
||||
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
@ -19,6 +19,7 @@ struct nft_dynset {
|
||||
enum nft_registers sreg_key:8;
|
||||
enum nft_registers sreg_data:8;
|
||||
bool invert;
|
||||
bool expr;
|
||||
u8 num_exprs;
|
||||
u64 timeout;
|
||||
struct nft_expr *expr_array[NFT_SET_EXPR_MAX];
|
||||
@ -175,11 +176,12 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
|
||||
|
||||
if (tb[NFTA_DYNSET_FLAGS]) {
|
||||
u32 flags = ntohl(nla_get_be32(tb[NFTA_DYNSET_FLAGS]));
|
||||
|
||||
if (flags & ~NFT_DYNSET_F_INV)
|
||||
return -EINVAL;
|
||||
if (flags & ~(NFT_DYNSET_F_INV | NFT_DYNSET_F_EXPR))
|
||||
return -EOPNOTSUPP;
|
||||
if (flags & NFT_DYNSET_F_INV)
|
||||
priv->invert = true;
|
||||
if (flags & NFT_DYNSET_F_EXPR)
|
||||
priv->expr = true;
|
||||
}
|
||||
|
||||
set = nft_set_lookup_global(ctx->net, ctx->table,
|
||||
@ -210,7 +212,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
|
||||
timeout = 0;
|
||||
if (tb[NFTA_DYNSET_TIMEOUT] != NULL) {
|
||||
if (!(set->flags & NFT_SET_TIMEOUT))
|
||||
return -EINVAL;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
err = nf_msecs_to_jiffies64(tb[NFTA_DYNSET_TIMEOUT], &timeout);
|
||||
if (err)
|
||||
@ -224,7 +226,7 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
|
||||
|
||||
if (tb[NFTA_DYNSET_SREG_DATA] != NULL) {
|
||||
if (!(set->flags & NFT_SET_MAP))
|
||||
return -EINVAL;
|
||||
return -EOPNOTSUPP;
|
||||
if (set->dtype == NFT_DATA_VERDICT)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
@ -261,6 +263,9 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
|
||||
struct nlattr *tmp;
|
||||
int left;
|
||||
|
||||
if (!priv->expr)
|
||||
return -EINVAL;
|
||||
|
||||
i = 0;
|
||||
nla_for_each_nested(tmp, tb[NFTA_DYNSET_EXPRESSIONS], left) {
|
||||
if (i == NFT_SET_EXPR_MAX) {
|
||||
|
||||
@ -115,6 +115,9 @@ static int xt_rateest_tg_checkentry(const struct xt_tgchk_param *par)
|
||||
} cfg;
|
||||
int ret;
|
||||
|
||||
if (strnlen(info->name, sizeof(est->name)) >= sizeof(est->name))
|
||||
return -ENAMETOOLONG;
|
||||
|
||||
net_get_random_once(&jhash_rnd, sizeof(jhash_rnd));
|
||||
|
||||
mutex_lock(&xn->hash_lock);
|
||||
|
||||
@ -4595,7 +4595,9 @@ static void packet_seq_stop(struct seq_file *seq, void *v)
|
||||
static int packet_seq_show(struct seq_file *seq, void *v)
|
||||
{
|
||||
if (v == SEQ_START_TOKEN)
|
||||
seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n");
|
||||
seq_printf(seq,
|
||||
"%*sRefCnt Type Proto Iface R Rmem User Inode\n",
|
||||
IS_ENABLED(CONFIG_64BIT) ? -17 : -9, "sk");
|
||||
else {
|
||||
struct sock *s = sk_entry(v);
|
||||
const struct packet_sock *po = pkt_sk(s);
|
||||
|
||||
@ -362,7 +362,7 @@ static int choke_change(struct Qdisc *sch, struct nlattr *opt,
|
||||
|
||||
ctl = nla_data(tb[TCA_CHOKE_PARMS]);
|
||||
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log))
|
||||
return -EINVAL;
|
||||
|
||||
if (ctl->limit > CHOKE_MAX_QUEUE)
|
||||
|
||||
@ -480,7 +480,7 @@ static inline int gred_change_vq(struct Qdisc *sch, int dp,
|
||||
struct gred_sched *table = qdisc_priv(sch);
|
||||
struct gred_sched_data *q = table->tab[dp];
|
||||
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog)) {
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log)) {
|
||||
NL_SET_ERR_MSG_MOD(extack, "invalid RED parameters");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -250,7 +250,7 @@ static int __red_change(struct Qdisc *sch, struct nlattr **tb,
|
||||
max_P = tb[TCA_RED_MAX_P] ? nla_get_u32(tb[TCA_RED_MAX_P]) : 0;
|
||||
|
||||
ctl = nla_data(tb[TCA_RED_PARMS]);
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog))
|
||||
if (!red_check_params(ctl->qth_min, ctl->qth_max, ctl->Wlog, ctl->Scell_log))
|
||||
return -EINVAL;
|
||||
|
||||
err = red_get_flags(ctl->flags, TC_RED_HISTORIC_FLAGS,
|
||||
|
||||
@ -647,7 +647,7 @@ static int sfq_change(struct Qdisc *sch, struct nlattr *opt)
|
||||
}
|
||||
|
||||
if (ctl_v1 && !red_check_params(ctl_v1->qth_min, ctl_v1->qth_max,
|
||||
ctl_v1->Wlog))
|
||||
ctl_v1->Wlog, ctl_v1->Scell_log))
|
||||
return -EINVAL;
|
||||
if (ctl_v1 && ctl_v1->qth_min) {
|
||||
p = kmalloc(sizeof(*p), GFP_KERNEL);
|
||||
|
||||
@ -1605,8 +1605,9 @@ static void taprio_reset(struct Qdisc *sch)
|
||||
|
||||
hrtimer_cancel(&q->advance_timer);
|
||||
if (q->qdiscs) {
|
||||
for (i = 0; i < dev->num_tx_queues && q->qdiscs[i]; i++)
|
||||
qdisc_reset(q->qdiscs[i]);
|
||||
for (i = 0; i < dev->num_tx_queues; i++)
|
||||
if (q->qdiscs[i])
|
||||
qdisc_reset(q->qdiscs[i]);
|
||||
}
|
||||
sch->qstats.backlog = 0;
|
||||
sch->q.qlen = 0;
|
||||
@ -1626,7 +1627,7 @@ static void taprio_destroy(struct Qdisc *sch)
|
||||
taprio_disable_offload(dev, q, NULL);
|
||||
|
||||
if (q->qdiscs) {
|
||||
for (i = 0; i < dev->num_tx_queues && q->qdiscs[i]; i++)
|
||||
for (i = 0; i < dev->num_tx_queues; i++)
|
||||
qdisc_put(q->qdiscs[i]);
|
||||
|
||||
kfree(q->qdiscs);
|
||||
|
||||
@ -423,9 +423,9 @@ static void xsk_destruct_skb(struct sk_buff *skb)
|
||||
struct xdp_sock *xs = xdp_sk(skb->sk);
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&xs->tx_completion_lock, flags);
|
||||
spin_lock_irqsave(&xs->pool->cq_lock, flags);
|
||||
xskq_prod_submit_addr(xs->pool->cq, addr);
|
||||
spin_unlock_irqrestore(&xs->tx_completion_lock, flags);
|
||||
spin_unlock_irqrestore(&xs->pool->cq_lock, flags);
|
||||
|
||||
sock_wfree(skb);
|
||||
}
|
||||
@ -437,6 +437,7 @@ static int xsk_generic_xmit(struct sock *sk)
|
||||
bool sent_frame = false;
|
||||
struct xdp_desc desc;
|
||||
struct sk_buff *skb;
|
||||
unsigned long flags;
|
||||
int err = 0;
|
||||
|
||||
mutex_lock(&xs->mutex);
|
||||
@ -468,10 +469,13 @@ static int xsk_generic_xmit(struct sock *sk)
|
||||
* if there is space in it. This avoids having to implement
|
||||
* any buffering in the Tx path.
|
||||
*/
|
||||
spin_lock_irqsave(&xs->pool->cq_lock, flags);
|
||||
if (unlikely(err) || xskq_prod_reserve(xs->pool->cq)) {
|
||||
spin_unlock_irqrestore(&xs->pool->cq_lock, flags);
|
||||
kfree_skb(skb);
|
||||
goto out;
|
||||
}
|
||||
spin_unlock_irqrestore(&xs->pool->cq_lock, flags);
|
||||
|
||||
skb->dev = xs->dev;
|
||||
skb->priority = sk->sk_priority;
|
||||
@ -483,6 +487,9 @@ static int xsk_generic_xmit(struct sock *sk)
|
||||
if (err == NETDEV_TX_BUSY) {
|
||||
/* Tell user-space to retry the send */
|
||||
skb->destructor = sock_wfree;
|
||||
spin_lock_irqsave(&xs->pool->cq_lock, flags);
|
||||
xskq_prod_cancel(xs->pool->cq);
|
||||
spin_unlock_irqrestore(&xs->pool->cq_lock, flags);
|
||||
/* Free skb without triggering the perf drop trace */
|
||||
consume_skb(skb);
|
||||
err = -EAGAIN;
|
||||
@ -878,6 +885,10 @@ static int xsk_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
|
||||
}
|
||||
}
|
||||
|
||||
/* FQ and CQ are now owned by the buffer pool and cleaned up with it. */
|
||||
xs->fq_tmp = NULL;
|
||||
xs->cq_tmp = NULL;
|
||||
|
||||
xs->dev = dev;
|
||||
xs->zc = xs->umem->zc;
|
||||
xs->queue_id = qid;
|
||||
@ -1299,7 +1310,6 @@ static int xsk_create(struct net *net, struct socket *sock, int protocol,
|
||||
xs->state = XSK_READY;
|
||||
mutex_init(&xs->mutex);
|
||||
spin_lock_init(&xs->rx_lock);
|
||||
spin_lock_init(&xs->tx_completion_lock);
|
||||
|
||||
INIT_LIST_HEAD(&xs->map_list);
|
||||
spin_lock_init(&xs->map_list_lock);
|
||||
|
||||
@ -71,12 +71,11 @@ struct xsk_buff_pool *xp_create_and_assign_umem(struct xdp_sock *xs,
|
||||
INIT_LIST_HEAD(&pool->free_list);
|
||||
INIT_LIST_HEAD(&pool->xsk_tx_list);
|
||||
spin_lock_init(&pool->xsk_tx_list_lock);
|
||||
spin_lock_init(&pool->cq_lock);
|
||||
refcount_set(&pool->users, 1);
|
||||
|
||||
pool->fq = xs->fq_tmp;
|
||||
pool->cq = xs->cq_tmp;
|
||||
xs->fq_tmp = NULL;
|
||||
xs->cq_tmp = NULL;
|
||||
|
||||
for (i = 0; i < pool->free_heads_cnt; i++) {
|
||||
xskb = &pool->heads[i];
|
||||
|
||||
@ -334,6 +334,11 @@ static inline bool xskq_prod_is_full(struct xsk_queue *q)
|
||||
return xskq_prod_nb_free(q, 1) ? false : true;
|
||||
}
|
||||
|
||||
static inline void xskq_prod_cancel(struct xsk_queue *q)
|
||||
{
|
||||
q->cached_prod--;
|
||||
}
|
||||
|
||||
static inline int xskq_prod_reserve(struct xsk_queue *q)
|
||||
{
|
||||
if (xskq_prod_is_full(q))
|
||||
|
||||
@ -121,6 +121,9 @@ VMLINUX_BTF_PATHS ?= $(if $(O),$(O)/vmlinux) \
|
||||
/sys/kernel/btf/vmlinux \
|
||||
/boot/vmlinux-$(shell uname -r)
|
||||
VMLINUX_BTF ?= $(abspath $(firstword $(wildcard $(VMLINUX_BTF_PATHS))))
|
||||
ifeq ($(VMLINUX_BTF),)
|
||||
$(error Cannot find a vmlinux for VMLINUX_BTF at any of "$(VMLINUX_BTF_PATHS)")
|
||||
endif
|
||||
|
||||
# Define simple and short `make test_progs`, `make test_sysctl`, etc targets
|
||||
# to build individual tests.
|
||||
|
||||
@ -1312,22 +1312,58 @@ static void test_map_stress(void)
|
||||
#define DO_UPDATE 1
|
||||
#define DO_DELETE 0
|
||||
|
||||
#define MAP_RETRIES 20
|
||||
|
||||
static int map_update_retriable(int map_fd, const void *key, const void *value,
|
||||
int flags, int attempts)
|
||||
{
|
||||
while (bpf_map_update_elem(map_fd, key, value, flags)) {
|
||||
if (!attempts || (errno != EAGAIN && errno != EBUSY))
|
||||
return -errno;
|
||||
|
||||
usleep(1);
|
||||
attempts--;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int map_delete_retriable(int map_fd, const void *key, int attempts)
|
||||
{
|
||||
while (bpf_map_delete_elem(map_fd, key)) {
|
||||
if (!attempts || (errno != EAGAIN && errno != EBUSY))
|
||||
return -errno;
|
||||
|
||||
usleep(1);
|
||||
attempts--;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_update_delete(unsigned int fn, void *data)
|
||||
{
|
||||
int do_update = ((int *)data)[1];
|
||||
int fd = ((int *)data)[0];
|
||||
int i, key, value;
|
||||
int i, key, value, err;
|
||||
|
||||
for (i = fn; i < MAP_SIZE; i += TASKS) {
|
||||
key = value = i;
|
||||
|
||||
if (do_update) {
|
||||
assert(bpf_map_update_elem(fd, &key, &value,
|
||||
BPF_NOEXIST) == 0);
|
||||
assert(bpf_map_update_elem(fd, &key, &value,
|
||||
BPF_EXIST) == 0);
|
||||
err = map_update_retriable(fd, &key, &value, BPF_NOEXIST, MAP_RETRIES);
|
||||
if (err)
|
||||
printf("error %d %d\n", err, errno);
|
||||
assert(err == 0);
|
||||
err = map_update_retriable(fd, &key, &value, BPF_EXIST, MAP_RETRIES);
|
||||
if (err)
|
||||
printf("error %d %d\n", err, errno);
|
||||
assert(err == 0);
|
||||
} else {
|
||||
assert(bpf_map_delete_elem(fd, &key) == 0);
|
||||
err = map_delete_retriable(fd, &key, MAP_RETRIES);
|
||||
if (err)
|
||||
printf("error %d %d\n", err, errno);
|
||||
assert(err == 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -715,7 +715,7 @@ static void worker_pkt_dump(void)
|
||||
int payload = *((uint32_t *)(pkt_buf[iter]->payload + PKT_HDR_SIZE));
|
||||
|
||||
if (payload == EOT) {
|
||||
ksft_print_msg("End-of-tranmission frame received\n");
|
||||
ksft_print_msg("End-of-transmission frame received\n");
|
||||
fprintf(stdout, "---------------------------------------\n");
|
||||
break;
|
||||
}
|
||||
@ -747,7 +747,7 @@ static void worker_pkt_validate(void)
|
||||
}
|
||||
|
||||
if (payloadseqnum == EOT) {
|
||||
ksft_print_msg("End-of-tranmission frame received: PASS\n");
|
||||
ksft_print_msg("End-of-transmission frame received: PASS\n");
|
||||
sigvar = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -230,7 +230,7 @@ switch_create()
|
||||
__mlnx_qos -i $swp4 --pfc=0,1,0,0,0,0,0,0 >/dev/null
|
||||
# PG0 will get autoconfigured to Xoff, give PG1 arbitrarily 100K, which
|
||||
# is (-2*MTU) about 80K of delay provision.
|
||||
__mlnx_qos -i $swp3 --buffer_size=0,$_100KB,0,0,0,0,0,0 >/dev/null
|
||||
__mlnx_qos -i $swp4 --buffer_size=0,$_100KB,0,0,0,0,0,0 >/dev/null
|
||||
|
||||
# bridges
|
||||
# -------
|
||||
|
||||
Loading…
Reference in New Issue
Block a user