From: Sasha Levin Date: Sat, 5 Aug 2023 20:50:00 +0000 (-0400) Subject: Fixes for 5.15 X-Git-Tag: v4.14.321~52 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2b2b7f99d81b42e0e4ccc196dd7a13778894e139;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 5.15 Signed-off-by: Sasha Levin --- diff --git a/queue-5.15/arm64-dts-imx8mn-var-som-add-missing-pull-up-for-onb.patch b/queue-5.15/arm64-dts-imx8mn-var-som-add-missing-pull-up-for-onb.patch new file mode 100644 index 00000000000..c920fbb2930 --- /dev/null +++ b/queue-5.15/arm64-dts-imx8mn-var-som-add-missing-pull-up-for-onb.patch @@ -0,0 +1,47 @@ +From b50f5e11d9faefba78b27ec62a126cf9cac40e1c Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 4 Jul 2023 09:48:00 -0400 +Subject: arm64: dts: imx8mn-var-som: add missing pull-up for onboard PHY reset + pinmux + +From: Hugo Villeneuve + +[ Upstream commit 253be5b53c2792fb4384f8005b05421e6f040ee3 ] + +For SOMs with an onboard PHY, the RESET_N pull-up resistor is +currently deactivated in the pinmux configuration. When the pinmux +code selects the GPIO function for this pin, with a default direction +of input, this prevents the RESET_N pin from being taken to the proper +3.3V level (deasserted), and this results in the PHY being not +detected since it is held in reset. + +Taken from RESET_N pin description in ADIN13000 datasheet: + This pin requires a 1K pull-up resistor to AVDD_3P3. + +Activate the pull-up resistor to fix the issue. + +Fixes: ade0176dd8a0 ("arm64: dts: imx8mn-var-som: Add Variscite VAR-SOM-MX8MN System on Module") +Signed-off-by: Hugo Villeneuve +Reviewed-by: Fabio Estevam +Signed-off-by: Shawn Guo +Signed-off-by: Sasha Levin +--- + arch/arm64/boot/dts/freescale/imx8mn-var-som.dtsi | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/arch/arm64/boot/dts/freescale/imx8mn-var-som.dtsi b/arch/arm64/boot/dts/freescale/imx8mn-var-som.dtsi +index d053ef302fb82..faafefe562e4b 100644 +--- a/arch/arm64/boot/dts/freescale/imx8mn-var-som.dtsi ++++ b/arch/arm64/boot/dts/freescale/imx8mn-var-som.dtsi +@@ -351,7 +351,7 @@ + MX8MN_IOMUXC_ENET_RXC_ENET1_RGMII_RXC 0x91 + MX8MN_IOMUXC_ENET_RX_CTL_ENET1_RGMII_RX_CTL 0x91 + MX8MN_IOMUXC_ENET_TX_CTL_ENET1_RGMII_TX_CTL 0x1f +- MX8MN_IOMUXC_GPIO1_IO09_GPIO1_IO9 0x19 ++ MX8MN_IOMUXC_GPIO1_IO09_GPIO1_IO9 0x159 + >; + }; + +-- +2.40.1 + diff --git a/queue-5.15/bpf-add-length-check-for-sk_diag_bpf_storage_req_map.patch b/queue-5.15/bpf-add-length-check-for-sk_diag_bpf_storage_req_map.patch new file mode 100644 index 00000000000..01eca4cd8ae --- /dev/null +++ b/queue-5.15/bpf-add-length-check-for-sk_diag_bpf_storage_req_map.patch @@ -0,0 +1,49 @@ +From 0fc9dc502f76fae1383805742278a3e77d087f8d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 25 Jul 2023 10:33:30 +0800 +Subject: bpf: Add length check for SK_DIAG_BPF_STORAGE_REQ_MAP_FD parsing + +From: Lin Ma + +[ Upstream commit bcc29b7f5af6797702c2306a7aacb831fc5ce9cb ] + +The nla_for_each_nested parsing in function bpf_sk_storage_diag_alloc +does not check the length of the nested attribute. This can lead to an +out-of-attribute read and allow a malformed nlattr (e.g., length 0) to +be viewed as a 4 byte integer. + +This patch adds an additional check when the nlattr is getting counted. +This makes sure the latter nla_get_u32 can access the attributes with +the correct length. + +Fixes: 1ed4d92458a9 ("bpf: INET_DIAG support in bpf_sk_storage") +Suggested-by: Jakub Kicinski +Signed-off-by: Lin Ma +Reviewed-by: Jakub Kicinski +Link: https://lore.kernel.org/r/20230725023330.422856-1-linma@zju.edu.cn +Signed-off-by: Martin KaFai Lau +Signed-off-by: Sasha Levin +--- + net/core/bpf_sk_storage.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +diff --git a/net/core/bpf_sk_storage.c b/net/core/bpf_sk_storage.c +index 910ca41cb9e67..4953abee79fea 100644 +--- a/net/core/bpf_sk_storage.c ++++ b/net/core/bpf_sk_storage.c +@@ -521,8 +521,11 @@ bpf_sk_storage_diag_alloc(const struct nlattr *nla_stgs) + return ERR_PTR(-EPERM); + + nla_for_each_nested(nla, nla_stgs, rem) { +- if (nla_type(nla) == SK_DIAG_BPF_STORAGE_REQ_MAP_FD) ++ if (nla_type(nla) == SK_DIAG_BPF_STORAGE_REQ_MAP_FD) { ++ if (nla_len(nla) != sizeof(u32)) ++ return ERR_PTR(-EINVAL); + nr_maps++; ++ } + } + + diag = kzalloc(struct_size(diag, maps, nr_maps), GFP_KERNEL); +-- +2.40.1 + diff --git a/queue-5.15/bpf-cpumap-handle-skb-as-well-when-clean-up-ptr_ring.patch b/queue-5.15/bpf-cpumap-handle-skb-as-well-when-clean-up-ptr_ring.patch new file mode 100644 index 00000000000..5b85430d832 --- /dev/null +++ b/queue-5.15/bpf-cpumap-handle-skb-as-well-when-clean-up-ptr_ring.patch @@ -0,0 +1,85 @@ +From 5e5827b20319659cad5b69af8f476615fb8926f1 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 29 Jul 2023 17:51:07 +0800 +Subject: bpf, cpumap: Handle skb as well when clean up ptr_ring + +From: Hou Tao + +[ Upstream commit 7c62b75cd1a792e14b037fa4f61f9b18914e7de1 ] + +The following warning was reported when running xdp_redirect_cpu with +both skb-mode and stress-mode enabled: + + ------------[ cut here ]------------ + Incorrect XDP memory type (-2128176192) usage + WARNING: CPU: 7 PID: 1442 at net/core/xdp.c:405 + Modules linked in: + CPU: 7 PID: 1442 Comm: kworker/7:0 Tainted: G 6.5.0-rc2+ #1 + Hardware name: QEMU Standard PC (i440FX + PIIX, 1996) + Workqueue: events __cpu_map_entry_free + RIP: 0010:__xdp_return+0x1e4/0x4a0 + ...... + Call Trace: + + ? show_regs+0x65/0x70 + ? __warn+0xa5/0x240 + ? __xdp_return+0x1e4/0x4a0 + ...... + xdp_return_frame+0x4d/0x150 + __cpu_map_entry_free+0xf9/0x230 + process_one_work+0x6b0/0xb80 + worker_thread+0x96/0x720 + kthread+0x1a5/0x1f0 + ret_from_fork+0x3a/0x70 + ret_from_fork_asm+0x1b/0x30 + + +The reason for the warning is twofold. One is due to the kthread +cpu_map_kthread_run() is stopped prematurely. Another one is +__cpu_map_ring_cleanup() doesn't handle skb mode and treats skbs in +ptr_ring as XDP frames. + +Prematurely-stopped kthread will be fixed by the preceding patch and +ptr_ring will be empty when __cpu_map_ring_cleanup() is called. But +as the comments in __cpu_map_ring_cleanup() said, handling and freeing +skbs in ptr_ring as well to "catch any broken behaviour gracefully". + +Fixes: 11941f8a8536 ("bpf: cpumap: Implement generic cpumap") +Signed-off-by: Hou Tao +Acked-by: Jesper Dangaard Brouer +Link: https://lore.kernel.org/r/20230729095107.1722450-3-houtao@huaweicloud.com +Signed-off-by: Martin KaFai Lau +Signed-off-by: Sasha Levin +--- + kernel/bpf/cpumap.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +diff --git a/kernel/bpf/cpumap.c b/kernel/bpf/cpumap.c +index db6221773e43f..17f52efba1c80 100644 +--- a/kernel/bpf/cpumap.c ++++ b/kernel/bpf/cpumap.c +@@ -133,11 +133,17 @@ static void __cpu_map_ring_cleanup(struct ptr_ring *ring) + * invoked cpu_map_kthread_stop(). Catch any broken behaviour + * gracefully and warn once. + */ +- struct xdp_frame *xdpf; ++ void *ptr; + +- while ((xdpf = ptr_ring_consume(ring))) +- if (WARN_ON_ONCE(xdpf)) +- xdp_return_frame(xdpf); ++ while ((ptr = ptr_ring_consume(ring))) { ++ WARN_ON_ONCE(1); ++ if (unlikely(__ptr_test_bit(0, &ptr))) { ++ __ptr_clear_bit(0, &ptr); ++ kfree_skb(ptr); ++ continue; ++ } ++ xdp_return_frame(ptr); ++ } + } + + static void put_cpu_map_entry(struct bpf_cpu_map_entry *rcpu) +-- +2.40.1 + diff --git a/queue-5.15/bpf-sockmap-remove-preempt_disable-in-sock_map_sk_ac.patch b/queue-5.15/bpf-sockmap-remove-preempt_disable-in-sock_map_sk_ac.patch new file mode 100644 index 00000000000..c50199c90dc --- /dev/null +++ b/queue-5.15/bpf-sockmap-remove-preempt_disable-in-sock_map_sk_ac.patch @@ -0,0 +1,59 @@ +From 69412a81cfd2954816cdb5fc9b7266db6e18e601 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 08:44:11 +0200 +Subject: bpf: sockmap: Remove preempt_disable in sock_map_sk_acquire + +From: Tomas Glozar + +[ Upstream commit 13d2618b48f15966d1adfe1ff6a1985f5eef40ba ] + +Disabling preemption in sock_map_sk_acquire conflicts with GFP_ATOMIC +allocation later in sk_psock_init_link on PREEMPT_RT kernels, since +GFP_ATOMIC might sleep on RT (see bpf: Make BPF and PREEMPT_RT co-exist +patchset notes for details). + +This causes calling bpf_map_update_elem on BPF_MAP_TYPE_SOCKMAP maps to +BUG (sleeping function called from invalid context) on RT kernels. + +preempt_disable was introduced together with lock_sk and rcu_read_lock +in commit 99ba2b5aba24e ("bpf: sockhash, disallow bpf_tcp_close and update +in parallel"), probably to match disabled migration of BPF programs, and +is no longer necessary. + +Remove preempt_disable to fix BUG in sock_map_update_common on RT. + +Signed-off-by: Tomas Glozar +Reviewed-by: Jakub Sitnicki +Link: https://lore.kernel.org/all/20200224140131.461979697@linutronix.de/ +Fixes: 99ba2b5aba24 ("bpf: sockhash, disallow bpf_tcp_close and update in parallel") +Reviewed-by: John Fastabend +Link: https://lore.kernel.org/r/20230728064411.305576-1-tglozar@redhat.com +Signed-off-by: Paolo Abeni +Signed-off-by: Sasha Levin +--- + net/core/sock_map.c | 2 -- + 1 file changed, 2 deletions(-) + +diff --git a/net/core/sock_map.c b/net/core/sock_map.c +index 86b4e8909ad1e..85d3c62bdfa6a 100644 +--- a/net/core/sock_map.c ++++ b/net/core/sock_map.c +@@ -117,7 +117,6 @@ static void sock_map_sk_acquire(struct sock *sk) + __acquires(&sk->sk_lock.slock) + { + lock_sock(sk); +- preempt_disable(); + rcu_read_lock(); + } + +@@ -125,7 +124,6 @@ static void sock_map_sk_release(struct sock *sk) + __releases(&sk->sk_lock.slock) + { + rcu_read_unlock(); +- preempt_enable(); + release_sock(sk); + } + +-- +2.40.1 + diff --git a/queue-5.15/firmware-arm_scmi-fix-chan_free-cleanup-on-smc.patch b/queue-5.15/firmware-arm_scmi-fix-chan_free-cleanup-on-smc.patch new file mode 100644 index 00000000000..c8377be45e5 --- /dev/null +++ b/queue-5.15/firmware-arm_scmi-fix-chan_free-cleanup-on-smc.patch @@ -0,0 +1,89 @@ +From f1b056a8d31eb954469e2cd4c66a7f428a0f6c17 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 19 Jul 2023 18:35:33 +0100 +Subject: firmware: arm_scmi: Fix chan_free cleanup on SMC + +From: Cristian Marussi + +[ Upstream commit d1ff11d7ad8704f8d615f6446041c221b2d2ec4d ] + +SCMI transport based on SMC can optionally use an additional IRQ to +signal message completion. The associated interrupt handler is currently +allocated using devres but on shutdown the core SCMI stack will call +.chan_free() well before any managed cleanup is invoked by devres. +As a consequence, the arrival of a late reply to an in-flight pending +transaction could still trigger the interrupt handler well after the +SCMI core has cleaned up the channels, with unpleasant results. + +Inhibit further message processing on the IRQ path by explicitly freeing +the IRQ inside .chan_free() callback itself. + +Fixes: dd820ee21d5e ("firmware: arm_scmi: Augment SMC/HVC to allow optional interrupt") +Reported-by: Bjorn Andersson +Signed-off-by: Cristian Marussi +Link: https://lore.kernel.org/r/20230719173533.2739319-1-cristian.marussi@arm.com +Signed-off-by: Sudeep Holla +Signed-off-by: Sasha Levin +--- + drivers/firmware/arm_scmi/smc.c | 17 +++++++++++------ + 1 file changed, 11 insertions(+), 6 deletions(-) + +diff --git a/drivers/firmware/arm_scmi/smc.c b/drivers/firmware/arm_scmi/smc.c +index 4effecc3bb463..f529004f1922e 100644 +--- a/drivers/firmware/arm_scmi/smc.c ++++ b/drivers/firmware/arm_scmi/smc.c +@@ -21,6 +21,7 @@ + /** + * struct scmi_smc - Structure representing a SCMI smc transport + * ++ * @irq: An optional IRQ for completion + * @cinfo: SCMI channel info + * @shmem: Transmit/Receive shared memory area + * @shmem_lock: Lock to protect access to Tx/Rx shared memory area +@@ -30,6 +31,7 @@ + */ + + struct scmi_smc { ++ int irq; + struct scmi_chan_info *cinfo; + struct scmi_shared_mem __iomem *shmem; + struct mutex shmem_lock; +@@ -66,7 +68,7 @@ static int smc_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, + struct resource res; + struct device_node *np; + u32 func_id; +- int ret, irq; ++ int ret; + + if (!tx) + return -ENODEV; +@@ -102,11 +104,10 @@ static int smc_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, + * completion of a message is signaled by an interrupt rather than by + * the return of the SMC call. + */ +- irq = of_irq_get_byname(cdev->of_node, "a2p"); +- if (irq > 0) { +- ret = devm_request_irq(dev, irq, smc_msg_done_isr, +- IRQF_NO_SUSPEND, +- dev_name(dev), scmi_info); ++ scmi_info->irq = of_irq_get_byname(cdev->of_node, "a2p"); ++ if (scmi_info->irq > 0) { ++ ret = request_irq(scmi_info->irq, smc_msg_done_isr, ++ IRQF_NO_SUSPEND, dev_name(dev), scmi_info); + if (ret) { + dev_err(dev, "failed to setup SCMI smc irq\n"); + return ret; +@@ -128,6 +129,10 @@ static int smc_chan_free(int id, void *p, void *data) + struct scmi_chan_info *cinfo = p; + struct scmi_smc *scmi_info = cinfo->transport_info; + ++ /* Ignore any possible further reception on the IRQ path */ ++ if (scmi_info->irq > 0) ++ free_irq(scmi_info->irq, scmi_info); ++ + cinfo->transport_info = NULL; + scmi_info->cinfo = NULL; + +-- +2.40.1 + diff --git a/queue-5.15/ip6mr-fix-skb_under_panic-in-ip6mr_cache_report.patch b/queue-5.15/ip6mr-fix-skb_under_panic-in-ip6mr_cache_report.patch new file mode 100644 index 00000000000..c11361dc85e --- /dev/null +++ b/queue-5.15/ip6mr-fix-skb_under_panic-in-ip6mr_cache_report.patch @@ -0,0 +1,77 @@ +From 7d5720128f34d1d00afeed8e78e605327c30134c Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 1 Aug 2023 14:43:18 +0800 +Subject: ip6mr: Fix skb_under_panic in ip6mr_cache_report() + +From: Yue Haibing + +[ Upstream commit 30e0191b16e8a58e4620fa3e2839ddc7b9d4281c ] + +skbuff: skb_under_panic: text:ffffffff88771f69 len:56 put:-4 + head:ffff88805f86a800 data:ffff887f5f86a850 tail:0x88 end:0x2c0 dev:pim6reg + ------------[ cut here ]------------ + kernel BUG at net/core/skbuff.c:192! + invalid opcode: 0000 [#1] PREEMPT SMP KASAN + CPU: 2 PID: 22968 Comm: kworker/2:11 Not tainted 6.5.0-rc3-00044-g0a8db05b571a #236 + Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.15.0-1 04/01/2014 + Workqueue: ipv6_addrconf addrconf_dad_work + RIP: 0010:skb_panic+0x152/0x1d0 + Call Trace: + + skb_push+0xc4/0xe0 + ip6mr_cache_report+0xd69/0x19b0 + reg_vif_xmit+0x406/0x690 + dev_hard_start_xmit+0x17e/0x6e0 + __dev_queue_xmit+0x2d6a/0x3d20 + vlan_dev_hard_start_xmit+0x3ab/0x5c0 + dev_hard_start_xmit+0x17e/0x6e0 + __dev_queue_xmit+0x2d6a/0x3d20 + neigh_connected_output+0x3ed/0x570 + ip6_finish_output2+0x5b5/0x1950 + ip6_finish_output+0x693/0x11c0 + ip6_output+0x24b/0x880 + NF_HOOK.constprop.0+0xfd/0x530 + ndisc_send_skb+0x9db/0x1400 + ndisc_send_rs+0x12a/0x6c0 + addrconf_dad_completed+0x3c9/0xea0 + addrconf_dad_work+0x849/0x1420 + process_one_work+0xa22/0x16e0 + worker_thread+0x679/0x10c0 + ret_from_fork+0x28/0x60 + ret_from_fork_asm+0x11/0x20 + +When setup a vlan device on dev pim6reg, DAD ns packet may sent on reg_vif_xmit(). +reg_vif_xmit() + ip6mr_cache_report() + skb_push(skb, -skb_network_offset(pkt));//skb_network_offset(pkt) is 4 +And skb_push declared as: + void *skb_push(struct sk_buff *skb, unsigned int len); + skb->data -= len; + //0xffff88805f86a84c - 0xfffffffc = 0xffff887f5f86a850 +skb->data is set to 0xffff887f5f86a850, which is invalid mem addr, lead to skb_push() fails. + +Fixes: 14fb64e1f449 ("[IPV6] MROUTE: Support PIM-SM (SSM).") +Signed-off-by: Yue Haibing +Reviewed-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/ipv6/ip6mr.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c +index 91f1c5f56d5fa..ee094645c7cea 100644 +--- a/net/ipv6/ip6mr.c ++++ b/net/ipv6/ip6mr.c +@@ -1068,7 +1068,7 @@ static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt, + And all this only to mangle msg->im6_msgtype and + to set msg->im6_mbz to "mbz" :-) + */ +- skb_push(skb, -skb_network_offset(pkt)); ++ __skb_pull(skb, skb_network_offset(pkt)); + + skb_push(skb, sizeof(*msg)); + skb_reset_transport_header(skb); +-- +2.40.1 + diff --git a/queue-5.15/kvm-s390-fix-sthyi-error-handling.patch b/queue-5.15/kvm-s390-fix-sthyi-error-handling.patch new file mode 100644 index 00000000000..f60be324172 --- /dev/null +++ b/queue-5.15/kvm-s390-fix-sthyi-error-handling.patch @@ -0,0 +1,78 @@ +From a53e596b429d442712e11b2d4715f8aa7bff2e53 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 27 Jul 2023 20:29:39 +0200 +Subject: KVM: s390: fix sthyi error handling + +From: Heiko Carstens + +[ Upstream commit 0c02cc576eac161601927b41634f80bfd55bfa9e ] + +Commit 9fb6c9b3fea1 ("s390/sthyi: add cache to store hypervisor info") +added cache handling for store hypervisor info. This also changed the +possible return code for sthyi_fill(). + +Instead of only returning a condition code like the sthyi instruction would +do, it can now also return a negative error value (-ENOMEM). handle_styhi() +was not changed accordingly. In case of an error, the negative error value +would incorrectly injected into the guest PSW. + +Add proper error handling to prevent this, and update the comment which +describes the possible return values of sthyi_fill(). + +Fixes: 9fb6c9b3fea1 ("s390/sthyi: add cache to store hypervisor info") +Reviewed-by: Christian Borntraeger +Link: https://lore.kernel.org/r/20230727182939.2050744-1-hca@linux.ibm.com +Signed-off-by: Heiko Carstens +Signed-off-by: Sasha Levin +--- + arch/s390/kernel/sthyi.c | 6 +++--- + arch/s390/kvm/intercept.c | 9 ++++++--- + 2 files changed, 9 insertions(+), 6 deletions(-) + +diff --git a/arch/s390/kernel/sthyi.c b/arch/s390/kernel/sthyi.c +index 4d141e2c132e5..2ea7f208f0e73 100644 +--- a/arch/s390/kernel/sthyi.c ++++ b/arch/s390/kernel/sthyi.c +@@ -459,9 +459,9 @@ static int sthyi_update_cache(u64 *rc) + * + * Fills the destination with system information returned by the STHYI + * instruction. The data is generated by emulation or execution of STHYI, +- * if available. The return value is the condition code that would be +- * returned, the rc parameter is the return code which is passed in +- * register R2 + 1. ++ * if available. The return value is either a negative error value or ++ * the condition code that would be returned, the rc parameter is the ++ * return code which is passed in register R2 + 1. + */ + int sthyi_fill(void *dst, u64 *rc) + { +diff --git a/arch/s390/kvm/intercept.c b/arch/s390/kvm/intercept.c +index aeb0e0865e890..458b42b50b8cb 100644 +--- a/arch/s390/kvm/intercept.c ++++ b/arch/s390/kvm/intercept.c +@@ -389,8 +389,8 @@ static int handle_partial_execution(struct kvm_vcpu *vcpu) + */ + int handle_sthyi(struct kvm_vcpu *vcpu) + { +- int reg1, reg2, r = 0; +- u64 code, addr, cc = 0, rc = 0; ++ int reg1, reg2, cc = 0, r = 0; ++ u64 code, addr, rc = 0; + struct sthyi_sctns *sctns = NULL; + + if (!test_kvm_facility(vcpu->kvm, 74)) +@@ -421,7 +421,10 @@ int handle_sthyi(struct kvm_vcpu *vcpu) + return -ENOMEM; + + cc = sthyi_fill(sctns, &rc); +- ++ if (cc < 0) { ++ free_page((unsigned long)sctns); ++ return cc; ++ } + out: + if (!cc) { + if (kvm_s390_pv_cpu_is_protected(vcpu)) { +-- +2.40.1 + diff --git a/queue-5.15/misdn-hfcpci-fix-potential-deadlock-on-hc-lock.patch b/queue-5.15/misdn-hfcpci-fix-potential-deadlock-on-hc-lock.patch new file mode 100644 index 00000000000..13e89779f4f --- /dev/null +++ b/queue-5.15/misdn-hfcpci-fix-potential-deadlock-on-hc-lock.patch @@ -0,0 +1,88 @@ +From e2395209aceea49cba1fe5c443d61233a07c255f Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 27 Jul 2023 08:56:19 +0000 +Subject: mISDN: hfcpci: Fix potential deadlock on &hc->lock + +From: Chengfeng Ye + +[ Upstream commit 56c6be35fcbed54279df0a2c9e60480a61841d6f ] + +As &hc->lock is acquired by both timer _hfcpci_softirq() and hardirq +hfcpci_int(), the timer should disable irq before lock acquisition +otherwise deadlock could happen if the timmer is preemtped by the hadr irq. + +Possible deadlock scenario: +hfcpci_softirq() (timer) + -> _hfcpci_softirq() + -> spin_lock(&hc->lock); + + -> hfcpci_int() + -> spin_lock(&hc->lock); (deadlock here) + +This flaw was found by an experimental static analysis tool I am developing +for irq-related deadlock. + +The tentative patch fixes the potential deadlock by spin_lock_irq() +in timer. + +Fixes: b36b654a7e82 ("mISDN: Create /sys/class/mISDN") +Signed-off-by: Chengfeng Ye +Link: https://lore.kernel.org/r/20230727085619.7419-1-dg573847474@gmail.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/isdn/hardware/mISDN/hfcpci.c | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c +index eba58b99cd29d..d6cf01c32a33d 100644 +--- a/drivers/isdn/hardware/mISDN/hfcpci.c ++++ b/drivers/isdn/hardware/mISDN/hfcpci.c +@@ -839,7 +839,7 @@ hfcpci_fill_fifo(struct bchannel *bch) + *z1t = cpu_to_le16(new_z1); /* now send data */ + if (bch->tx_idx < bch->tx_skb->len) + return; +- dev_kfree_skb(bch->tx_skb); ++ dev_kfree_skb_any(bch->tx_skb); + if (get_next_bframe(bch)) + goto next_t_frame; + return; +@@ -895,7 +895,7 @@ hfcpci_fill_fifo(struct bchannel *bch) + } + bz->za[new_f1].z1 = cpu_to_le16(new_z1); /* for next buffer */ + bz->f1 = new_f1; /* next frame */ +- dev_kfree_skb(bch->tx_skb); ++ dev_kfree_skb_any(bch->tx_skb); + get_next_bframe(bch); + } + +@@ -1119,7 +1119,7 @@ tx_birq(struct bchannel *bch) + if (bch->tx_skb && bch->tx_idx < bch->tx_skb->len) + hfcpci_fill_fifo(bch); + else { +- dev_kfree_skb(bch->tx_skb); ++ dev_kfree_skb_any(bch->tx_skb); + if (get_next_bframe(bch)) + hfcpci_fill_fifo(bch); + } +@@ -2277,7 +2277,7 @@ _hfcpci_softirq(struct device *dev, void *unused) + return 0; + + if (hc->hw.int_m2 & HFCPCI_IRQ_ENABLE) { +- spin_lock(&hc->lock); ++ spin_lock_irq(&hc->lock); + bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1); + if (bch && bch->state == ISDN_P_B_RAW) { /* B1 rx&tx */ + main_rec_hfcpci(bch); +@@ -2288,7 +2288,7 @@ _hfcpci_softirq(struct device *dev, void *unused) + main_rec_hfcpci(bch); + tx_birq(bch); + } +- spin_unlock(&hc->lock); ++ spin_unlock_irq(&hc->lock); + } + return 0; + } +-- +2.40.1 + diff --git a/queue-5.15/net-add-missing-data-race-annotation-for-sk_ll_usec.patch b/queue-5.15/net-add-missing-data-race-annotation-for-sk_ll_usec.patch new file mode 100644 index 00000000000..0471df7d733 --- /dev/null +++ b/queue-5.15/net-add-missing-data-race-annotation-for-sk_ll_usec.patch @@ -0,0 +1,36 @@ +From b191306f823ebffa06dc2753934baa71b9fd46e4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:17 +0000 +Subject: net: add missing data-race annotation for sk_ll_usec + +From: Eric Dumazet + +[ Upstream commit e5f0d2dd3c2faa671711dac6d3ff3cef307bcfe3 ] + +In a prior commit I forgot that sk_getsockopt() reads +sk->sk_ll_usec without holding a lock. + +Fixes: 0dbffbb5335a ("net: annotate data race around sk_ll_usec") +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index 0cca1ccf14990..1f9401d757cbb 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1673,7 +1673,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + + #ifdef CONFIG_NET_RX_BUSY_POLL + case SO_BUSY_POLL: +- v.val = sk->sk_ll_usec; ++ v.val = READ_ONCE(sk->sk_ll_usec); + break; + case SO_PREFER_BUSY_POLL: + v.val = READ_ONCE(sk->sk_prefer_busy_poll); +-- +2.40.1 + diff --git a/queue-5.15/net-add-missing-data-race-annotations-around-sk-sk_p.patch b/queue-5.15/net-add-missing-data-race-annotations-around-sk-sk_p.patch new file mode 100644 index 00000000000..9bb4924adab --- /dev/null +++ b/queue-5.15/net-add-missing-data-race-annotations-around-sk-sk_p.patch @@ -0,0 +1,63 @@ +From 73f6e7ab0665db9e7d61853274f3d558ca485a8f Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:16 +0000 +Subject: net: add missing data-race annotations around sk->sk_peek_off + +From: Eric Dumazet + +[ Upstream commit 11695c6e966b0ec7ed1d16777d294cef865a5c91 ] + +sk_getsockopt() runs locklessly, thus we need to annotate the read +of sk->sk_peek_off. + +While we are at it, add corresponding annotations to sk_set_peek_off() +and unix_set_peek_off(). + +Fixes: b9bb53f3836f ("sock: convert sk_peek_offset functions to WRITE_ONCE") +Signed-off-by: Eric Dumazet +Cc: Willem de Bruijn +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 4 ++-- + net/unix/af_unix.c | 2 +- + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index 59abfb2c92266..0cca1ccf14990 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1643,7 +1643,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + if (!sock->ops->set_peek_off) + return -EOPNOTSUPP; + +- v.val = sk->sk_peek_off; ++ v.val = READ_ONCE(sk->sk_peek_off); + break; + case SO_NOFCS: + v.val = sock_flag(sk, SOCK_NOFCS); +@@ -2901,7 +2901,7 @@ EXPORT_SYMBOL(__sk_mem_reclaim); + + int sk_set_peek_off(struct sock *sk, int val) + { +- sk->sk_peek_off = val; ++ WRITE_ONCE(sk->sk_peek_off, val); + return 0; + } + EXPORT_SYMBOL_GPL(sk_set_peek_off); +diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c +index d326540e4938c..7a076d5017d1c 100644 +--- a/net/unix/af_unix.c ++++ b/net/unix/af_unix.c +@@ -717,7 +717,7 @@ static int unix_set_peek_off(struct sock *sk, int val) + if (mutex_lock_interruptible(&u->iolock)) + return -EINTR; + +- sk->sk_peek_off = val; ++ WRITE_ONCE(sk->sk_peek_off, val); + mutex_unlock(&u->iolock); + + return 0; +-- +2.40.1 + diff --git a/queue-5.15/net-add-missing-read_once-sk-sk_rcvbuf-annotation.patch b/queue-5.15/net-add-missing-read_once-sk-sk_rcvbuf-annotation.patch new file mode 100644 index 00000000000..917ca841919 --- /dev/null +++ b/queue-5.15/net-add-missing-read_once-sk-sk_rcvbuf-annotation.patch @@ -0,0 +1,36 @@ +From 17eb2362600976748b1c068336366623518671d3 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:14 +0000 +Subject: net: add missing READ_ONCE(sk->sk_rcvbuf) annotation + +From: Eric Dumazet + +[ Upstream commit b4b553253091cafe9ec38994acf42795e073bef5 ] + +In a prior commit, I forgot to change sk_getsockopt() +when reading sk->sk_rcvbuf locklessly. + +Fixes: ebb3b78db7bf ("tcp: annotate sk->sk_rcvbuf lockless reads") +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index 0e480ac6c4de5..59abfb2c92266 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1460,7 +1460,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + break; + + case SO_RCVBUF: +- v.val = sk->sk_rcvbuf; ++ v.val = READ_ONCE(sk->sk_rcvbuf); + break; + + case SO_REUSEADDR: +-- +2.40.1 + diff --git a/queue-5.15/net-add-missing-read_once-sk-sk_rcvlowat-annotation.patch b/queue-5.15/net-add-missing-read_once-sk-sk_rcvlowat-annotation.patch new file mode 100644 index 00000000000..c269960cde3 --- /dev/null +++ b/queue-5.15/net-add-missing-read_once-sk-sk_rcvlowat-annotation.patch @@ -0,0 +1,36 @@ +From d07231958761825a4c5017281fdd4152c523bc2d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:11 +0000 +Subject: net: add missing READ_ONCE(sk->sk_rcvlowat) annotation + +From: Eric Dumazet + +[ Upstream commit e6d12bdb435d23ff6c1890c852d85408a2f496ee ] + +In a prior commit, I forgot to change sk_getsockopt() +when reading sk->sk_rcvlowat locklessly. + +Fixes: eac66402d1c3 ("net: annotate sk->sk_rcvlowat lockless reads") +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index d392efa0d9551..ffd566d52eec3 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1549,7 +1549,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + break; + + case SO_RCVLOWAT: +- v.val = sk->sk_rcvlowat; ++ v.val = READ_ONCE(sk->sk_rcvlowat); + break; + + case SO_SNDLOWAT: +-- +2.40.1 + diff --git a/queue-5.15/net-add-missing-read_once-sk-sk_sndbuf-annotation.patch b/queue-5.15/net-add-missing-read_once-sk-sk_sndbuf-annotation.patch new file mode 100644 index 00000000000..b5b7607feff --- /dev/null +++ b/queue-5.15/net-add-missing-read_once-sk-sk_sndbuf-annotation.patch @@ -0,0 +1,36 @@ +From 2c52595e453196d3b5e623a9bade2a01bab3496e Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:13 +0000 +Subject: net: add missing READ_ONCE(sk->sk_sndbuf) annotation + +From: Eric Dumazet + +[ Upstream commit 74bc084327c643499474ba75df485607da37dd6e ] + +In a prior commit, I forgot to change sk_getsockopt() +when reading sk->sk_sndbuf locklessly. + +Fixes: e292f05e0df7 ("tcp: annotate sk->sk_sndbuf lockless reads") +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index ffd566d52eec3..0e480ac6c4de5 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1456,7 +1456,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + break; + + case SO_SNDBUF: +- v.val = sk->sk_sndbuf; ++ v.val = READ_ONCE(sk->sk_sndbuf); + break; + + case SO_RCVBUF: +-- +2.40.1 + diff --git a/queue-5.15/net-annotate-data-races-around-sk-sk_max_pacing_rate.patch b/queue-5.15/net-annotate-data-races-around-sk-sk_max_pacing_rate.patch new file mode 100644 index 00000000000..4bc7cd48f2f --- /dev/null +++ b/queue-5.15/net-annotate-data-races-around-sk-sk_max_pacing_rate.patch @@ -0,0 +1,54 @@ +From 3835ef7026817cd468cc41324d37ce1623a0dda5 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 15:03:10 +0000 +Subject: net: annotate data-races around sk->sk_max_pacing_rate + +From: Eric Dumazet + +[ Upstream commit ea7f45ef77b39e72244d282e47f6cb1ef4135cd2 ] + +sk_getsockopt() runs locklessly. This means sk->sk_max_pacing_rate +can be read while other threads are changing its value. + +Fixes: 62748f32d501 ("net: introduce SO_MAX_PACING_RATE") +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/sock.c | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +diff --git a/net/core/sock.c b/net/core/sock.c +index cf1e437ae4875..d392efa0d9551 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1297,7 +1297,8 @@ int sock_setsockopt(struct socket *sock, int level, int optname, + cmpxchg(&sk->sk_pacing_status, + SK_PACING_NONE, + SK_PACING_NEEDED); +- sk->sk_max_pacing_rate = ulval; ++ /* Pairs with READ_ONCE() from sk_getsockopt() */ ++ WRITE_ONCE(sk->sk_max_pacing_rate, ulval); + sk->sk_pacing_rate = min(sk->sk_pacing_rate, ulval); + break; + } +@@ -1680,12 +1681,14 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + #endif + + case SO_MAX_PACING_RATE: ++ /* The READ_ONCE() pair with the WRITE_ONCE() in sk_setsockopt() */ + if (sizeof(v.ulval) != sizeof(v.val) && len >= sizeof(v.ulval)) { + lv = sizeof(v.ulval); +- v.ulval = sk->sk_max_pacing_rate; ++ v.ulval = READ_ONCE(sk->sk_max_pacing_rate); + } else { + /* 32bit version */ +- v.val = min_t(unsigned long, sk->sk_max_pacing_rate, ~0U); ++ v.val = min_t(unsigned long, ~0U, ++ READ_ONCE(sk->sk_max_pacing_rate)); + } + break; + +-- +2.40.1 + diff --git a/queue-5.15/net-dcb-choose-correct-policy-to-parse-dcb_attr_bcn.patch b/queue-5.15/net-dcb-choose-correct-policy-to-parse-dcb_attr_bcn.patch new file mode 100644 index 00000000000..30c11373eae --- /dev/null +++ b/queue-5.15/net-dcb-choose-correct-policy-to-parse-dcb_attr_bcn.patch @@ -0,0 +1,103 @@ +From 7c3412dfe87f83e0c222555ef39fe5fd3fe793cb Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 1 Aug 2023 09:32:48 +0800 +Subject: net: dcb: choose correct policy to parse DCB_ATTR_BCN + +From: Lin Ma + +[ Upstream commit 31d49ba033095f6e8158c60f69714a500922e0c3 ] + +The dcbnl_bcn_setcfg uses erroneous policy to parse tb[DCB_ATTR_BCN], +which is introduced in commit 859ee3c43812 ("DCB: Add support for DCB +BCN"). Please see the comment in below code + +static int dcbnl_bcn_setcfg(...) +{ + ... + ret = nla_parse_nested_deprecated(..., dcbnl_pfc_up_nest, .. ) + // !!! dcbnl_pfc_up_nest for attributes + // DCB_PFC_UP_ATTR_0 to DCB_PFC_UP_ATTR_ALL in enum dcbnl_pfc_up_attrs + ... + for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) { + // !!! DCB_BCN_ATTR_RP_0 to DCB_BCN_ATTR_RP_7 in enum dcbnl_bcn_attrs + ... + value_byte = nla_get_u8(data[i]); + ... + } + ... + for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) { + // !!! DCB_BCN_ATTR_BCNA_0 to DCB_BCN_ATTR_RI in enum dcbnl_bcn_attrs + ... + value_int = nla_get_u32(data[i]); + ... + } + ... +} + +That is, the nla_parse_nested_deprecated uses dcbnl_pfc_up_nest +attributes to parse nlattr defined in dcbnl_pfc_up_attrs. But the +following access code fetch each nlattr as dcbnl_bcn_attrs attributes. +By looking up the associated nla_policy for dcbnl_bcn_attrs. We can find +the beginning part of these two policies are "same". + +static const struct nla_policy dcbnl_pfc_up_nest[...] = { + [DCB_PFC_UP_ATTR_0] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_1] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_2] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_3] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_4] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_5] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_6] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_7] = {.type = NLA_U8}, + [DCB_PFC_UP_ATTR_ALL] = {.type = NLA_FLAG}, +}; + +static const struct nla_policy dcbnl_bcn_nest[...] = { + [DCB_BCN_ATTR_RP_0] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_1] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_2] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_3] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_4] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_5] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_6] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_7] = {.type = NLA_U8}, + [DCB_BCN_ATTR_RP_ALL] = {.type = NLA_FLAG}, + // from here is somewhat different + [DCB_BCN_ATTR_BCNA_0] = {.type = NLA_U32}, + ... + [DCB_BCN_ATTR_ALL] = {.type = NLA_FLAG}, +}; + +Therefore, the current code is buggy and this +nla_parse_nested_deprecated could overflow the dcbnl_pfc_up_nest and use +the adjacent nla_policy to parse attributes from DCB_BCN_ATTR_BCNA_0. + +Hence use the correct policy dcbnl_bcn_nest to parse the nested +tb[DCB_ATTR_BCN] TLV. + +Fixes: 859ee3c43812 ("DCB: Add support for DCB BCN") +Signed-off-by: Lin Ma +Reviewed-by: Simon Horman +Link: https://lore.kernel.org/r/20230801013248.87240-1-linma@zju.edu.cn +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/dcb/dcbnl.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/dcb/dcbnl.c b/net/dcb/dcbnl.c +index dc4fb699b56c3..d2981e89d3638 100644 +--- a/net/dcb/dcbnl.c ++++ b/net/dcb/dcbnl.c +@@ -946,7 +946,7 @@ static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlmsghdr *nlh, + return -EOPNOTSUPP; + + ret = nla_parse_nested_deprecated(data, DCB_BCN_ATTR_MAX, +- tb[DCB_ATTR_BCN], dcbnl_pfc_up_nest, ++ tb[DCB_ATTR_BCN], dcbnl_bcn_nest, + NULL); + if (ret) + return ret; +-- +2.40.1 + diff --git a/queue-5.15/net-dsa-fix-value-check-in-bcm_sf2_sw_probe.patch b/queue-5.15/net-dsa-fix-value-check-in-bcm_sf2_sw_probe.patch new file mode 100644 index 00000000000..b661698551c --- /dev/null +++ b/queue-5.15/net-dsa-fix-value-check-in-bcm_sf2_sw_probe.patch @@ -0,0 +1,52 @@ +From 0bafeedd19187a4a7909d22cb2966ae6eed5887d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 27 Jul 2023 01:05:06 +0800 +Subject: net: dsa: fix value check in bcm_sf2_sw_probe() + +From: Yuanjun Gong + +[ Upstream commit dadc5b86cc9459581f37fe755b431adc399ea393 ] + +in bcm_sf2_sw_probe(), check the return value of clk_prepare_enable() +and return the error code if clk_prepare_enable() returns an +unexpected value. + +Fixes: e9ec5c3bd238 ("net: dsa: bcm_sf2: request and handle clocks") +Signed-off-by: Yuanjun Gong +Reviewed-by: Florian Fainelli +Link: https://lore.kernel.org/r/20230726170506.16547-1-ruc_gongyuanjun@163.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/net/dsa/bcm_sf2.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c +index d76b2377d66ef..773d751ef169f 100644 +--- a/drivers/net/dsa/bcm_sf2.c ++++ b/drivers/net/dsa/bcm_sf2.c +@@ -1422,7 +1422,9 @@ static int bcm_sf2_sw_probe(struct platform_device *pdev) + if (IS_ERR(priv->clk)) + return PTR_ERR(priv->clk); + +- clk_prepare_enable(priv->clk); ++ ret = clk_prepare_enable(priv->clk); ++ if (ret) ++ return ret; + + priv->clk_mdiv = devm_clk_get_optional(&pdev->dev, "sw_switch_mdiv"); + if (IS_ERR(priv->clk_mdiv)) { +@@ -1430,7 +1432,9 @@ static int bcm_sf2_sw_probe(struct platform_device *pdev) + goto out_clk; + } + +- clk_prepare_enable(priv->clk_mdiv); ++ ret = clk_prepare_enable(priv->clk_mdiv); ++ if (ret) ++ goto out_clk; + + ret = bcm_sf2_sw_rst(priv); + if (ret) { +-- +2.40.1 + diff --git a/queue-5.15/net-korina-handle-clk-prepare-error-in-korina_probe.patch b/queue-5.15/net-korina-handle-clk-prepare-error-in-korina_probe.patch new file mode 100644 index 00000000000..cfa56f17621 --- /dev/null +++ b/queue-5.15/net-korina-handle-clk-prepare-error-in-korina_probe.patch @@ -0,0 +1,43 @@ +From 2a378fa66d28719a0bca90b22e7cf73eed5070c4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 17:05:35 +0800 +Subject: net: korina: handle clk prepare error in korina_probe() + +From: Yuanjun Gong + +[ Upstream commit 0b6291ad1940c403734312d0e453e8dac9148f69 ] + +in korina_probe(), the return value of clk_prepare_enable() +should be checked since it might fail. we can use +devm_clk_get_optional_enabled() instead of devm_clk_get_optional() +and clk_prepare_enable() to automatically handle the error. + +Fixes: e4cd854ec487 ("net: korina: Get mdio input clock via common clock framework") +Signed-off-by: Yuanjun Gong +Link: https://lore.kernel.org/r/20230731090535.21416-1-ruc_gongyuanjun@163.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/korina.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/drivers/net/ethernet/korina.c b/drivers/net/ethernet/korina.c +index df9a8eefa007a..916e85039b610 100644 +--- a/drivers/net/ethernet/korina.c ++++ b/drivers/net/ethernet/korina.c +@@ -1301,11 +1301,10 @@ static int korina_probe(struct platform_device *pdev) + else if (of_get_ethdev_address(pdev->dev.of_node, dev) < 0) + eth_hw_addr_random(dev); + +- clk = devm_clk_get_optional(&pdev->dev, "mdioclk"); ++ clk = devm_clk_get_optional_enabled(&pdev->dev, "mdioclk"); + if (IS_ERR(clk)) + return PTR_ERR(clk); + if (clk) { +- clk_prepare_enable(clk); + lp->mii_clock_freq = clk_get_rate(clk); + } else { + lp->mii_clock_freq = 200000000; /* max possible input clk */ +-- +2.40.1 + diff --git a/queue-5.15/net-ll_temac-fix-error-checking-of-irq_of_parse_and_.patch b/queue-5.15/net-ll_temac-fix-error-checking-of-irq_of_parse_and_.patch new file mode 100644 index 00000000000..b61f5d44e0a --- /dev/null +++ b/queue-5.15/net-ll_temac-fix-error-checking-of-irq_of_parse_and_.patch @@ -0,0 +1,54 @@ +From 854ba1c63309ce05e0b0d0d41d1890b5060701d2 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 10:42:32 +0300 +Subject: net: ll_temac: fix error checking of irq_of_parse_and_map() + +From: Dan Carpenter + +[ Upstream commit ef45e8400f5bb66b03cc949f76c80e2a118447de ] + +Most kernel functions return negative error codes but some irq functions +return zero on error. In this code irq_of_parse_and_map(), returns zero +and platform_get_irq() returns negative error codes. We need to handle +both cases appropriately. + +Fixes: 8425c41d1ef7 ("net: ll_temac: Extend support to non-device-tree platforms") +Signed-off-by: Dan Carpenter +Acked-by: Esben Haabendal +Reviewed-by: Yang Yingliang +Reviewed-by: Harini Katakam +Link: https://lore.kernel.org/r/3d0aef75-06e0-45a5-a2a6-2cc4738d4143@moroto.mountain +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/xilinx/ll_temac_main.c | 12 ++++++++---- + 1 file changed, 8 insertions(+), 4 deletions(-) + +diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c +index 303de9293fc71..b4db50c9e7038 100644 +--- a/drivers/net/ethernet/xilinx/ll_temac_main.c ++++ b/drivers/net/ethernet/xilinx/ll_temac_main.c +@@ -1556,12 +1556,16 @@ static int temac_probe(struct platform_device *pdev) + } + + /* Error handle returned DMA RX and TX interrupts */ +- if (lp->rx_irq < 0) +- return dev_err_probe(&pdev->dev, lp->rx_irq, ++ if (lp->rx_irq <= 0) { ++ rc = lp->rx_irq ?: -EINVAL; ++ return dev_err_probe(&pdev->dev, rc, + "could not get DMA RX irq\n"); +- if (lp->tx_irq < 0) +- return dev_err_probe(&pdev->dev, lp->tx_irq, ++ } ++ if (lp->tx_irq <= 0) { ++ rc = lp->tx_irq ?: -EINVAL; ++ return dev_err_probe(&pdev->dev, rc, + "could not get DMA TX irq\n"); ++ } + + if (temac_np) { + /* Retrieve the MAC address */ +-- +2.40.1 + diff --git a/queue-5.15/net-ll_temac-switch-to-use-dev_err_probe-helper.patch b/queue-5.15/net-ll_temac-switch-to-use-dev_err_probe-helper.patch new file mode 100644 index 00000000000..b88a352157b --- /dev/null +++ b/queue-5.15/net-ll_temac-switch-to-use-dev_err_probe-helper.patch @@ -0,0 +1,50 @@ +From 532bd581b353e133b3a49a3a79a4a1d3ff437231 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 15 Sep 2022 19:42:14 +0800 +Subject: net: ll_temac: Switch to use dev_err_probe() helper + +From: Yang Yingliang + +[ Upstream commit 75ae8c284c00dc3584b7c173f6fcf96ee15bd02c ] + +dev_err() can be replace with dev_err_probe() which will check if error +code is -EPROBE_DEFER. + +Signed-off-by: Yang Yingliang +Signed-off-by: David S. Miller +Stable-dep-of: ef45e8400f5b ("net: ll_temac: fix error checking of irq_of_parse_and_map()") +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/xilinx/ll_temac_main.c | 16 ++++++---------- + 1 file changed, 6 insertions(+), 10 deletions(-) + +diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c +index 2ab29efa6b6e4..303de9293fc71 100644 +--- a/drivers/net/ethernet/xilinx/ll_temac_main.c ++++ b/drivers/net/ethernet/xilinx/ll_temac_main.c +@@ -1556,16 +1556,12 @@ static int temac_probe(struct platform_device *pdev) + } + + /* Error handle returned DMA RX and TX interrupts */ +- if (lp->rx_irq < 0) { +- if (lp->rx_irq != -EPROBE_DEFER) +- dev_err(&pdev->dev, "could not get DMA RX irq\n"); +- return lp->rx_irq; +- } +- if (lp->tx_irq < 0) { +- if (lp->tx_irq != -EPROBE_DEFER) +- dev_err(&pdev->dev, "could not get DMA TX irq\n"); +- return lp->tx_irq; +- } ++ if (lp->rx_irq < 0) ++ return dev_err_probe(&pdev->dev, lp->rx_irq, ++ "could not get DMA RX irq\n"); ++ if (lp->tx_irq < 0) ++ return dev_err_probe(&pdev->dev, lp->tx_irq, ++ "could not get DMA TX irq\n"); + + if (temac_np) { + /* Retrieve the MAC address */ +-- +2.40.1 + diff --git a/queue-5.15/net-mlx5-dr-fix-memory-leak-in-mlx5dr_cmd_create_ref.patch b/queue-5.15/net-mlx5-dr-fix-memory-leak-in-mlx5dr_cmd_create_ref.patch new file mode 100644 index 00000000000..0079ac555e2 --- /dev/null +++ b/queue-5.15/net-mlx5-dr-fix-memory-leak-in-mlx5dr_cmd_create_ref.patch @@ -0,0 +1,44 @@ +From 3f0dff3738cfc34aa58aa05ada1edd93fc07dad6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 5 Jul 2023 20:15:27 +0800 +Subject: net/mlx5: DR, fix memory leak in mlx5dr_cmd_create_reformat_ctx + +From: Zhengchao Shao + +[ Upstream commit 5dd77585dd9d0e03dd1bceb95f0269a7eaf6b936 ] + +when mlx5_cmd_exec failed in mlx5dr_cmd_create_reformat_ctx, the memory +pointed by 'in' is not released, which will cause memory leak. Move memory +release after mlx5_cmd_exec. + +Fixes: 1d9186476e12 ("net/mlx5: DR, Add direct rule command utilities") +Signed-off-by: Zhengchao Shao +Reviewed-by: Leon Romanovsky +Signed-off-by: Saeed Mahameed +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/mellanox/mlx5/core/steering/dr_cmd.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_cmd.c +index fcf705ce421f3..aa003a75946bb 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_cmd.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/steering/dr_cmd.c +@@ -528,11 +528,12 @@ int mlx5dr_cmd_create_reformat_ctx(struct mlx5_core_dev *mdev, + + err = mlx5_cmd_exec(mdev, in, inlen, out, sizeof(out)); + if (err) +- return err; ++ goto err_free_in; + + *reformat_id = MLX5_GET(alloc_packet_reformat_context_out, out, packet_reformat_id); +- kvfree(in); + ++err_free_in: ++ kvfree(in); + return err; + } + +-- +2.40.1 + diff --git a/queue-5.15/net-mlx5-fs_core-make-find_closest_ft-more-generic.patch b/queue-5.15/net-mlx5-fs_core-make-find_closest_ft-more-generic.patch new file mode 100644 index 00000000000..a3caf4cf24f --- /dev/null +++ b/queue-5.15/net-mlx5-fs_core-make-find_closest_ft-more-generic.patch @@ -0,0 +1,120 @@ +From 671a68d7701b091dd5f8ea577306fb83b7f3e98c Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 14:58:40 +0300 +Subject: net/mlx5: fs_core: Make find_closest_ft more generic + +From: Jianbo Liu + +[ Upstream commit 618d28a535a0582617465d14e05f3881736a2962 ] + +As find_closest_ft_recursive is called to find the closest FT, the +first parameter of find_closest_ft can be changed from fs_prio to +fs_node. Thus this function is extended to find the closest FT for the +nodes of any type, not only prios, but also the sub namespaces. + +Signed-off-by: Jianbo Liu +Signed-off-by: Leon Romanovsky +Link: https://lore.kernel.org/r/d3962c2b443ec8dde7a740dc742a1f052d5e256c.1690803944.git.leonro@nvidia.com +Signed-off-by: Jakub Kicinski +Stable-dep-of: c635ca45a7a2 ("net/mlx5: fs_core: Skip the FTs in the same FS_TYPE_PRIO_CHAINS fs_prio") +Signed-off-by: Sasha Levin +--- + .../net/ethernet/mellanox/mlx5/core/fs_core.c | 29 +++++++++---------- + 1 file changed, 14 insertions(+), 15 deletions(-) + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +index cb3f9de3d00ba..8b1a5f5637597 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +@@ -818,18 +818,17 @@ static struct mlx5_flow_table *find_closest_ft_recursive(struct fs_node *root, + return ft; + } + +-/* If reverse is false then return the first flow table in next priority of +- * prio in the tree, else return the last flow table in the previous priority +- * of prio in the tree. ++/* If reverse is false then return the first flow table next to the passed node ++ * in the tree, else return the last flow table before the node in the tree. + */ +-static struct mlx5_flow_table *find_closest_ft(struct fs_prio *prio, bool reverse) ++static struct mlx5_flow_table *find_closest_ft(struct fs_node *node, bool reverse) + { + struct mlx5_flow_table *ft = NULL; + struct fs_node *curr_node; + struct fs_node *parent; + +- parent = prio->node.parent; +- curr_node = &prio->node; ++ parent = node->parent; ++ curr_node = node; + while (!ft && parent) { + ft = find_closest_ft_recursive(parent, &curr_node->list, reverse); + curr_node = parent; +@@ -839,15 +838,15 @@ static struct mlx5_flow_table *find_closest_ft(struct fs_prio *prio, bool revers + } + + /* Assuming all the tree is locked by mutex chain lock */ +-static struct mlx5_flow_table *find_next_chained_ft(struct fs_prio *prio) ++static struct mlx5_flow_table *find_next_chained_ft(struct fs_node *node) + { +- return find_closest_ft(prio, false); ++ return find_closest_ft(node, false); + } + + /* Assuming all the tree is locked by mutex chain lock */ +-static struct mlx5_flow_table *find_prev_chained_ft(struct fs_prio *prio) ++static struct mlx5_flow_table *find_prev_chained_ft(struct fs_node *node) + { +- return find_closest_ft(prio, true); ++ return find_closest_ft(node, true); + } + + static struct mlx5_flow_table *find_next_fwd_ft(struct mlx5_flow_table *ft, +@@ -859,7 +858,7 @@ static struct mlx5_flow_table *find_next_fwd_ft(struct mlx5_flow_table *ft, + next_ns = flow_act->action & MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_NS; + fs_get_obj(prio, next_ns ? ft->ns->node.parent : ft->node.parent); + +- return find_next_chained_ft(prio); ++ return find_next_chained_ft(&prio->node); + } + + static int connect_fts_in_prio(struct mlx5_core_dev *dev, +@@ -890,7 +889,7 @@ static int connect_prev_fts(struct mlx5_core_dev *dev, + { + struct mlx5_flow_table *prev_ft; + +- prev_ft = find_prev_chained_ft(prio); ++ prev_ft = find_prev_chained_ft(&prio->node); + if (prev_ft) { + struct fs_prio *prev_prio; + +@@ -1036,7 +1035,7 @@ static int connect_flow_table(struct mlx5_core_dev *dev, struct mlx5_flow_table + if (err) + return err; + +- next_ft = first_ft ? first_ft : find_next_chained_ft(prio); ++ next_ft = first_ft ? first_ft : find_next_chained_ft(&prio->node); + err = connect_fwd_rules(dev, ft, next_ft); + if (err) + return err; +@@ -1111,7 +1110,7 @@ static struct mlx5_flow_table *__mlx5_create_flow_table(struct mlx5_flow_namespa + + tree_init_node(&ft->node, del_hw_flow_table, del_sw_flow_table); + next_ft = unmanaged ? ft_attr->next_ft : +- find_next_chained_ft(fs_prio); ++ find_next_chained_ft(&fs_prio->node); + ft->def_miss_action = ns->def_miss_action; + ft->ns = ns; + err = root->cmds->create_flow_table(root, ft, ft_attr->max_fte, next_ft); +@@ -2086,7 +2085,7 @@ static struct mlx5_flow_table *find_next_ft(struct mlx5_flow_table *ft) + + if (!list_is_last(&ft->node.list, &prio->node.children)) + return list_next_entry(ft, node.list); +- return find_next_chained_ft(prio); ++ return find_next_chained_ft(&prio->node); + } + + static int update_root_ft_destroy(struct mlx5_flow_table *ft) +-- +2.40.1 + diff --git a/queue-5.15/net-mlx5-fs_core-skip-the-fts-in-the-same-fs_type_pr.patch b/queue-5.15/net-mlx5-fs_core-skip-the-fts-in-the-same-fs_type_pr.patch new file mode 100644 index 00000000000..3ae03a08ae3 --- /dev/null +++ b/queue-5.15/net-mlx5-fs_core-skip-the-fts-in-the-same-fs_type_pr.patch @@ -0,0 +1,196 @@ +From ca43f386fdc6febfecb2358c13cf72b9c14cbb03 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 14:58:41 +0300 +Subject: net/mlx5: fs_core: Skip the FTs in the same FS_TYPE_PRIO_CHAINS + fs_prio + +From: Jianbo Liu + +[ Upstream commit c635ca45a7a2023904a1f851e99319af7b87017d ] + +In the cited commit, new type of FS_TYPE_PRIO_CHAINS fs_prio was added +to support multiple parallel namespaces for multi-chains. And we skip +all the flow tables under the fs_node of this type unconditionally, +when searching for the next or previous flow table to connect for a +new table. + +As this search function is also used for find new root table when the +old one is being deleted, it will skip the entire FS_TYPE_PRIO_CHAINS +fs_node next to the old root. However, new root table should be chosen +from it if there is any table in it. Fix it by skipping only the flow +tables in the same FS_TYPE_PRIO_CHAINS fs_node when finding the +closest FT for a fs_node. + +Besides, complete the connecting from FTs of previous priority of prio +because there should be multiple prevs after this fs_prio type is +introduced. And also the next FT should be chosen from the first flow +table next to the prio in the same FS_TYPE_PRIO_CHAINS fs_prio, if +this prio is the first child. + +Fixes: 328edb499f99 ("net/mlx5: Split FDB fast path prio to multiple namespaces") +Signed-off-by: Jianbo Liu +Reviewed-by: Paul Blakey +Signed-off-by: Leon Romanovsky +Link: https://lore.kernel.org/r/7a95754df479e722038996c97c97b062b372591f.1690803944.git.leonro@nvidia.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + .../net/ethernet/mellanox/mlx5/core/fs_core.c | 80 +++++++++++++++++-- + 1 file changed, 72 insertions(+), 8 deletions(-) + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +index 8b1a5f5637597..161ad2ae40196 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +@@ -802,7 +802,7 @@ static struct mlx5_flow_table *find_closest_ft_recursive(struct fs_node *root, + struct fs_node *iter = list_entry(start, struct fs_node, list); + struct mlx5_flow_table *ft = NULL; + +- if (!root || root->type == FS_TYPE_PRIO_CHAINS) ++ if (!root) + return NULL; + + list_for_each_advance_continue(iter, &root->children, reverse) { +@@ -818,19 +818,42 @@ static struct mlx5_flow_table *find_closest_ft_recursive(struct fs_node *root, + return ft; + } + ++static struct fs_node *find_prio_chains_parent(struct fs_node *parent, ++ struct fs_node **child) ++{ ++ struct fs_node *node = NULL; ++ ++ while (parent && parent->type != FS_TYPE_PRIO_CHAINS) { ++ node = parent; ++ parent = parent->parent; ++ } ++ ++ if (child) ++ *child = node; ++ ++ return parent; ++} ++ + /* If reverse is false then return the first flow table next to the passed node + * in the tree, else return the last flow table before the node in the tree. ++ * If skip is true, skip the flow tables in the same prio_chains prio. + */ +-static struct mlx5_flow_table *find_closest_ft(struct fs_node *node, bool reverse) ++static struct mlx5_flow_table *find_closest_ft(struct fs_node *node, bool reverse, ++ bool skip) + { ++ struct fs_node *prio_chains_parent = NULL; + struct mlx5_flow_table *ft = NULL; + struct fs_node *curr_node; + struct fs_node *parent; + ++ if (skip) ++ prio_chains_parent = find_prio_chains_parent(node, NULL); + parent = node->parent; + curr_node = node; + while (!ft && parent) { +- ft = find_closest_ft_recursive(parent, &curr_node->list, reverse); ++ if (parent != prio_chains_parent) ++ ft = find_closest_ft_recursive(parent, &curr_node->list, ++ reverse); + curr_node = parent; + parent = curr_node->parent; + } +@@ -840,13 +863,13 @@ static struct mlx5_flow_table *find_closest_ft(struct fs_node *node, bool revers + /* Assuming all the tree is locked by mutex chain lock */ + static struct mlx5_flow_table *find_next_chained_ft(struct fs_node *node) + { +- return find_closest_ft(node, false); ++ return find_closest_ft(node, false, true); + } + + /* Assuming all the tree is locked by mutex chain lock */ + static struct mlx5_flow_table *find_prev_chained_ft(struct fs_node *node) + { +- return find_closest_ft(node, true); ++ return find_closest_ft(node, true, true); + } + + static struct mlx5_flow_table *find_next_fwd_ft(struct mlx5_flow_table *ft, +@@ -882,21 +905,55 @@ static int connect_fts_in_prio(struct mlx5_core_dev *dev, + return 0; + } + ++static struct mlx5_flow_table *find_closet_ft_prio_chains(struct fs_node *node, ++ struct fs_node *parent, ++ struct fs_node **child, ++ bool reverse) ++{ ++ struct mlx5_flow_table *ft; ++ ++ ft = find_closest_ft(node, reverse, false); ++ ++ if (ft && parent == find_prio_chains_parent(&ft->node, child)) ++ return ft; ++ ++ return NULL; ++} ++ + /* Connect flow tables from previous priority of prio to ft */ + static int connect_prev_fts(struct mlx5_core_dev *dev, + struct mlx5_flow_table *ft, + struct fs_prio *prio) + { ++ struct fs_node *prio_parent, *parent = NULL, *child, *node; + struct mlx5_flow_table *prev_ft; ++ int err = 0; ++ ++ prio_parent = find_prio_chains_parent(&prio->node, &child); ++ ++ /* return directly if not under the first sub ns of prio_chains prio */ ++ if (prio_parent && !list_is_first(&child->list, &prio_parent->children)) ++ return 0; + + prev_ft = find_prev_chained_ft(&prio->node); +- if (prev_ft) { ++ while (prev_ft) { + struct fs_prio *prev_prio; + + fs_get_obj(prev_prio, prev_ft->node.parent); +- return connect_fts_in_prio(dev, prev_prio, ft); ++ err = connect_fts_in_prio(dev, prev_prio, ft); ++ if (err) ++ break; ++ ++ if (!parent) { ++ parent = find_prio_chains_parent(&prev_prio->node, &child); ++ if (!parent) ++ break; ++ } ++ ++ node = child; ++ prev_ft = find_closet_ft_prio_chains(node, parent, &child, true); + } +- return 0; ++ return err; + } + + static int update_root_ft_create(struct mlx5_flow_table *ft, struct fs_prio +@@ -2079,12 +2136,19 @@ EXPORT_SYMBOL(mlx5_del_flow_rules); + /* Assuming prio->node.children(flow tables) is sorted by level */ + static struct mlx5_flow_table *find_next_ft(struct mlx5_flow_table *ft) + { ++ struct fs_node *prio_parent, *child; + struct fs_prio *prio; + + fs_get_obj(prio, ft->node.parent); + + if (!list_is_last(&ft->node.list, &prio->node.children)) + return list_next_entry(ft, node.list); ++ ++ prio_parent = find_prio_chains_parent(&prio->node, &child); ++ ++ if (prio_parent && list_is_first(&child->list, &prio_parent->children)) ++ return find_closest_ft(&prio->node, false, false); ++ + return find_next_chained_ft(&prio->node); + } + +-- +2.40.1 + diff --git a/queue-5.15/net-mlx5e-fix-return-value-check-in-mlx5e_ipsec_remo.patch b/queue-5.15/net-mlx5e-fix-return-value-check-in-mlx5e_ipsec_remo.patch new file mode 100644 index 00000000000..993bab09104 --- /dev/null +++ b/queue-5.15/net-mlx5e-fix-return-value-check-in-mlx5e_ipsec_remo.patch @@ -0,0 +1,39 @@ +From a10d0ca9aca71f5e1b7ac60106cb4b292fd1ddeb Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 25 Jul 2023 14:56:55 +0800 +Subject: net/mlx5e: fix return value check in mlx5e_ipsec_remove_trailer() + +From: Yuanjun Gong + +[ Upstream commit e5bcb7564d3bd0c88613c76963c5349be9c511c5 ] + +mlx5e_ipsec_remove_trailer() should return an error code if function +pskb_trim() returns an unexpected value. + +Fixes: 2ac9cfe78223 ("net/mlx5e: IPSec, Add Innova IPSec offload TX data path") +Signed-off-by: Yuanjun Gong +Reviewed-by: Leon Romanovsky +Signed-off-by: Saeed Mahameed +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.c +index b56fea142c246..4590d19c25cf7 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.c +@@ -121,7 +121,9 @@ static int mlx5e_ipsec_remove_trailer(struct sk_buff *skb, struct xfrm_state *x) + + trailer_len = alen + plen + 2; + +- pskb_trim(skb, skb->len - trailer_len); ++ ret = pskb_trim(skb, skb->len - trailer_len); ++ if (unlikely(ret)) ++ return ret; + if (skb->protocol == htons(ETH_P_IP)) { + ipv4hdr->tot_len = htons(ntohs(ipv4hdr->tot_len) - trailer_len); + ip_send_check(ipv4hdr); +-- +2.40.1 + diff --git a/queue-5.15/net-netsec-ignore-phy-mode-on-synquacer-in-dt-mode.patch b/queue-5.15/net-netsec-ignore-phy-mode-on-synquacer-in-dt-mode.patch new file mode 100644 index 00000000000..b5b022ee451 --- /dev/null +++ b/queue-5.15/net-netsec-ignore-phy-mode-on-synquacer-in-dt-mode.patch @@ -0,0 +1,61 @@ +From 01bde567c4a7cee6045d2e2af7f51650919ed75d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 11:48:32 +0100 +Subject: net: netsec: Ignore 'phy-mode' on SynQuacer in DT mode + +From: Mark Brown + +[ Upstream commit f3bb7759a924713bc54d15f6d0d70733b5935fad ] + +As documented in acd7aaf51b20 ("netsec: ignore 'phy-mode' device +property on ACPI systems") the SocioNext SynQuacer platform ships with +firmware defining the PHY mode as RGMII even though the physical +configuration of the PHY is for TX and RX delays. Since bbc4d71d63549bc +("net: phy: realtek: fix rtl8211e rx/tx delay config") this has caused +misconfiguration of the PHY, rendering the network unusable. + +This was worked around for ACPI by ignoring the phy-mode property but +the system is also used with DT. For DT instead if we're running on a +SynQuacer force a working PHY mode, as well as the standard EDK2 +firmware with DT there are also some of these systems that use u-boot +and might not initialise the PHY if not netbooting. Newer firmware +imagaes for at least EDK2 are available from Linaro so print a warning +when doing this. + +Fixes: 533dd11a12f6 ("net: socionext: Add Synquacer NetSec driver") +Signed-off-by: Mark Brown +Acked-by: Ard Biesheuvel +Acked-by: Ilias Apalodimas +Reviewed-by: Andrew Lunn +Link: https://lore.kernel.org/r/20230731-synquacer-net-v3-1-944be5f06428@kernel.org +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/socionext/netsec.c | 11 +++++++++++ + 1 file changed, 11 insertions(+) + +diff --git a/drivers/net/ethernet/socionext/netsec.c b/drivers/net/ethernet/socionext/netsec.c +index 6b8013fb17c38..eb59e8abe6915 100644 +--- a/drivers/net/ethernet/socionext/netsec.c ++++ b/drivers/net/ethernet/socionext/netsec.c +@@ -1851,6 +1851,17 @@ static int netsec_of_probe(struct platform_device *pdev, + return err; + } + ++ /* ++ * SynQuacer is physically configured with TX and RX delays ++ * but the standard firmware claimed otherwise for a long ++ * time, ignore it. ++ */ ++ if (of_machine_is_compatible("socionext,developer-box") && ++ priv->phy_interface != PHY_INTERFACE_MODE_RGMII_ID) { ++ dev_warn(&pdev->dev, "Outdated firmware reports incorrect PHY mode, overriding\n"); ++ priv->phy_interface = PHY_INTERFACE_MODE_RGMII_ID; ++ } ++ + priv->phy_np = of_parse_phandle(pdev->dev.of_node, "phy-handle", 0); + if (!priv->phy_np) { + dev_err(&pdev->dev, "missing required property 'phy-handle'\n"); +-- +2.40.1 + diff --git a/queue-5.15/net-sched-cls_fw-no-longer-copy-tcf_result-on-update.patch b/queue-5.15/net-sched-cls_fw-no-longer-copy-tcf_result-on-update.patch new file mode 100644 index 00000000000..b2f0b3bc25f --- /dev/null +++ b/queue-5.15/net-sched-cls_fw-no-longer-copy-tcf_result-on-update.patch @@ -0,0 +1,50 @@ +From 708fc9906a9f632ac4e049dc46d70892502cd3a6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 29 Jul 2023 08:32:01 -0400 +Subject: net/sched: cls_fw: No longer copy tcf_result on update to avoid + use-after-free + +From: valis + +[ Upstream commit 76e42ae831991c828cffa8c37736ebfb831ad5ec ] + +When fw_change() is called on an existing filter, the whole +tcf_result struct is always copied into the new instance of the filter. + +This causes a problem when updating a filter bound to a class, +as tcf_unbind_filter() is always called on the old instance in the +success path, decreasing filter_cnt of the still referenced class +and allowing it to be deleted, leading to a use-after-free. + +Fix this by no longer copying the tcf_result struct from the old filter. + +Fixes: e35a8ee5993b ("net: sched: fw use RCU") +Reported-by: valis +Reported-by: Bing-Jhong Billy Jheng +Signed-off-by: valis +Signed-off-by: Jamal Hadi Salim +Reviewed-by: Victor Nogueira +Reviewed-by: Pedro Tammela +Reviewed-by: M A Ramdhan +Link: https://lore.kernel.org/r/20230729123202.72406-3-jhs@mojatatu.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/sched/cls_fw.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/net/sched/cls_fw.c b/net/sched/cls_fw.c +index ea52c320f67c4..a2f53aee39097 100644 +--- a/net/sched/cls_fw.c ++++ b/net/sched/cls_fw.c +@@ -265,7 +265,6 @@ static int fw_change(struct net *net, struct sk_buff *in_skb, + return -ENOBUFS; + + fnew->id = f->id; +- fnew->res = f->res; + fnew->ifindex = f->ifindex; + fnew->tp = f->tp; + +-- +2.40.1 + diff --git a/queue-5.15/net-sched-cls_route-no-longer-copy-tcf_result-on-upd.patch b/queue-5.15/net-sched-cls_route-no-longer-copy-tcf_result-on-upd.patch new file mode 100644 index 00000000000..17c100dfb85 --- /dev/null +++ b/queue-5.15/net-sched-cls_route-no-longer-copy-tcf_result-on-upd.patch @@ -0,0 +1,50 @@ +From 2339a7b744b35f097afe9ca576a24f716a2d7305 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 29 Jul 2023 08:32:02 -0400 +Subject: net/sched: cls_route: No longer copy tcf_result on update to avoid + use-after-free + +From: valis + +[ Upstream commit b80b829e9e2c1b3f7aae34855e04d8f6ecaf13c8 ] + +When route4_change() is called on an existing filter, the whole +tcf_result struct is always copied into the new instance of the filter. + +This causes a problem when updating a filter bound to a class, +as tcf_unbind_filter() is always called on the old instance in the +success path, decreasing filter_cnt of the still referenced class +and allowing it to be deleted, leading to a use-after-free. + +Fix this by no longer copying the tcf_result struct from the old filter. + +Fixes: 1109c00547fc ("net: sched: RCU cls_route") +Reported-by: valis +Reported-by: Bing-Jhong Billy Jheng +Signed-off-by: valis +Signed-off-by: Jamal Hadi Salim +Reviewed-by: Victor Nogueira +Reviewed-by: Pedro Tammela +Reviewed-by: M A Ramdhan +Link: https://lore.kernel.org/r/20230729123202.72406-4-jhs@mojatatu.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/sched/cls_route.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c +index 48712bc51bda7..194468d0355a1 100644 +--- a/net/sched/cls_route.c ++++ b/net/sched/cls_route.c +@@ -511,7 +511,6 @@ static int route4_change(struct net *net, struct sk_buff *in_skb, + if (fold) { + f->id = fold->id; + f->iif = fold->iif; +- f->res = fold->res; + f->handle = fold->handle; + + f->tp = fold->tp; +-- +2.40.1 + diff --git a/queue-5.15/net-sched-cls_u32-fix-match-key-mis-addressing.patch b/queue-5.15/net-sched-cls_u32-fix-match-key-mis-addressing.patch new file mode 100644 index 00000000000..1ef429cabb9 --- /dev/null +++ b/queue-5.15/net-sched-cls_u32-fix-match-key-mis-addressing.patch @@ -0,0 +1,145 @@ +From d0eb5b77cca2d8a685c1522f2f1a81d342dac815 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 26 Jul 2023 09:51:51 -0400 +Subject: net: sched: cls_u32: Fix match key mis-addressing + +From: Jamal Hadi Salim + +[ Upstream commit e68409db995380d1badacba41ff24996bd396171 ] + +A match entry is uniquely identified with an "address" or "path" in the +form of: hashtable ID(12b):bucketid(8b):nodeid(12b). + +When creating table match entries all of hash table id, bucket id and +node (match entry id) are needed to be either specified by the user or +reasonable in-kernel defaults are used. The in-kernel default for a table id is +0x800(omnipresent root table); for bucketid it is 0x0. Prior to this fix there +was none for a nodeid i.e. the code assumed that the user passed the correct +nodeid and if the user passes a nodeid of 0 (as Mingi Cho did) then that is what +was used. But nodeid of 0 is reserved for identifying the table. This is not +a problem until we dump. The dump code notices that the nodeid is zero and +assumes it is referencing a table and therefore references table struct +tc_u_hnode instead of what was created i.e match entry struct tc_u_knode. + +Ming does an equivalent of: +tc filter add dev dummy0 parent 10: prio 1 handle 0x1000 \ +protocol ip u32 match ip src 10.0.0.1/32 classid 10:1 action ok + +Essentially specifying a table id 0, bucketid 1 and nodeid of zero +Tableid 0 is remapped to the default of 0x800. +Bucketid 1 is ignored and defaults to 0x00. +Nodeid was assumed to be what Ming passed - 0x000 + +dumping before fix shows: +~$ tc filter ls dev dummy0 parent 10: +filter protocol ip pref 1 u32 chain 0 +filter protocol ip pref 1 u32 chain 0 fh 800: ht divisor 1 +filter protocol ip pref 1 u32 chain 0 fh 800: ht divisor -30591 + +Note that the last line reports a table instead of a match entry +(you can tell this because it says "ht divisor..."). +As a result of reporting the wrong data type (misinterpretting of struct +tc_u_knode as being struct tc_u_hnode) the divisor is reported with value +of -30591. Ming identified this as part of the heap address +(physmap_base is 0xffff8880 (-30591 - 1)). + +The fix is to ensure that when table entry matches are added and no +nodeid is specified (i.e nodeid == 0) then we get the next available +nodeid from the table's pool. + +After the fix, this is what the dump shows: +$ tc filter ls dev dummy0 parent 10: +filter protocol ip pref 1 u32 chain 0 +filter protocol ip pref 1 u32 chain 0 fh 800: ht divisor 1 +filter protocol ip pref 1 u32 chain 0 fh 800::800 order 2048 key ht 800 bkt 0 flowid 10:1 not_in_hw + match 0a000001/ffffffff at 12 + action order 1: gact action pass + random type none pass val 0 + index 1 ref 1 bind 1 + +Reported-by: Mingi Cho +Fixes: 1da177e4c3f4 ("Linux-2.6.12-rc2") +Signed-off-by: Jamal Hadi Salim +Link: https://lore.kernel.org/r/20230726135151.416917-1-jhs@mojatatu.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/sched/cls_u32.c | 56 ++++++++++++++++++++++++++++++++++++++++----- + 1 file changed, 50 insertions(+), 6 deletions(-) + +diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c +index 0025fa837e857..e4e38aa75111e 100644 +--- a/net/sched/cls_u32.c ++++ b/net/sched/cls_u32.c +@@ -999,18 +999,62 @@ static int u32_change(struct net *net, struct sk_buff *in_skb, + return -EINVAL; + } + ++ /* At this point, we need to derive the new handle that will be used to ++ * uniquely map the identity of this table match entry. The ++ * identity of the entry that we need to construct is 32 bits made of: ++ * htid(12b):bucketid(8b):node/entryid(12b) ++ * ++ * At this point _we have the table(ht)_ in which we will insert this ++ * entry. We carry the table's id in variable "htid". ++ * Note that earlier code picked the ht selection either by a) the user ++ * providing the htid specified via TCA_U32_HASH attribute or b) when ++ * no such attribute is passed then the root ht, is default to at ID ++ * 0x[800][00][000]. Rule: the root table has a single bucket with ID 0. ++ * If OTOH the user passed us the htid, they may also pass a bucketid of ++ * choice. 0 is fine. For example a user htid is 0x[600][01][000] it is ++ * indicating hash bucketid of 1. Rule: the entry/node ID _cannot_ be ++ * passed via the htid, so even if it was non-zero it will be ignored. ++ * ++ * We may also have a handle, if the user passed one. The handle also ++ * carries the same addressing of htid(12b):bucketid(8b):node/entryid(12b). ++ * Rule: the bucketid on the handle is ignored even if one was passed; ++ * rather the value on "htid" is always assumed to be the bucketid. ++ */ + if (handle) { ++ /* Rule: The htid from handle and tableid from htid must match */ + if (TC_U32_HTID(handle) && TC_U32_HTID(handle ^ htid)) { + NL_SET_ERR_MSG_MOD(extack, "Handle specified hash table address mismatch"); + return -EINVAL; + } +- handle = htid | TC_U32_NODE(handle); +- err = idr_alloc_u32(&ht->handle_idr, NULL, &handle, handle, +- GFP_KERNEL); +- if (err) +- return err; +- } else ++ /* Ok, so far we have a valid htid(12b):bucketid(8b) but we ++ * need to finalize the table entry identification with the last ++ * part - the node/entryid(12b)). Rule: Nodeid _cannot be 0_ for ++ * entries. Rule: nodeid of 0 is reserved only for tables(see ++ * earlier code which processes TC_U32_DIVISOR attribute). ++ * Rule: The nodeid can only be derived from the handle (and not ++ * htid). ++ * Rule: if the handle specified zero for the node id example ++ * 0x60000000, then pick a new nodeid from the pool of IDs ++ * this hash table has been allocating from. ++ * If OTOH it is specified (i.e for example the user passed a ++ * handle such as 0x60000123), then we use it generate our final ++ * handle which is used to uniquely identify the match entry. ++ */ ++ if (!TC_U32_NODE(handle)) { ++ handle = gen_new_kid(ht, htid); ++ } else { ++ handle = htid | TC_U32_NODE(handle); ++ err = idr_alloc_u32(&ht->handle_idr, NULL, &handle, ++ handle, GFP_KERNEL); ++ if (err) ++ return err; ++ } ++ } else { ++ /* The user did not give us a handle; lets just generate one ++ * from the table's pool of nodeids. ++ */ + handle = gen_new_kid(ht, htid); ++ } + + if (tb[TCA_U32_SEL] == NULL) { + NL_SET_ERR_MSG_MOD(extack, "Selector not specified"); +-- +2.40.1 + diff --git a/queue-5.15/net-sched-cls_u32-no-longer-copy-tcf_result-on-updat.patch b/queue-5.15/net-sched-cls_u32-no-longer-copy-tcf_result-on-updat.patch new file mode 100644 index 00000000000..2830ca74534 --- /dev/null +++ b/queue-5.15/net-sched-cls_u32-no-longer-copy-tcf_result-on-updat.patch @@ -0,0 +1,50 @@ +From 253a165382d8f7e75810896757d3badd85e33d62 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 29 Jul 2023 08:32:00 -0400 +Subject: net/sched: cls_u32: No longer copy tcf_result on update to avoid + use-after-free + +From: valis + +[ Upstream commit 3044b16e7c6fe5d24b1cdbcf1bd0a9d92d1ebd81 ] + +When u32_change() is called on an existing filter, the whole +tcf_result struct is always copied into the new instance of the filter. + +This causes a problem when updating a filter bound to a class, +as tcf_unbind_filter() is always called on the old instance in the +success path, decreasing filter_cnt of the still referenced class +and allowing it to be deleted, leading to a use-after-free. + +Fix this by no longer copying the tcf_result struct from the old filter. + +Fixes: de5df63228fc ("net: sched: cls_u32 changes to knode must appear atomic to readers") +Reported-by: valis +Reported-by: M A Ramdhan +Signed-off-by: valis +Signed-off-by: Jamal Hadi Salim +Reviewed-by: Victor Nogueira +Reviewed-by: Pedro Tammela +Reviewed-by: M A Ramdhan +Link: https://lore.kernel.org/r/20230729123202.72406-2-jhs@mojatatu.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/sched/cls_u32.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c +index e4e38aa75111e..17edcf1d1c3b6 100644 +--- a/net/sched/cls_u32.c ++++ b/net/sched/cls_u32.c +@@ -812,7 +812,6 @@ static struct tc_u_knode *u32_init_knode(struct net *net, struct tcf_proto *tp, + + new->ifindex = n->ifindex; + new->fshift = n->fshift; +- new->res = n->res; + new->flags = n->flags; + RCU_INIT_POINTER(new->ht_down, ht); + +-- +2.40.1 + diff --git a/queue-5.15/net-sched-taprio-limit-tca_taprio_attr_sched_cycle_t.patch b/queue-5.15/net-sched-taprio-limit-tca_taprio_attr_sched_cycle_t.patch new file mode 100644 index 00000000000..2e8ede7d9f7 --- /dev/null +++ b/queue-5.15/net-sched-taprio-limit-tca_taprio_attr_sched_cycle_t.patch @@ -0,0 +1,140 @@ +From ee021d317b36c6b5d418a446791bd104e26f8df3 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 17:07:05 -0700 +Subject: net/sched: taprio: Limit TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME to INT_MAX. + +From: Kuniyuki Iwashima + +[ Upstream commit e739718444f7bf2fa3d70d101761ad83056ca628 ] + +syzkaller found zero division error [0] in div_s64_rem() called from +get_cycle_time_elapsed(), where sched->cycle_time is the divisor. + +We have tests in parse_taprio_schedule() so that cycle_time will never +be 0, and actually cycle_time is not 0 in get_cycle_time_elapsed(). + +The problem is that the types of divisor are different; cycle_time is +s64, but the argument of div_s64_rem() is s32. + +syzkaller fed this input and 0x100000000 is cast to s32 to be 0. + + @TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME={0xc, 0x8, 0x100000000} + +We use s64 for cycle_time to cast it to ktime_t, so let's keep it and +set max for cycle_time. + +While at it, we prevent overflow in setup_txtime() and add another +test in parse_taprio_schedule() to check if cycle_time overflows. + +Also, we add a new tdc test case for this issue. + +[0]: +divide error: 0000 [#1] PREEMPT SMP KASAN NOPTI +CPU: 1 PID: 103 Comm: kworker/1:3 Not tainted 6.5.0-rc1-00330-g60cc1f7d0605 #3 +Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.16.0-0-gd239552ce722-prebuilt.qemu.org 04/01/2014 +Workqueue: ipv6_addrconf addrconf_dad_work +RIP: 0010:div_s64_rem include/linux/math64.h:42 [inline] +RIP: 0010:get_cycle_time_elapsed net/sched/sch_taprio.c:223 [inline] +RIP: 0010:find_entry_to_transmit+0x252/0x7e0 net/sched/sch_taprio.c:344 +Code: 3c 02 00 0f 85 5e 05 00 00 48 8b 4c 24 08 4d 8b bd 40 01 00 00 48 8b 7c 24 48 48 89 c8 4c 29 f8 48 63 f7 48 99 48 89 74 24 70 <48> f7 fe 48 29 d1 48 8d 04 0f 49 89 cc 48 89 44 24 20 49 8d 85 10 +RSP: 0018:ffffc90000acf260 EFLAGS: 00010206 +RAX: 177450e0347560cf RBX: 0000000000000000 RCX: 177450e0347560cf +RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000100000000 +RBP: 0000000000000056 R08: 0000000000000000 R09: ffffed10020a0934 +R10: ffff8880105049a7 R11: ffff88806cf3a520 R12: ffff888010504800 +R13: ffff88800c00d800 R14: ffff8880105049a0 R15: 0000000000000000 +FS: 0000000000000000(0000) GS:ffff88806cf00000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: 00007f0edf84f0e8 CR3: 000000000d73c002 CR4: 0000000000770ee0 +PKRU: 55555554 +Call Trace: + + get_packet_txtime net/sched/sch_taprio.c:508 [inline] + taprio_enqueue_one+0x900/0xff0 net/sched/sch_taprio.c:577 + taprio_enqueue+0x378/0xae0 net/sched/sch_taprio.c:658 + dev_qdisc_enqueue+0x46/0x170 net/core/dev.c:3732 + __dev_xmit_skb net/core/dev.c:3821 [inline] + __dev_queue_xmit+0x1b2f/0x3000 net/core/dev.c:4169 + dev_queue_xmit include/linux/netdevice.h:3088 [inline] + neigh_resolve_output net/core/neighbour.c:1552 [inline] + neigh_resolve_output+0x4a7/0x780 net/core/neighbour.c:1532 + neigh_output include/net/neighbour.h:544 [inline] + ip6_finish_output2+0x924/0x17d0 net/ipv6/ip6_output.c:135 + __ip6_finish_output+0x620/0xaa0 net/ipv6/ip6_output.c:196 + ip6_finish_output net/ipv6/ip6_output.c:207 [inline] + NF_HOOK_COND include/linux/netfilter.h:292 [inline] + ip6_output+0x206/0x410 net/ipv6/ip6_output.c:228 + dst_output include/net/dst.h:458 [inline] + NF_HOOK.constprop.0+0xea/0x260 include/linux/netfilter.h:303 + ndisc_send_skb+0x872/0xe80 net/ipv6/ndisc.c:508 + ndisc_send_ns+0xb5/0x130 net/ipv6/ndisc.c:666 + addrconf_dad_work+0xc14/0x13f0 net/ipv6/addrconf.c:4175 + process_one_work+0x92c/0x13a0 kernel/workqueue.c:2597 + worker_thread+0x60f/0x1240 kernel/workqueue.c:2748 + kthread+0x2fe/0x3f0 kernel/kthread.c:389 + ret_from_fork+0x2c/0x50 arch/x86/entry/entry_64.S:308 + +Modules linked in: + +Fixes: 4cfd5779bd6e ("taprio: Add support for txtime-assist mode") +Reported-by: syzkaller +Signed-off-by: Kuniyuki Iwashima +Co-developed-by: Eric Dumazet +Co-developed-by: Pedro Tammela +Acked-by: Vinicius Costa Gomes +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/sched/sch_taprio.c | 15 +++++++++++++-- + 1 file changed, 13 insertions(+), 2 deletions(-) + +diff --git a/net/sched/sch_taprio.c b/net/sched/sch_taprio.c +index e203deacc9533..e40b4425eb6b5 100644 +--- a/net/sched/sch_taprio.c ++++ b/net/sched/sch_taprio.c +@@ -780,6 +780,11 @@ static const struct nla_policy entry_policy[TCA_TAPRIO_SCHED_ENTRY_MAX + 1] = { + [TCA_TAPRIO_SCHED_ENTRY_INTERVAL] = { .type = NLA_U32 }, + }; + ++static struct netlink_range_validation_signed taprio_cycle_time_range = { ++ .min = 0, ++ .max = INT_MAX, ++}; ++ + static const struct nla_policy taprio_policy[TCA_TAPRIO_ATTR_MAX + 1] = { + [TCA_TAPRIO_ATTR_PRIOMAP] = { + .len = sizeof(struct tc_mqprio_qopt) +@@ -788,7 +793,8 @@ static const struct nla_policy taprio_policy[TCA_TAPRIO_ATTR_MAX + 1] = { + [TCA_TAPRIO_ATTR_SCHED_BASE_TIME] = { .type = NLA_S64 }, + [TCA_TAPRIO_ATTR_SCHED_SINGLE_ENTRY] = { .type = NLA_NESTED }, + [TCA_TAPRIO_ATTR_SCHED_CLOCKID] = { .type = NLA_S32 }, +- [TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME] = { .type = NLA_S64 }, ++ [TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME] = ++ NLA_POLICY_FULL_RANGE_SIGNED(NLA_S64, &taprio_cycle_time_range), + [TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME_EXTENSION] = { .type = NLA_S64 }, + [TCA_TAPRIO_ATTR_FLAGS] = { .type = NLA_U32 }, + [TCA_TAPRIO_ATTR_TXTIME_DELAY] = { .type = NLA_U32 }, +@@ -923,6 +929,11 @@ static int parse_taprio_schedule(struct taprio_sched *q, struct nlattr **tb, + return -EINVAL; + } + ++ if (cycle < 0 || cycle > INT_MAX) { ++ NL_SET_ERR_MSG(extack, "'cycle_time' is too big"); ++ return -EINVAL; ++ } ++ + new->cycle_time = cycle; + } + +@@ -1127,7 +1138,7 @@ static void setup_txtime(struct taprio_sched *q, + struct sched_gate_list *sched, ktime_t base) + { + struct sched_entry *entry; +- u32 interval = 0; ++ u64 interval = 0; + + list_for_each_entry(entry, &sched->entries, list) { + entry->next_txtime = ktime_add_ns(base, interval); +-- +2.40.1 + diff --git a/queue-5.15/perf-test-uprobe_from_different_cu-skip-if-there-is-.patch b/queue-5.15/perf-test-uprobe_from_different_cu-skip-if-there-is-.patch new file mode 100644 index 00000000000..2f8ad5a5c0a --- /dev/null +++ b/queue-5.15/perf-test-uprobe_from_different_cu-skip-if-there-is-.patch @@ -0,0 +1,66 @@ +From 8543b04275fd8a38f8c9b5d295c7f91a8c27d59c Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 28 Jul 2023 17:18:12 +0200 +Subject: perf test uprobe_from_different_cu: Skip if there is no gcc +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Georg Müller + +[ Upstream commit 98ce8e4a9dcfb448b30a2d7a16190f4a00382377 ] + +Without gcc, the test will fail. + +On cleanup, ignore probe removal errors. Otherwise, in case of an error +adding the probe, the temporary directory is not removed. + +Fixes: 56cbeacf14353057 ("perf probe: Add test for regression introduced by switch to die_get_decl_file()") +Signed-off-by: Georg Müller +Acked-by: Ian Rogers +Cc: Adrian Hunter +Cc: Alexander Shishkin +Cc: Georg Müller +Cc: Ingo Molnar +Cc: Jiri Olsa +Cc: Mark Rutland +Cc: Masami Hiramatsu +Cc: Namhyung Kim +Cc: Peter Zijlstra +Link: https://lore.kernel.org/r/20230728151812.454806-2-georgmueller@gmx.net +Link: https://lore.kernel.org/r/CAP-5=fUP6UuLgRty3t2=fQsQi3k4hDMz415vWdp1x88QMvZ8ug@mail.gmail.com/ +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/tests/shell/test_uprobe_from_different_cu.sh | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/tools/perf/tests/shell/test_uprobe_from_different_cu.sh b/tools/perf/tests/shell/test_uprobe_from_different_cu.sh +index 00d2e0e2e0c28..319f36ebb9a40 100644 +--- a/tools/perf/tests/shell/test_uprobe_from_different_cu.sh ++++ b/tools/perf/tests/shell/test_uprobe_from_different_cu.sh +@@ -4,6 +4,12 @@ + + set -e + ++# skip if there's no gcc ++if ! [ -x "$(command -v gcc)" ]; then ++ echo "failed: no gcc compiler" ++ exit 2 ++fi ++ + temp_dir=$(mktemp -d /tmp/perf-uprobe-different-cu-sh.XXXXXXXXXX) + + cleanup() +@@ -11,7 +17,7 @@ cleanup() + trap - EXIT TERM INT + if [[ "${temp_dir}" =~ ^/tmp/perf-uprobe-different-cu-sh.*$ ]]; then + echo "--- Cleaning up ---" +- perf probe -x ${temp_dir}/testfile -d foo ++ perf probe -x ${temp_dir}/testfile -d foo || true + rm -f "${temp_dir}/"* + rmdir "${temp_dir}" + fi +-- +2.40.1 + diff --git a/queue-5.15/prestera-fix-fallback-to-previous-version-on-same-ma.patch b/queue-5.15/prestera-fix-fallback-to-previous-version-on-same-ma.patch new file mode 100644 index 00000000000..43cf1ae2a39 --- /dev/null +++ b/queue-5.15/prestera-fix-fallback-to-previous-version-on-same-ma.patch @@ -0,0 +1,66 @@ +From 6e8e63b2a0edf0de41008d65e02e7e317fba11ad Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 11:23:56 +0200 +Subject: prestera: fix fallback to previous version on same major version + +From: Jonas Gorski + +[ Upstream commit b755c25fbcd568821a3bb0e0d5c2daa5fcb00bba ] + +When both supported and previous version have the same major version, +and the firmwares are missing, the driver ends in a loop requesting the +same (previous) version over and over again: + + [ 76.327413] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.1.img firmware, fall-back to previous 4.0 version + [ 76.339802] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.352162] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.364502] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.376848] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.389183] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.401522] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.413860] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + [ 76.426199] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.0.img firmware, fall-back to previous 4.0 version + ... + +Fix this by inverting the check to that we aren't yet at the previous +version, and also check the minor version. + +This also catches the case where both versions are the same, as it was +after commit bb5dbf2cc64d ("net: marvell: prestera: add firmware v4.0 +support"). + +With this fix applied: + + [ 88.499622] Prestera DX 0000:01:00.0: missing latest mrvl/prestera/mvsw_prestera_fw-v4.1.img firmware, fall-back to previous 4.0 version + [ 88.511995] Prestera DX 0000:01:00.0: failed to request previous firmware: mrvl/prestera/mvsw_prestera_fw-v4.0.img + [ 88.522403] Prestera DX: probe of 0000:01:00.0 failed with error -2 + +Fixes: 47f26018a414 ("net: marvell: prestera: try to load previous fw version") +Signed-off-by: Jonas Gorski +Acked-by: Elad Nachman +Reviewed-by: Jesse Brandeburg +Acked-by: Taras Chornyi +Link: https://lore.kernel.org/r/20230802092357.163944-1-jonas.gorski@bisdn.de +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/marvell/prestera/prestera_pci.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/marvell/prestera/prestera_pci.c b/drivers/net/ethernet/marvell/prestera/prestera_pci.c +index a8d7b889ebeee..6bef633aa6330 100644 +--- a/drivers/net/ethernet/marvell/prestera/prestera_pci.c ++++ b/drivers/net/ethernet/marvell/prestera/prestera_pci.c +@@ -645,7 +645,8 @@ static int prestera_fw_get(struct prestera_fw *fw) + + err = request_firmware_direct(&fw->bin, fw_path, fw->dev.dev); + if (err) { +- if (ver_maj == PRESTERA_SUPP_FW_MAJ_VER) { ++ if (ver_maj != PRESTERA_PREV_FW_MAJ_VER || ++ ver_min != PRESTERA_PREV_FW_MIN_VER) { + ver_maj = PRESTERA_PREV_FW_MAJ_VER; + ver_min = PRESTERA_PREV_FW_MIN_VER; + +-- +2.40.1 + diff --git a/queue-5.15/qed-fix-kernel-doc-warnings.patch b/queue-5.15/qed-fix-kernel-doc-warnings.patch new file mode 100644 index 00000000000..578109e92d3 --- /dev/null +++ b/queue-5.15/qed-fix-kernel-doc-warnings.patch @@ -0,0 +1,6901 @@ +From 42473d48cc5abeb768a79f13d6b3f20e026e21a4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 4 Oct 2021 09:58:39 +0300 +Subject: qed: Fix kernel-doc warnings + +From: Prabhakar Kushwaha + +[ Upstream commit 19198e4ec97dc9d173b458a75ace3c3ca55c2d85 ] + +This patch fixes all the qed and qede kernel-doc warnings +according to the guidelines that are described in +Documentation/doc-guide/kernel-doc.rst. + +Signed-off-by: Ariel Elior +Signed-off-by: Omkar Kulkarni +Signed-off-by: Shai Malin +Signed-off-by: Prabhakar Kushwaha +Signed-off-by: David S. Miller +Stable-dep-of: e346e231b42b ("qed: Fix scheduling in a tasklet while getting stats") +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/qlogic/qed/qed.h | 9 +- + drivers/net/ethernet/qlogic/qed/qed_cxt.h | 138 +-- + drivers/net/ethernet/qlogic/qed/qed_dev_api.h | 343 ++++--- + drivers/net/ethernet/qlogic/qed/qed_hsi.h | 956 +++++++++--------- + drivers/net/ethernet/qlogic/qed/qed_hw.h | 222 ++-- + .../net/ethernet/qlogic/qed/qed_init_ops.h | 58 +- + drivers/net/ethernet/qlogic/qed/qed_int.h | 284 +++--- + drivers/net/ethernet/qlogic/qed/qed_iscsi.h | 9 +- + drivers/net/ethernet/qlogic/qed/qed_l2.h | 134 +-- + drivers/net/ethernet/qlogic/qed/qed_ll2.h | 130 +-- + drivers/net/ethernet/qlogic/qed/qed_mcp.h | 757 +++++++------- + .../net/ethernet/qlogic/qed/qed_selftest.h | 30 +- + drivers/net/ethernet/qlogic/qed/qed_sp.h | 215 ++-- + drivers/net/ethernet/qlogic/qed/qed_sriov.h | 99 +- + drivers/net/ethernet/qlogic/qed/qed_vf.h | 301 +++--- + drivers/net/ethernet/qlogic/qede/qede_main.c | 5 +- + include/linux/qed/qed_chain.h | 97 +- + include/linux/qed/qed_if.h | 255 ++--- + include/linux/qed/qed_iscsi_if.h | 2 +- + include/linux/qed/qed_ll2_if.h | 42 +- + include/linux/qed/qed_nvmetcp_if.h | 17 + + 21 files changed, 2186 insertions(+), 1917 deletions(-) + +diff --git a/drivers/net/ethernet/qlogic/qed/qed.h b/drivers/net/ethernet/qlogic/qed/qed.h +index d58e021614cd0..b656408b9d700 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed.h ++++ b/drivers/net/ethernet/qlogic/qed/qed.h +@@ -877,12 +877,13 @@ u32 qed_get_hsi_def_val(struct qed_dev *cdev, enum qed_hsi_def_type type); + + + /** +- * @brief qed_concrete_to_sw_fid - get the sw function id from +- * the concrete value. ++ * qed_concrete_to_sw_fid(): Get the sw function id from ++ * the concrete value. + * +- * @param concrete_fid ++ * @cdev: Qed dev pointer. ++ * @concrete_fid: Concrete fid. + * +- * @return inline u8 ++ * Return: inline u8. + */ + static inline u8 qed_concrete_to_sw_fid(struct qed_dev *cdev, + u32 concrete_fid) +diff --git a/drivers/net/ethernet/qlogic/qed/qed_cxt.h b/drivers/net/ethernet/qlogic/qed/qed_cxt.h +index 8adb7ed0c12db..d31196db7bdde 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_cxt.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_cxt.h +@@ -28,24 +28,23 @@ struct qed_tid_mem { + }; + + /** +- * @brief qedo_cid_get_cxt_info - Returns the context info for a specific cid ++ * qed_cxt_get_cid_info(): Returns the context info for a specific cidi. + * ++ * @p_hwfn: HW device data. ++ * @p_info: In/out. + * +- * @param p_hwfn +- * @param p_info in/out +- * +- * @return int ++ * Return: Int. + */ + int qed_cxt_get_cid_info(struct qed_hwfn *p_hwfn, + struct qed_cxt_info *p_info); + + /** +- * @brief qed_cxt_get_tid_mem_info ++ * qed_cxt_get_tid_mem_info(): Returns the tid mem info. + * +- * @param p_hwfn +- * @param p_info ++ * @p_hwfn: HW device data. ++ * @p_info: in/out. + * +- * @return int ++ * Return: int. + */ + int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, + struct qed_tid_mem *p_info); +@@ -64,142 +63,155 @@ u32 qed_cxt_get_proto_cid_count(struct qed_hwfn *p_hwfn, + enum protocol_type type, u32 *vf_cid); + + /** +- * @brief qed_cxt_set_pf_params - Set the PF params for cxt init ++ * qed_cxt_set_pf_params(): Set the PF params for cxt init. ++ * ++ * @p_hwfn: HW device data. ++ * @rdma_tasks: Requested maximum. + * +- * @param p_hwfn +- * @param rdma_tasks - requested maximum +- * @return int ++ * Return: int. + */ + int qed_cxt_set_pf_params(struct qed_hwfn *p_hwfn, u32 rdma_tasks); + + /** +- * @brief qed_cxt_cfg_ilt_compute - compute ILT init parameters ++ * qed_cxt_cfg_ilt_compute(): Compute ILT init parameters. + * +- * @param p_hwfn +- * @param last_line ++ * @p_hwfn: HW device data. ++ * @last_line: Last_line. + * +- * @return int ++ * Return: Int + */ + int qed_cxt_cfg_ilt_compute(struct qed_hwfn *p_hwfn, u32 *last_line); + + /** +- * @brief qed_cxt_cfg_ilt_compute_excess - how many lines can be decreased ++ * qed_cxt_cfg_ilt_compute_excess(): How many lines can be decreased. ++ * ++ * @p_hwfn: HW device data. ++ * @used_lines: Used lines. + * +- * @param p_hwfn +- * @param used_lines ++ * Return: Int. + */ + u32 qed_cxt_cfg_ilt_compute_excess(struct qed_hwfn *p_hwfn, u32 used_lines); + + /** +- * @brief qed_cxt_mngr_alloc - Allocate and init the context manager struct ++ * qed_cxt_mngr_alloc(): Allocate and init the context manager struct. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_cxt_mngr_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_cxt_mngr_free ++ * qed_cxt_mngr_free() - Context manager free. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_cxt_mngr_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_cxt_tables_alloc - Allocate ILT shadow, Searcher T2, acquired map ++ * qed_cxt_tables_alloc(): Allocate ILT shadow, Searcher T2, acquired map. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_cxt_tables_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_cxt_mngr_setup - Reset the acquired CIDs ++ * qed_cxt_mngr_setup(): Reset the acquired CIDs. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + */ + void qed_cxt_mngr_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_cxt_hw_init_common - Initailze ILT and DQ, common phase, per path. +- * ++ * qed_cxt_hw_init_common(): Initailze ILT and DQ, common phase, per path. + * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_cxt_hw_init_common(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_cxt_hw_init_pf - Initailze ILT and DQ, PF phase, per path. ++ * qed_cxt_hw_init_pf(): Initailze ILT and DQ, PF phase, per path. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Void. + */ + void qed_cxt_hw_init_pf(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief qed_qm_init_pf - Initailze the QM PF phase, per path ++ * qed_qm_init_pf(): Initailze the QM PF phase, per path. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @is_pf_loading: Is pf pending. + * +- * @param p_hwfn +- * @param p_ptt +- * @param is_pf_loading ++ * Return: Void. + */ + void qed_qm_init_pf(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, bool is_pf_loading); + + /** +- * @brief Reconfigures QM pf on the fly ++ * qed_qm_reconf(): Reconfigures QM pf on the fly. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int ++ * Return: Int. + */ + int qed_qm_reconf(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + #define QED_CXT_PF_CID (0xff) + + /** +- * @brief qed_cxt_release - Release a cid ++ * qed_cxt_release_cid(): Release a cid. + * +- * @param p_hwfn +- * @param cid ++ * @p_hwfn: HW device data. ++ * @cid: Cid. ++ * ++ * Return: Void. + */ + void qed_cxt_release_cid(struct qed_hwfn *p_hwfn, u32 cid); + + /** +- * @brief qed_cxt_release - Release a cid belonging to a vf-queue ++ * _qed_cxt_release_cid(): Release a cid belonging to a vf-queue. ++ * ++ * @p_hwfn: HW device data. ++ * @cid: Cid. ++ * @vfid: Engine relative index. QED_CXT_PF_CID if belongs to PF. + * +- * @param p_hwfn +- * @param cid +- * @param vfid - engine relative index. QED_CXT_PF_CID if belongs to PF ++ * Return: Void. + */ + void _qed_cxt_release_cid(struct qed_hwfn *p_hwfn, u32 cid, u8 vfid); + + /** +- * @brief qed_cxt_acquire - Acquire a new cid of a specific protocol type ++ * qed_cxt_acquire_cid(): Acquire a new cid of a specific protocol type. + * +- * @param p_hwfn +- * @param type +- * @param p_cid ++ * @p_hwfn: HW device data. ++ * @type: Type. ++ * @p_cid: Pointer cid. + * +- * @return int ++ * Return: Int. + */ + int qed_cxt_acquire_cid(struct qed_hwfn *p_hwfn, + enum protocol_type type, u32 *p_cid); + + /** +- * @brief _qed_cxt_acquire - Acquire a new cid of a specific protocol type +- * for a vf-queue ++ * _qed_cxt_acquire_cid(): Acquire a new cid of a specific protocol type ++ * for a vf-queue. + * +- * @param p_hwfn +- * @param type +- * @param p_cid +- * @param vfid - engine relative index. QED_CXT_PF_CID if belongs to PF ++ * @p_hwfn: HW device data. ++ * @type: Type. ++ * @p_cid: Pointer cid. ++ * @vfid: Engine relative index. QED_CXT_PF_CID if belongs to PF. + * +- * @return int ++ * Return: Int. + */ + int _qed_cxt_acquire_cid(struct qed_hwfn *p_hwfn, + enum protocol_type type, u32 *p_cid, u8 vfid); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev_api.h b/drivers/net/ethernet/qlogic/qed/qed_dev_api.h +index d3c1f3879be87..f0a825b985a4b 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_dev_api.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_dev_api.h +@@ -15,44 +15,52 @@ + #include "qed_int.h" + + /** +- * @brief qed_init_dp - initialize the debug level ++ * qed_init_dp(): Initialize the debug level. + * +- * @param cdev +- * @param dp_module +- * @param dp_level ++ * @cdev: Qed dev pointer. ++ * @dp_module: Module debug parameter. ++ * @dp_level: Module debug level. ++ * ++ * Return: Void. + */ + void qed_init_dp(struct qed_dev *cdev, + u32 dp_module, + u8 dp_level); + + /** +- * @brief qed_init_struct - initialize the device structure to +- * its defaults ++ * qed_init_struct(): Initialize the device structure to ++ * its defaults. ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Void. + */ + void qed_init_struct(struct qed_dev *cdev); + + /** +- * @brief qed_resc_free - ++ * qed_resc_free: Free device resources. ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Void. + */ + void qed_resc_free(struct qed_dev *cdev); + + /** +- * @brief qed_resc_alloc - ++ * qed_resc_alloc(): Alloc device resources. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_resc_alloc(struct qed_dev *cdev); + + /** +- * @brief qed_resc_setup - ++ * qed_resc_setup(): Setup device resources. + * +- * @param cdev ++ * @cdev: Qed dev pointer. ++ * ++ * Return: Void. + */ + void qed_resc_setup(struct qed_dev *cdev); + +@@ -105,94 +113,97 @@ struct qed_hw_init_params { + }; + + /** +- * @brief qed_hw_init - ++ * qed_hw_init(): Init Qed hardware. + * +- * @param cdev +- * @param p_params ++ * @cdev: Qed dev pointer. ++ * @p_params: Pointers to params. + * +- * @return int ++ * Return: Int. + */ + int qed_hw_init(struct qed_dev *cdev, struct qed_hw_init_params *p_params); + + /** +- * @brief qed_hw_timers_stop_all - stop the timers HW block ++ * qed_hw_timers_stop_all(): Stop the timers HW block. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return void ++ * Return: void. + */ + void qed_hw_timers_stop_all(struct qed_dev *cdev); + + /** +- * @brief qed_hw_stop - ++ * qed_hw_stop(): Stop Qed hardware. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: int. + */ + int qed_hw_stop(struct qed_dev *cdev); + + /** +- * @brief qed_hw_stop_fastpath -should be called incase +- * slowpath is still required for the device, +- * but fastpath is not. ++ * qed_hw_stop_fastpath(): Should be called incase ++ * slowpath is still required for the device, ++ * but fastpath is not. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_hw_stop_fastpath(struct qed_dev *cdev); + + /** +- * @brief qed_hw_start_fastpath -restart fastpath traffic, +- * only if hw_stop_fastpath was called ++ * qed_hw_start_fastpath(): Restart fastpath traffic, ++ * only if hw_stop_fastpath was called. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_hw_start_fastpath(struct qed_hwfn *p_hwfn); + + + /** +- * @brief qed_hw_prepare - ++ * qed_hw_prepare(): Prepare Qed hardware. + * +- * @param cdev +- * @param personality - personality to initialize ++ * @cdev: Qed dev pointer. ++ * @personality: Personality to initialize. + * +- * @return int ++ * Return: Int. + */ + int qed_hw_prepare(struct qed_dev *cdev, + int personality); + + /** +- * @brief qed_hw_remove - ++ * qed_hw_remove(): Remove Qed hardware. ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Void. + */ + void qed_hw_remove(struct qed_dev *cdev); + + /** +- * @brief qed_ptt_acquire - Allocate a PTT window ++ * qed_ptt_acquire(): Allocate a PTT window. + * +- * Should be called at the entry point to the driver (at the beginning of an +- * exported function) ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: struct qed_ptt. + * +- * @return struct qed_ptt ++ * Should be called at the entry point to the driver (at the beginning of an ++ * exported function). + */ + struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ptt_release - Release PTT Window ++ * qed_ptt_release(): Release PTT Window. + * +- * Should be called at the end of a flow - at the end of the function that +- * acquired the PTT. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * ++ * Return: Void. + * +- * @param p_hwfn +- * @param p_ptt ++ * Should be called at the end of a flow - at the end of the function that ++ * acquired the PTT. + */ + void qed_ptt_release(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); +@@ -205,15 +216,17 @@ enum qed_dmae_address_type_t { + }; + + /** +- * @brief qed_dmae_host2grc - copy data from source addr to +- * dmae registers using the given ptt ++ * qed_dmae_host2grc(): Copy data from source addr to ++ * dmae registers using the given ptt. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @source_addr: Source address. ++ * @grc_addr: GRC address (dmae_data_offset). ++ * @size_in_dwords: Size. ++ * @p_params: (default parameters will be used in case of NULL). + * +- * @param p_hwfn +- * @param p_ptt +- * @param source_addr +- * @param grc_addr (dmae_data_offset) +- * @param size_in_dwords +- * @param p_params (default parameters will be used in case of NULL) ++ * Return: Int. + */ + int + qed_dmae_host2grc(struct qed_hwfn *p_hwfn, +@@ -224,29 +237,34 @@ qed_dmae_host2grc(struct qed_hwfn *p_hwfn, + struct qed_dmae_params *p_params); + + /** +- * @brief qed_dmae_grc2host - Read data from dmae data offset +- * to source address using the given ptt ++ * qed_dmae_grc2host(): Read data from dmae data offset ++ * to source address using the given ptt. ++ * ++ * @p_ptt: P_ptt. ++ * @grc_addr: GRC address (dmae_data_offset). ++ * @dest_addr: Destination Address. ++ * @size_in_dwords: Size. ++ * @p_params: (default parameters will be used in case of NULL). + * +- * @param p_ptt +- * @param grc_addr (dmae_data_offset) +- * @param dest_addr +- * @param size_in_dwords +- * @param p_params (default parameters will be used in case of NULL) ++ * Return: Int. + */ + int qed_dmae_grc2host(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + u32 grc_addr, dma_addr_t dest_addr, u32 size_in_dwords, + struct qed_dmae_params *p_params); + + /** +- * @brief qed_dmae_host2host - copy data from to source address +- * to a destination adress (for SRIOV) using the given ptt ++ * qed_dmae_host2host(): Copy data from to source address ++ * to a destination adrress (for SRIOV) using the given ++ * ptt. + * +- * @param p_hwfn +- * @param p_ptt +- * @param source_addr +- * @param dest_addr +- * @param size_in_dwords +- * @param p_params (default parameters will be used in case of NULL) ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @source_addr: Source address. ++ * @dest_addr: Destination address. ++ * @size_in_dwords: size. ++ * @p_params: (default parameters will be used in case of NULL). ++ * ++ * Return: Int. + */ + int qed_dmae_host2host(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -259,51 +277,51 @@ int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain, + void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain); + + /** +- * @@brief qed_fw_l2_queue - Get absolute L2 queue ID ++ * qed_fw_l2_queue(): Get absolute L2 queue ID. + * +- * @param p_hwfn +- * @param src_id - relative to p_hwfn +- * @param dst_id - absolute per engine ++ * @p_hwfn: HW device data. ++ * @src_id: Relative to p_hwfn. ++ * @dst_id: Absolute per engine. + * +- * @return int ++ * Return: Int. + */ + int qed_fw_l2_queue(struct qed_hwfn *p_hwfn, + u16 src_id, + u16 *dst_id); + + /** +- * @@brief qed_fw_vport - Get absolute vport ID ++ * qed_fw_vport(): Get absolute vport ID. + * +- * @param p_hwfn +- * @param src_id - relative to p_hwfn +- * @param dst_id - absolute per engine ++ * @p_hwfn: HW device data. ++ * @src_id: Relative to p_hwfn. ++ * @dst_id: Absolute per engine. + * +- * @return int ++ * Return: Int. + */ + int qed_fw_vport(struct qed_hwfn *p_hwfn, + u8 src_id, + u8 *dst_id); + + /** +- * @@brief qed_fw_rss_eng - Get absolute RSS engine ID ++ * qed_fw_rss_eng(): Get absolute RSS engine ID. + * +- * @param p_hwfn +- * @param src_id - relative to p_hwfn +- * @param dst_id - absolute per engine ++ * @p_hwfn: HW device data. ++ * @src_id: Relative to p_hwfn. ++ * @dst_id: Absolute per engine. + * +- * @return int ++ * Return: Int. + */ + int qed_fw_rss_eng(struct qed_hwfn *p_hwfn, + u8 src_id, + u8 *dst_id); + + /** +- * @brief qed_llh_get_num_ppfid - Return the allocated number of LLH filter +- * banks that are allocated to the PF. ++ * qed_llh_get_num_ppfid(): Return the allocated number of LLH filter ++ * banks that are allocated to the PF. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return u8 - Number of LLH filter banks ++ * Return: u8 Number of LLH filter banks. + */ + u8 qed_llh_get_num_ppfid(struct qed_dev *cdev); + +@@ -314,45 +332,50 @@ enum qed_eng { + }; + + /** +- * @brief qed_llh_set_ppfid_affinity - Set the engine affinity for the given +- * LLH filter bank. ++ * qed_llh_set_ppfid_affinity(): Set the engine affinity for the given ++ * LLH filter bank. + * +- * @param cdev +- * @param ppfid - relative within the allocated ppfids ('0' is the default one). +- * @param eng ++ * @cdev: Qed dev pointer. ++ * @ppfid: Relative within the allocated ppfids ('0' is the default one). ++ * @eng: Engine. + * +- * @return int ++ * Return: Int. + */ + int qed_llh_set_ppfid_affinity(struct qed_dev *cdev, + u8 ppfid, enum qed_eng eng); + + /** +- * @brief qed_llh_set_roce_affinity - Set the RoCE engine affinity ++ * qed_llh_set_roce_affinity(): Set the RoCE engine affinity. + * +- * @param cdev +- * @param eng ++ * @cdev: Qed dev pointer. ++ * @eng: Engine. + * +- * @return int ++ * Return: Int. + */ + int qed_llh_set_roce_affinity(struct qed_dev *cdev, enum qed_eng eng); + + /** +- * @brief qed_llh_add_mac_filter - Add a LLH MAC filter into the given filter +- * bank. ++ * qed_llh_add_mac_filter(): Add a LLH MAC filter into the given filter ++ * bank. ++ * ++ * @cdev: Qed dev pointer. ++ * @ppfid: Relative within the allocated ppfids ('0' is the default one). ++ * @mac_addr: MAC to add. + * +- * @param cdev +- * @param ppfid - relative within the allocated ppfids ('0' is the default one). +- * @param mac_addr - MAC to add ++ * Return: Int. + */ + int qed_llh_add_mac_filter(struct qed_dev *cdev, + u8 ppfid, u8 mac_addr[ETH_ALEN]); + + /** +- * @brief qed_llh_remove_mac_filter - Remove a LLH MAC filter from the given +- * filter bank. ++ * qed_llh_remove_mac_filter(): Remove a LLH MAC filter from the given ++ * filter bank. + * +- * @param p_ptt +- * @param p_filter - MAC to remove ++ * @cdev: Qed dev pointer. ++ * @ppfid: Ppfid. ++ * @mac_addr: MAC to remove ++ * ++ * Return: Void. + */ + void qed_llh_remove_mac_filter(struct qed_dev *cdev, + u8 ppfid, u8 mac_addr[ETH_ALEN]); +@@ -368,15 +391,16 @@ enum qed_llh_prot_filter_type_t { + }; + + /** +- * @brief qed_llh_add_protocol_filter - Add a LLH protocol filter into the +- * given filter bank. ++ * qed_llh_add_protocol_filter(): Add a LLH protocol filter into the ++ * given filter bank. ++ * ++ * @cdev: Qed dev pointer. ++ * @ppfid: Relative within the allocated ppfids ('0' is the default one). ++ * @type: Type of filters and comparing. ++ * @source_port_or_eth_type: Source port or ethertype to add. ++ * @dest_port: Destination port to add. + * +- * @param cdev +- * @param ppfid - relative within the allocated ppfids ('0' is the default one). +- * @param type - type of filters and comparing +- * @param source_port_or_eth_type - source port or ethertype to add +- * @param dest_port - destination port to add +- * @param type - type of filters and comparing ++ * Return: Int. + */ + int + qed_llh_add_protocol_filter(struct qed_dev *cdev, +@@ -385,14 +409,14 @@ qed_llh_add_protocol_filter(struct qed_dev *cdev, + u16 source_port_or_eth_type, u16 dest_port); + + /** +- * @brief qed_llh_remove_protocol_filter - Remove a LLH protocol filter from +- * the given filter bank. ++ * qed_llh_remove_protocol_filter(): Remove a LLH protocol filter from ++ * the given filter bank. + * +- * @param cdev +- * @param ppfid - relative within the allocated ppfids ('0' is the default one). +- * @param type - type of filters and comparing +- * @param source_port_or_eth_type - source port or ethertype to add +- * @param dest_port - destination port to add ++ * @cdev: Qed dev pointer. ++ * @ppfid: Relative within the allocated ppfids ('0' is the default one). ++ * @type: Type of filters and comparing. ++ * @source_port_or_eth_type: Source port or ethertype to add. ++ * @dest_port: Destination port to add. + */ + void + qed_llh_remove_protocol_filter(struct qed_dev *cdev, +@@ -401,31 +425,31 @@ qed_llh_remove_protocol_filter(struct qed_dev *cdev, + u16 source_port_or_eth_type, u16 dest_port); + + /** +- * *@brief Cleanup of previous driver remains prior to load ++ * qed_final_cleanup(): Cleanup of previous driver remains prior to load. + * +- * @param p_hwfn +- * @param p_ptt +- * @param id - For PF, engine-relative. For VF, PF-relative. +- * @param is_vf - true iff cleanup is made for a VF. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @id: For PF, engine-relative. For VF, PF-relative. ++ * @is_vf: True iff cleanup is made for a VF. + * +- * @return int ++ * Return: Int. + */ + int qed_final_cleanup(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u16 id, bool is_vf); + + /** +- * @brief qed_get_queue_coalesce - Retrieve coalesce value for a given queue. ++ * qed_get_queue_coalesce(): Retrieve coalesce value for a given queue. + * +- * @param p_hwfn +- * @param p_coal - store coalesce value read from the hardware. +- * @param p_handle ++ * @p_hwfn: HW device data. ++ * @coal: Store coalesce value read from the hardware. ++ * @handle: P_handle. + * +- * @return int ++ * Return: Int. + **/ + int qed_get_queue_coalesce(struct qed_hwfn *p_hwfn, u16 *coal, void *handle); + + /** +- * @brief qed_set_queue_coalesce - Configure coalesce parameters for Rx and ++ * qed_set_queue_coalesce(): Configure coalesce parameters for Rx and + * Tx queue. The fact that we can configure coalescing to up to 511, but on + * varying accuracy [the bigger the value the less accurate] up to a mistake + * of 3usec for the highest values. +@@ -433,37 +457,38 @@ int qed_get_queue_coalesce(struct qed_hwfn *p_hwfn, u16 *coal, void *handle); + * should be in same range [i.e., either 0-0x7f, 0x80-0xff or 0x100-0x1ff] + * otherwise configuration would break. + * ++ * @rx_coal: Rx Coalesce value in micro seconds. ++ * @tx_coal: TX Coalesce value in micro seconds. ++ * @p_handle: P_handle. + * +- * @param rx_coal - Rx Coalesce value in micro seconds. +- * @param tx_coal - TX Coalesce value in micro seconds. +- * @param p_handle +- * +- * @return int ++ * Return: Int. + **/ + int + qed_set_queue_coalesce(u16 rx_coal, u16 tx_coal, void *p_handle); + + /** +- * @brief qed_pglueb_set_pfid_enable - Enable or disable PCI BUS MASTER ++ * qed_pglueb_set_pfid_enable(): Enable or disable PCI BUS MASTER. + * +- * @param p_hwfn +- * @param p_ptt +- * @param b_enable - true/false ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @b_enable: True/False. + * +- * @return int ++ * Return: Int. + */ + int qed_pglueb_set_pfid_enable(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, bool b_enable); + + /** +- * @brief db_recovery_add - add doorbell information to the doorbell +- * recovery mechanism. ++ * qed_db_recovery_add(): add doorbell information to the doorbell ++ * recovery mechanism. + * +- * @param cdev +- * @param db_addr - doorbell address +- * @param db_data - address of where db_data is stored +- * @param db_width - doorbell is 32b pr 64b +- * @param db_space - doorbell recovery addresses are user or kernel space ++ * @cdev: Qed dev pointer. ++ * @db_addr: Doorbell address. ++ * @db_data: Address of where db_data is stored. ++ * @db_width: Doorbell is 32b pr 64b. ++ * @db_space: Doorbell recovery addresses are user or kernel space. ++ * ++ * Return: Int. + */ + int qed_db_recovery_add(struct qed_dev *cdev, + void __iomem *db_addr, +@@ -472,13 +497,15 @@ int qed_db_recovery_add(struct qed_dev *cdev, + enum qed_db_rec_space db_space); + + /** +- * @brief db_recovery_del - remove doorbell information from the doorbell ++ * qed_db_recovery_del() - remove doorbell information from the doorbell + * recovery mechanism. db_data serves as key (db_addr is not unique). + * +- * @param cdev +- * @param db_addr - doorbell address +- * @param db_data - address where db_data is stored. Serves as key for the ++ * @cdev: Qed dev pointer. ++ * @db_addr: doorbell address. ++ * @db_data: address where db_data is stored. Serves as key for the + * entry to delete. ++ * ++ * Return: Int. + */ + int qed_db_recovery_del(struct qed_dev *cdev, + void __iomem *db_addr, void *db_data); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_hsi.h b/drivers/net/ethernet/qlogic/qed/qed_hsi.h +index fb1baa2da2d0d..744c82a108754 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_hsi.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_hsi.h +@@ -3012,96 +3012,102 @@ struct iro { + /***************************** Public Functions *******************************/ + + /** +- * @brief qed_dbg_set_bin_ptr - Sets a pointer to the binary data with debug +- * arrays. ++ * qed_dbg_set_bin_ptr(): Sets a pointer to the binary data with debug ++ * arrays. + * +- * @param p_hwfn - HW device data +- * @param bin_ptr - a pointer to the binary data with debug arrays. ++ * @p_hwfn: HW device data. ++ * @bin_ptr: A pointer to the binary data with debug arrays. ++ * ++ * Return: enum dbg status. + */ + enum dbg_status qed_dbg_set_bin_ptr(struct qed_hwfn *p_hwfn, + const u8 * const bin_ptr); + + /** +- * @brief qed_read_regs - Reads registers into a buffer (using GRC). ++ * qed_read_regs(): Reads registers into a buffer (using GRC). ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf: Destination buffer. ++ * @addr: Source GRC address in dwords. ++ * @len: Number of registers to read. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf - Destination buffer. +- * @param addr - Source GRC address in dwords. +- * @param len - Number of registers to read. ++ * Return: Void. + */ + void qed_read_regs(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *buf, u32 addr, u32 len); + + /** +- * @brief qed_read_fw_info - Reads FW info from the chip. ++ * qed_read_fw_info(): Reads FW info from the chip. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @fw_info: (Out) a pointer to write the FW info into. ++ * ++ * Return: True if the FW info was read successfully from one of the Storms, ++ * or false if all Storms are in reset. + * + * The FW info contains FW-related information, such as the FW version, + * FW image (main/L2B/kuku), FW timestamp, etc. + * The FW info is read from the internal RAM of the first Storm that is not in + * reset. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param fw_info - Out: a pointer to write the FW info into. +- * +- * @return true if the FW info was read successfully from one of the Storms, +- * or false if all Storms are in reset. + */ + bool qed_read_fw_info(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, struct fw_info *fw_info); + /** +- * @brief qed_dbg_grc_config - Sets the value of a GRC parameter. ++ * qed_dbg_grc_config(): Sets the value of a GRC parameter. + * +- * @param p_hwfn - HW device data +- * @param grc_param - GRC parameter +- * @param val - Value to set. ++ * @p_hwfn: HW device data. ++ * @grc_param: GRC parameter. ++ * @val: Value to set. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - grc_param is invalid +- * - val is outside the allowed boundaries ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - Grc_param is invalid. ++ * - Val is outside the allowed boundaries. + */ + enum dbg_status qed_dbg_grc_config(struct qed_hwfn *p_hwfn, + enum dbg_grc_params grc_param, u32 val); + + /** +- * @brief qed_dbg_grc_set_params_default - Reverts all GRC parameters to their +- * default value. ++ * qed_dbg_grc_set_params_default(): Reverts all GRC parameters to their ++ * default value. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn - HW device data ++ * Return: Void. + */ + void qed_dbg_grc_set_params_default(struct qed_hwfn *p_hwfn); + /** +- * @brief qed_dbg_grc_get_dump_buf_size - Returns the required buffer size for +- * GRC Dump. ++ * qed_dbg_grc_get_dump_buf_size(): Returns the required buffer size for ++ * GRC Dump. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for the GRC Dump +- * data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) required buffer size (in dwords) for the GRC Dump ++ * data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_grc_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + + /** +- * @brief qed_dbg_grc_dump - Dumps GRC data into the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the collected GRC data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified dump buffer is too small +- * Otherwise, returns ok. ++ * qed_dbg_grc_dump(): Dumps GRC data into the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the collected GRC data into. ++ * @buf_size_in_dwords:Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified dump buffer is too small. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_grc_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3110,36 +3116,36 @@ enum dbg_status qed_dbg_grc_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_idle_chk_get_dump_buf_size - Returns the required buffer size +- * for idle check results. ++ * qed_dbg_idle_chk_get_dump_buf_size(): Returns the required buffer size ++ * for idle check results. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for the idle check +- * data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) required buffer size (in dwords) for the idle check ++ * data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * return: Error if one of the following holds: ++ * - The version wasn't set. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_idle_chk_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + + /** +- * @brief qed_dbg_idle_chk_dump - Performs idle check and writes the results +- * into the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the idle check data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * Otherwise, returns ok. ++ * qed_dbg_idle_chk_dump: Performs idle check and writes the results ++ * into the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the idle check data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified buffer is too small. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_idle_chk_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3148,42 +3154,42 @@ enum dbg_status qed_dbg_idle_chk_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_mcp_trace_get_dump_buf_size - Returns the required buffer size +- * for mcp trace results. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for mcp trace data. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the trace data in MCP scratchpad contain an invalid signature +- * - the bundle ID in NVRAM is invalid +- * - the trace meta data cannot be found (in NVRAM or image file) +- * Otherwise, returns ok. ++ * qed_dbg_mcp_trace_get_dump_buf_size(): Returns the required buffer size ++ * for mcp trace results. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) Required buffer size (in dwords) for mcp trace data. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The trace data in MCP scratchpad contain an invalid signature. ++ * - The bundle ID in NVRAM is invalid. ++ * - The trace meta data cannot be found (in NVRAM or image file). ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_mcp_trace_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + + /** +- * @brief qed_dbg_mcp_trace_dump - Performs mcp trace and writes the results +- * into the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the mcp trace data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * - the trace data in MCP scratchpad contain an invalid signature +- * - the bundle ID in NVRAM is invalid +- * - the trace meta data cannot be found (in NVRAM or image file) +- * - the trace meta data cannot be read (from NVRAM or image file) +- * Otherwise, returns ok. ++ * qed_dbg_mcp_trace_dump(): Performs mcp trace and writes the results ++ * into the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the mcp trace data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified buffer is too small. ++ * - The trace data in MCP scratchpad contain an invalid signature. ++ * - The bundle ID in NVRAM is invalid. ++ * - The trace meta data cannot be found (in NVRAM or image file). ++ * - The trace meta data cannot be read (from NVRAM or image file). ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_mcp_trace_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3192,36 +3198,36 @@ enum dbg_status qed_dbg_mcp_trace_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_reg_fifo_get_dump_buf_size - Returns the required buffer size +- * for grc trace fifo results. ++ * qed_dbg_reg_fifo_get_dump_buf_size(): Returns the required buffer size ++ * for grc trace fifo results. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for reg fifo data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) Required buffer size (in dwords) for reg fifo data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_reg_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + + /** +- * @brief qed_dbg_reg_fifo_dump - Reads the reg fifo and writes the results into +- * the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the reg fifo data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * - DMAE transaction failed +- * Otherwise, returns ok. ++ * qed_dbg_reg_fifo_dump(): Reads the reg fifo and writes the results into ++ * the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the reg fifo data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified buffer is too small. ++ * - DMAE transaction failed. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_reg_fifo_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3230,37 +3236,37 @@ enum dbg_status qed_dbg_reg_fifo_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_igu_fifo_get_dump_buf_size - Returns the required buffer size +- * for the IGU fifo results. ++ * qed_dbg_igu_fifo_get_dump_buf_size(): Returns the required buffer size ++ * for the IGU fifo results. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for the IGU fifo +- * data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) Required buffer size (in dwords) for the IGU fifo ++ * data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_igu_fifo_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + + /** +- * @brief qed_dbg_igu_fifo_dump - Reads the IGU fifo and writes the results into +- * the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the IGU fifo data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * - DMAE transaction failed +- * Otherwise, returns ok. ++ * qed_dbg_igu_fifo_dump(): Reads the IGU fifo and writes the results into ++ * the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the IGU fifo data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * - The specified buffer is too small ++ * - DMAE transaction failed ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_igu_fifo_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3269,37 +3275,37 @@ enum dbg_status qed_dbg_igu_fifo_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_protection_override_get_dump_buf_size - Returns the required +- * buffer size for protection override window results. ++ * qed_dbg_protection_override_get_dump_buf_size(): Returns the required ++ * buffer size for protection override window results. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for protection +- * override data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) Required buffer size (in dwords) for protection ++ * override data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * Otherwise, returns ok. + */ + enum dbg_status + qed_dbg_protection_override_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + /** +- * @brief qed_dbg_protection_override_dump - Reads protection override window +- * entries and writes the results into the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the protection override data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * - DMAE transaction failed +- * Otherwise, returns ok. ++ * qed_dbg_protection_override_dump(): Reads protection override window ++ * entries and writes the results into the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the protection override data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * @return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified buffer is too small. ++ * - DMAE transaction failed. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_protection_override_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3307,34 +3313,34 @@ enum dbg_status qed_dbg_protection_override_dump(struct qed_hwfn *p_hwfn, + u32 buf_size_in_dwords, + u32 *num_dumped_dwords); + /** +- * @brief qed_dbg_fw_asserts_get_dump_buf_size - Returns the required buffer +- * size for FW Asserts results. ++ * qed_dbg_fw_asserts_get_dump_buf_size(): Returns the required buffer ++ * size for FW Asserts results. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param buf_size - OUT: required buffer size (in dwords) for FW Asserts data. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @buf_size: (OUT) Required buffer size (in dwords) for FW Asserts data. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_fw_asserts_get_dump_buf_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *buf_size); + /** +- * @brief qed_dbg_fw_asserts_dump - Reads the FW Asserts and writes the results +- * into the specified buffer. +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param dump_buf - Pointer to write the FW Asserts data into. +- * @param buf_size_in_dwords - Size of the specified buffer in dwords. +- * @param num_dumped_dwords - OUT: number of dumped dwords. +- * +- * @return error if one of the following holds: +- * - the version wasn't set +- * - the specified buffer is too small +- * Otherwise, returns ok. ++ * qed_dbg_fw_asserts_dump(): Reads the FW Asserts and writes the results ++ * into the specified buffer. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dump_buf: Pointer to write the FW Asserts data into. ++ * @buf_size_in_dwords: Size of the specified buffer in dwords. ++ * @num_dumped_dwords: (OUT) number of dumped dwords. ++ * ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * - The specified buffer is too small. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_fw_asserts_dump(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3343,19 +3349,19 @@ enum dbg_status qed_dbg_fw_asserts_dump(struct qed_hwfn *p_hwfn, + u32 *num_dumped_dwords); + + /** +- * @brief qed_dbg_read_attn - Reads the attention registers of the specified ++ * qed_dbg_read_attn(): Reads the attention registers of the specified + * block and type, and writes the results into the specified buffer. + * +- * @param p_hwfn - HW device data +- * @param p_ptt - Ptt window used for writing the registers. +- * @param block - Block ID. +- * @param attn_type - Attention type. +- * @param clear_status - Indicates if the attention status should be cleared. +- * @param results - OUT: Pointer to write the read results into ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @block: Block ID. ++ * @attn_type: Attention type. ++ * @clear_status: Indicates if the attention status should be cleared. ++ * @results: (OUT) Pointer to write the read results into. + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_read_attn(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3365,15 +3371,15 @@ enum dbg_status qed_dbg_read_attn(struct qed_hwfn *p_hwfn, + struct dbg_attn_block_result *results); + + /** +- * @brief qed_dbg_print_attn - Prints attention registers values in the +- * specified results struct. ++ * qed_dbg_print_attn(): Prints attention registers values in the ++ * specified results struct. + * +- * @param p_hwfn +- * @param results - Pointer to the attention read results ++ * @p_hwfn: HW device data. ++ * @results: Pointer to the attention read results + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_print_attn(struct qed_hwfn *p_hwfn, + struct dbg_attn_block_result *results); +@@ -3420,60 +3426,64 @@ struct dbg_tools_user_data { + /***************************** Public Functions *******************************/ + + /** +- * @brief qed_dbg_user_set_bin_ptr - Sets a pointer to the binary data with +- * debug arrays. ++ * qed_dbg_user_set_bin_ptr(): Sets a pointer to the binary data with ++ * debug arrays. + * +- * @param p_hwfn - HW device data +- * @param bin_ptr - a pointer to the binary data with debug arrays. ++ * @p_hwfn: HW device data. ++ * @bin_ptr: a pointer to the binary data with debug arrays. ++ * ++ * Return: dbg_status. + */ + enum dbg_status qed_dbg_user_set_bin_ptr(struct qed_hwfn *p_hwfn, + const u8 * const bin_ptr); + + /** +- * @brief qed_dbg_alloc_user_data - Allocates user debug data. ++ * qed_dbg_alloc_user_data(): Allocates user debug data. ++ * ++ * @p_hwfn: HW device data. ++ * @user_data_ptr: (OUT) a pointer to the allocated memory. + * +- * @param p_hwfn - HW device data +- * @param user_data_ptr - OUT: a pointer to the allocated memory. ++ * Return: dbg_status. + */ + enum dbg_status qed_dbg_alloc_user_data(struct qed_hwfn *p_hwfn, + void **user_data_ptr); + + /** +- * @brief qed_dbg_get_status_str - Returns a string for the specified status. ++ * qed_dbg_get_status_str(): Returns a string for the specified status. + * +- * @param status - a debug status code. ++ * @status: A debug status code. + * +- * @return a string for the specified status ++ * Return: A string for the specified status. + */ + const char *qed_dbg_get_status_str(enum dbg_status status); + + /** +- * @brief qed_get_idle_chk_results_buf_size - Returns the required buffer size +- * for idle check results (in bytes). ++ * qed_get_idle_chk_results_buf_size(): Returns the required buffer size ++ * for idle check results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - idle check dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: idle check dump buffer. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_get_idle_chk_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *dump_buf, + u32 num_dumped_dwords, + u32 *results_buf_size); + /** +- * @brief qed_print_idle_chk_results - Prints idle check results ++ * qed_print_idle_chk_results(): Prints idle check results + * +- * @param p_hwfn - HW device data +- * @param dump_buf - idle check dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the idle check results. +- * @param num_errors - OUT: number of errors found in idle check. +- * @param num_warnings - OUT: number of warnings found in idle check. ++ * @p_hwfn: HW device data. ++ * @dump_buf: idle check dump buffer. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf: buffer for printing the idle check results. ++ * @num_errors: (OUT) number of errors found in idle check. ++ * @num_warnings: (OUT) number of warnings found in idle check. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_idle_chk_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3483,28 +3493,30 @@ enum dbg_status qed_print_idle_chk_results(struct qed_hwfn *p_hwfn, + u32 *num_warnings); + + /** +- * @brief qed_dbg_mcp_trace_set_meta_data - Sets the MCP Trace meta data. ++ * qed_dbg_mcp_trace_set_meta_data(): Sets the MCP Trace meta data. ++ * ++ * @p_hwfn: HW device data. ++ * @meta_buf: Meta buffer. ++ * ++ * Return: Void. + * + * Needed in case the MCP Trace dump doesn't contain the meta data (e.g. due to + * no NVRAM access). +- * +- * @param data - pointer to MCP Trace meta data +- * @param size - size of MCP Trace meta data in dwords + */ + void qed_dbg_mcp_trace_set_meta_data(struct qed_hwfn *p_hwfn, + const u32 *meta_buf); + + /** +- * @brief qed_get_mcp_trace_results_buf_size - Returns the required buffer size +- * for MCP Trace results (in bytes). ++ * qed_get_mcp_trace_results_buf_size(): Returns the required buffer size ++ * for MCP Trace results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - MCP Trace dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: MCP Trace dump buffer. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Rrror if the parsing fails, ok otherwise. + */ + enum dbg_status qed_get_mcp_trace_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3512,14 +3524,14 @@ enum dbg_status qed_get_mcp_trace_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *results_buf_size); + + /** +- * @brief qed_print_mcp_trace_results - Prints MCP Trace results ++ * qed_print_mcp_trace_results(): Prints MCP Trace results + * +- * @param p_hwfn - HW device data +- * @param dump_buf - mcp trace dump buffer, starting from the header. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the mcp trace results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: MCP trace dump buffer, starting from the header. ++ * @num_dumped_dwords: Member of dwords that were dumped. ++ * @results_buf: Buffer for printing the mcp trace results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_mcp_trace_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3527,30 +3539,30 @@ enum dbg_status qed_print_mcp_trace_results(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief qed_print_mcp_trace_results_cont - Prints MCP Trace results, and ++ * qed_print_mcp_trace_results_cont(): Prints MCP Trace results, and + * keeps the MCP trace meta data allocated, to support continuous MCP Trace + * parsing. After the continuous parsing ends, mcp_trace_free_meta_data should + * be called to free the meta data. + * +- * @param p_hwfn - HW device data +- * @param dump_buf - mcp trace dump buffer, starting from the header. +- * @param results_buf - buffer for printing the mcp trace results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: MVP trace dump buffer, starting from the header. ++ * @results_buf: Buffer for printing the mcp trace results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_mcp_trace_results_cont(struct qed_hwfn *p_hwfn, + u32 *dump_buf, + char *results_buf); + + /** +- * @brief print_mcp_trace_line - Prints MCP Trace results for a single line ++ * qed_print_mcp_trace_line(): Prints MCP Trace results for a single line + * +- * @param p_hwfn - HW device data +- * @param dump_buf - mcp trace dump buffer, starting from the header. +- * @param num_dumped_bytes - number of bytes that were dumped. +- * @param results_buf - buffer for printing the mcp trace results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: MCP trace dump buffer, starting from the header. ++ * @num_dumped_bytes: Number of bytes that were dumped. ++ * @results_buf: Buffer for printing the mcp trace results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_mcp_trace_line(struct qed_hwfn *p_hwfn, + u8 *dump_buf, +@@ -3558,24 +3570,26 @@ enum dbg_status qed_print_mcp_trace_line(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief mcp_trace_free_meta_data - Frees the MCP Trace meta data. ++ * qed_mcp_trace_free_meta_data(): Frees the MCP Trace meta data. + * Should be called after continuous MCP Trace parsing. + * +- * @param p_hwfn - HW device data ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_mcp_trace_free_meta_data(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_get_reg_fifo_results_buf_size - Returns the required buffer size +- * for reg_fifo results (in bytes). ++ * qed_get_reg_fifo_results_buf_size(): Returns the required buffer size ++ * for reg_fifo results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - reg fifo dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: Reg fifo dump buffer. ++ * @num_dumped_dwords: Number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_get_reg_fifo_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3583,14 +3597,14 @@ enum dbg_status qed_get_reg_fifo_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *results_buf_size); + + /** +- * @brief qed_print_reg_fifo_results - Prints reg fifo results ++ * qed_print_reg_fifo_results(): Prints reg fifo results. + * +- * @param p_hwfn - HW device data +- * @param dump_buf - reg fifo dump buffer, starting from the header. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the reg fifo results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: Reg fifo dump buffer, starting from the header. ++ * @num_dumped_dwords: Number of dwords that were dumped. ++ * @results_buf: Buffer for printing the reg fifo results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_reg_fifo_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3598,16 +3612,16 @@ enum dbg_status qed_print_reg_fifo_results(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief qed_get_igu_fifo_results_buf_size - Returns the required buffer size +- * for igu_fifo results (in bytes). ++ * qed_get_igu_fifo_results_buf_size(): Returns the required buffer size ++ * for igu_fifo results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - IGU fifo dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: IGU fifo dump buffer. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_get_igu_fifo_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3615,14 +3629,14 @@ enum dbg_status qed_get_igu_fifo_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *results_buf_size); + + /** +- * @brief qed_print_igu_fifo_results - Prints IGU fifo results ++ * qed_print_igu_fifo_results(): Prints IGU fifo results + * +- * @param p_hwfn - HW device data +- * @param dump_buf - IGU fifo dump buffer, starting from the header. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the IGU fifo results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: IGU fifo dump buffer, starting from the header. ++ * @num_dumped_dwords: Number of dwords that were dumped. ++ * @results_buf: Buffer for printing the IGU fifo results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_igu_fifo_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3630,16 +3644,16 @@ enum dbg_status qed_print_igu_fifo_results(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief qed_get_protection_override_results_buf_size - Returns the required +- * buffer size for protection override results (in bytes). ++ * qed_get_protection_override_results_buf_size(): Returns the required ++ * buffer size for protection override results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - protection override dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: Protection override dump buffer. ++ * @num_dumped_dwords: Number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status + qed_get_protection_override_results_buf_size(struct qed_hwfn *p_hwfn, +@@ -3648,15 +3662,15 @@ qed_get_protection_override_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *results_buf_size); + + /** +- * @brief qed_print_protection_override_results - Prints protection override +- * results. ++ * qed_print_protection_override_results(): Prints protection override ++ * results. + * +- * @param p_hwfn - HW device data +- * @param dump_buf - protection override dump buffer, starting from the header. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the reg fifo results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: Protection override dump buffer, starting from the header. ++ * @num_dumped_dwords: Number of dwords that were dumped. ++ * @results_buf: Buffer for printing the reg fifo results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_protection_override_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3664,16 +3678,16 @@ enum dbg_status qed_print_protection_override_results(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief qed_get_fw_asserts_results_buf_size - Returns the required buffer size +- * for FW Asserts results (in bytes). ++ * qed_get_fw_asserts_results_buf_size(): Returns the required buffer size ++ * for FW Asserts results (in bytes). + * +- * @param p_hwfn - HW device data +- * @param dump_buf - FW Asserts dump buffer. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf_size - OUT: required buffer size (in bytes) for the parsed +- * results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: FW Asserts dump buffer. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf_size: (OUT) required buffer size (in bytes) for the parsed ++ * results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_get_fw_asserts_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3681,14 +3695,14 @@ enum dbg_status qed_get_fw_asserts_results_buf_size(struct qed_hwfn *p_hwfn, + u32 *results_buf_size); + + /** +- * @brief qed_print_fw_asserts_results - Prints FW Asserts results ++ * qed_print_fw_asserts_results(): Prints FW Asserts results. + * +- * @param p_hwfn - HW device data +- * @param dump_buf - FW Asserts dump buffer, starting from the header. +- * @param num_dumped_dwords - number of dwords that were dumped. +- * @param results_buf - buffer for printing the FW Asserts results. ++ * @p_hwfn: HW device data. ++ * @dump_buf: FW Asserts dump buffer, starting from the header. ++ * @num_dumped_dwords: number of dwords that were dumped. ++ * @results_buf: buffer for printing the FW Asserts results. + * +- * @return error if the parsing fails, ok otherwise. ++ * Return: Error if the parsing fails, ok otherwise. + */ + enum dbg_status qed_print_fw_asserts_results(struct qed_hwfn *p_hwfn, + u32 *dump_buf, +@@ -3696,15 +3710,15 @@ enum dbg_status qed_print_fw_asserts_results(struct qed_hwfn *p_hwfn, + char *results_buf); + + /** +- * @brief qed_dbg_parse_attn - Parses and prints attention registers values in +- * the specified results struct. ++ * qed_dbg_parse_attn(): Parses and prints attention registers values in ++ * the specified results struct. + * +- * @param p_hwfn - HW device data +- * @param results - Pointer to the attention read results ++ * @p_hwfn: HW device data. ++ * @results: Pointer to the attention read results + * +- * @return error if one of the following holds: +- * - the version wasn't set +- * Otherwise, returns ok. ++ * Return: Error if one of the following holds: ++ * - The version wasn't set. ++ * Otherwise, returns ok. + */ + enum dbg_status qed_dbg_parse_attn(struct qed_hwfn *p_hwfn, + struct dbg_attn_block_result *results); +@@ -3746,18 +3760,18 @@ enum dbg_status qed_dbg_parse_attn(struct qed_hwfn *p_hwfn, + #define GTT_BAR0_MAP_REG_PSDM_RAM 0x01a000UL + + /** +- * @brief qed_qm_pf_mem_size - prepare QM ILT sizes ++ * qed_qm_pf_mem_size(): Prepare QM ILT sizes. + * +- * Returns the required host memory size in 4KB units. +- * Must be called before all QM init HSI functions. ++ * @num_pf_cids: Number of connections used by this PF. ++ * @num_vf_cids: Number of connections used by VFs of this PF. ++ * @num_tids: Number of tasks used by this PF. ++ * @num_pf_pqs: Number of PQs used by this PF. ++ * @num_vf_pqs: Number of PQs used by VFs of this PF. + * +- * @param num_pf_cids - number of connections used by this PF +- * @param num_vf_cids - number of connections used by VFs of this PF +- * @param num_tids - number of tasks used by this PF +- * @param num_pf_pqs - number of PQs used by this PF +- * @param num_vf_pqs - number of PQs used by VFs of this PF ++ * Return: The required host memory size in 4KB units. + * +- * @return The required host memory size in 4KB units. ++ * Returns the required host memory size in 4KB units. ++ * Must be called before all QM init HSI functions. + */ + u32 qed_qm_pf_mem_size(u32 num_pf_cids, + u32 num_vf_cids, +@@ -3800,74 +3814,74 @@ int qed_qm_pf_rt_init(struct qed_hwfn *p_hwfn, + struct qed_qm_pf_rt_init_params *p_params); + + /** +- * @brief qed_init_pf_wfq - Initializes the WFQ weight of the specified PF ++ * qed_init_pf_wfq(): Initializes the WFQ weight of the specified PF. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers +- * @param pf_id - PF ID +- * @param pf_wfq - WFQ weight. Must be non-zero. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers ++ * @pf_id: PF ID ++ * @pf_wfq: WFQ weight. Must be non-zero. + * +- * @return 0 on success, -1 on error. ++ * Return: 0 on success, -1 on error. + */ + int qed_init_pf_wfq(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u8 pf_id, u16 pf_wfq); + + /** +- * @brief qed_init_pf_rl - Initializes the rate limit of the specified PF ++ * qed_init_pf_rl(): Initializes the rate limit of the specified PF + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers +- * @param pf_id - PF ID +- * @param pf_rl - rate limit in Mb/sec units ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @pf_id: PF ID. ++ * @pf_rl: rate limit in Mb/sec units + * +- * @return 0 on success, -1 on error. ++ * Return: 0 on success, -1 on error. + */ + int qed_init_pf_rl(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u8 pf_id, u32 pf_rl); + + /** +- * @brief qed_init_vport_wfq Initializes the WFQ weight of the specified VPORT ++ * qed_init_vport_wfq(): Initializes the WFQ weight of the specified VPORT + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers +- * @param first_tx_pq_id- An array containing the first Tx PQ ID associated +- * with the VPORT for each TC. This array is filled by +- * qed_qm_pf_rt_init +- * @param vport_wfq - WFQ weight. Must be non-zero. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers ++ * @first_tx_pq_id: An array containing the first Tx PQ ID associated ++ * with the VPORT for each TC. This array is filled by ++ * qed_qm_pf_rt_init ++ * @wfq: WFQ weight. Must be non-zero. + * +- * @return 0 on success, -1 on error. ++ * Return: 0 on success, -1 on error. + */ + int qed_init_vport_wfq(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u16 first_tx_pq_id[NUM_OF_TCS], u16 wfq); + + /** +- * @brief qed_init_global_rl - Initializes the rate limit of the specified +- * rate limiter ++ * qed_init_global_rl(): Initializes the rate limit of the specified ++ * rate limiter. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers +- * @param rl_id - RL ID +- * @param rate_limit - rate limit in Mb/sec units ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @rl_id: RL ID. ++ * @rate_limit: Rate limit in Mb/sec units + * +- * @return 0 on success, -1 on error. ++ * Return: 0 on success, -1 on error. + */ + int qed_init_global_rl(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u16 rl_id, u32 rate_limit); + + /** +- * @brief qed_send_qm_stop_cmd Sends a stop command to the QM ++ * qed_send_qm_stop_cmd(): Sends a stop command to the QM. + * +- * @param p_hwfn +- * @param p_ptt +- * @param is_release_cmd - true for release, false for stop. +- * @param is_tx_pq - true for Tx PQs, false for Other PQs. +- * @param start_pq - first PQ ID to stop +- * @param num_pqs - Number of PQs to stop, starting from start_pq. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @is_release_cmd: true for release, false for stop. ++ * @is_tx_pq: true for Tx PQs, false for Other PQs. ++ * @start_pq: first PQ ID to stop ++ * @num_pqs: Number of PQs to stop, starting from start_pq. + * +- * @return bool, true if successful, false if timeout occurred while waiting for +- * QM command done. ++ * Return: Bool, true if successful, false if timeout occurred while waiting ++ * for QM command done. + */ + bool qed_send_qm_stop_cmd(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3875,53 +3889,64 @@ bool qed_send_qm_stop_cmd(struct qed_hwfn *p_hwfn, + bool is_tx_pq, u16 start_pq, u16 num_pqs); + + /** +- * @brief qed_set_vxlan_dest_port - initializes vxlan tunnel destination udp port ++ * qed_set_vxlan_dest_port(): Initializes vxlan tunnel destination udp port. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. +- * @param dest_port - vxlan destination udp port. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dest_port: vxlan destination udp port. ++ * ++ * Return: Void. + */ + void qed_set_vxlan_dest_port(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u16 dest_port); + + /** +- * @brief qed_set_vxlan_enable - enable or disable VXLAN tunnel in HW ++ * qed_set_vxlan_enable(): Enable or disable VXLAN tunnel in HW. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @vxlan_enable: vxlan enable flag. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. +- * @param vxlan_enable - vxlan enable flag. ++ * Return: Void. + */ + void qed_set_vxlan_enable(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, bool vxlan_enable); + + /** +- * @brief qed_set_gre_enable - enable or disable GRE tunnel in HW ++ * qed_set_gre_enable(): Enable or disable GRE tunnel in HW. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @eth_gre_enable: Eth GRE enable flag. ++ * @ip_gre_enable: IP GRE enable flag. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. +- * @param eth_gre_enable - eth GRE enable enable flag. +- * @param ip_gre_enable - IP GRE enable enable flag. ++ * Return: Void. + */ + void qed_set_gre_enable(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + bool eth_gre_enable, bool ip_gre_enable); + + /** +- * @brief qed_set_geneve_dest_port - initializes geneve tunnel destination udp port ++ * qed_set_geneve_dest_port(): Initializes geneve tunnel destination udp port + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. +- * @param dest_port - geneve destination udp port. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @dest_port: Geneve destination udp port. ++ * ++ * Retur: Void. + */ + void qed_set_geneve_dest_port(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u16 dest_port); + + /** +- * @brief qed_set_gre_enable - enable or disable GRE tunnel in HW ++ * qed_set_geneve_enable(): Enable or disable GRE tunnel in HW. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @eth_geneve_enable: Eth GENEVE enable flag. ++ * @ip_geneve_enable: IP GENEVE enable flag. + * +- * @param p_ptt - ptt window used for writing the registers. +- * @param eth_geneve_enable - eth GENEVE enable enable flag. +- * @param ip_geneve_enable - IP GENEVE enable enable flag. ++ * Return: Void. + */ + void qed_set_geneve_enable(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3931,25 +3956,29 @@ void qed_set_vxlan_no_l2_enable(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, bool enable); + + /** +- * @brief qed_gft_disable - Disable GFT ++ * qed_gft_disable(): Disable GFT. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @pf_id: PF on which to disable GFT. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. +- * @param pf_id - pf on which to disable GFT. ++ * Return: Void. + */ + void qed_gft_disable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, u16 pf_id); + + /** +- * @brief qed_gft_config - Enable and configure HW for GFT +- * +- * @param p_hwfn - HW device data +- * @param p_ptt - ptt window used for writing the registers. +- * @param pf_id - pf on which to enable GFT. +- * @param tcp - set profile tcp packets. +- * @param udp - set profile udp packet. +- * @param ipv4 - set profile ipv4 packet. +- * @param ipv6 - set profile ipv6 packet. +- * @param profile_type - define packet same fields. Use enum gft_profile_type. ++ * qed_gft_config(): Enable and configure HW for GFT. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @pf_id: PF on which to enable GFT. ++ * @tcp: Set profile tcp packets. ++ * @udp: Set profile udp packet. ++ * @ipv4: Set profile ipv4 packet. ++ * @ipv6: Set profile ipv6 packet. ++ * @profile_type: Define packet same fields. Use enum gft_profile_type. ++ * ++ * Return: Void. + */ + void qed_gft_config(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -3959,107 +3988,120 @@ void qed_gft_config(struct qed_hwfn *p_hwfn, + bool ipv4, bool ipv6, enum gft_profile_type profile_type); + + /** +- * @brief qed_enable_context_validation - Enable and configure context +- * validation. ++ * qed_enable_context_validation(): Enable and configure context ++ * validation. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. + * +- * @param p_hwfn +- * @param p_ptt - ptt window used for writing the registers. ++ * Return: Void. + */ + void qed_enable_context_validation(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief qed_calc_session_ctx_validation - Calcualte validation byte for +- * session context. ++ * qed_calc_session_ctx_validation(): Calcualte validation byte for ++ * session context. + * +- * @param p_ctx_mem - pointer to context memory. +- * @param ctx_size - context size. +- * @param ctx_type - context type. +- * @param cid - context cid. ++ * @p_ctx_mem: Pointer to context memory. ++ * @ctx_size: Context size. ++ * @ctx_type: Context type. ++ * @cid: Context cid. ++ * ++ * Return: Void. + */ + void qed_calc_session_ctx_validation(void *p_ctx_mem, + u16 ctx_size, u8 ctx_type, u32 cid); + + /** +- * @brief qed_calc_task_ctx_validation - Calcualte validation byte for task +- * context. ++ * qed_calc_task_ctx_validation(): Calcualte validation byte for task ++ * context. ++ * ++ * @p_ctx_mem: Pointer to context memory. ++ * @ctx_size: Context size. ++ * @ctx_type: Context type. ++ * @tid: Context tid. + * +- * @param p_ctx_mem - pointer to context memory. +- * @param ctx_size - context size. +- * @param ctx_type - context type. +- * @param tid - context tid. ++ * Return: Void. + */ + void qed_calc_task_ctx_validation(void *p_ctx_mem, + u16 ctx_size, u8 ctx_type, u32 tid); + + /** +- * @brief qed_memset_session_ctx - Memset session context to 0 while +- * preserving validation bytes. ++ * qed_memset_session_ctx(): Memset session context to 0 while ++ * preserving validation bytes. ++ * ++ * @p_ctx_mem: Pointer to context memory. ++ * @ctx_size: Size to initialzie. ++ * @ctx_type: Context type. + * +- * @param p_hwfn - +- * @param p_ctx_mem - pointer to context memory. +- * @param ctx_size - size to initialzie. +- * @param ctx_type - context type. ++ * Return: Void. + */ + void qed_memset_session_ctx(void *p_ctx_mem, u32 ctx_size, u8 ctx_type); + + /** +- * @brief qed_memset_task_ctx - Memset task context to 0 while preserving +- * validation bytes. ++ * qed_memset_task_ctx(): Memset task context to 0 while preserving ++ * validation bytes. + * +- * @param p_ctx_mem - pointer to context memory. +- * @param ctx_size - size to initialzie. +- * @param ctx_type - context type. ++ * @p_ctx_mem: Pointer to context memory. ++ * @ctx_size: size to initialzie. ++ * @ctx_type: context type. ++ * ++ * Return: Void. + */ + void qed_memset_task_ctx(void *p_ctx_mem, u32 ctx_size, u8 ctx_type); + + #define NUM_STORMS 6 + + /** +- * @brief qed_set_rdma_error_level - Sets the RDMA assert level. +- * If the severity of the error will be +- * above the level, the FW will assert. +- * @param p_hwfn - HW device data +- * @param p_ptt - ptt window used for writing the registers +- * @param assert_level - An array of assert levels for each storm. ++ * qed_set_rdma_error_level(): Sets the RDMA assert level. ++ * If the severity of the error will be ++ * above the level, the FW will assert. ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @assert_level: An array of assert levels for each storm. + * ++ * Return: Void. + */ + void qed_set_rdma_error_level(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u8 assert_level[NUM_STORMS]); + /** +- * @brief qed_fw_overlay_mem_alloc - Allocates and fills the FW overlay memory. ++ * qed_fw_overlay_mem_alloc(): Allocates and fills the FW overlay memory. + * +- * @param p_hwfn - HW device data +- * @param fw_overlay_in_buf - the input FW overlay buffer. +- * @param buf_size - the size of the input FW overlay buffer in bytes. +- * must be aligned to dwords. +- * @param fw_overlay_out_mem - OUT: a pointer to the allocated overlays memory. ++ * @p_hwfn: HW device data. ++ * @fw_overlay_in_buf: The input FW overlay buffer. ++ * @buf_size_in_bytes: The size of the input FW overlay buffer in bytes. ++ * must be aligned to dwords. + * +- * @return a pointer to the allocated overlays memory, ++ * Return: A pointer to the allocated overlays memory, + * or NULL in case of failures. + */ + struct phys_mem_desc * + qed_fw_overlay_mem_alloc(struct qed_hwfn *p_hwfn, +- const u32 * const fw_overlay_in_buf, ++ const u32 *const fw_overlay_in_buf, + u32 buf_size_in_bytes); + + /** +- * @brief qed_fw_overlay_init_ram - Initializes the FW overlay RAM. ++ * qed_fw_overlay_init_ram(): Initializes the FW overlay RAM. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: Ptt window used for writing the registers. ++ * @fw_overlay_mem: the allocated FW overlay memory. + * +- * @param p_hwfn - HW device data. +- * @param p_ptt - ptt window used for writing the registers. +- * @param fw_overlay_mem - the allocated FW overlay memory. ++ * Return: Void. + */ + void qed_fw_overlay_init_ram(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + struct phys_mem_desc *fw_overlay_mem); + + /** +- * @brief qed_fw_overlay_mem_free - Frees the FW overlay memory. ++ * qed_fw_overlay_mem_free(): Frees the FW overlay memory. ++ * ++ * @p_hwfn: HW device data. ++ * @fw_overlay_mem: The allocated FW overlay memory to free. + * +- * @param p_hwfn - HW device data. +- * @param fw_overlay_mem - the allocated FW overlay memory to free. ++ * Return: Void. + */ + void qed_fw_overlay_mem_free(struct qed_hwfn *p_hwfn, + struct phys_mem_desc *fw_overlay_mem); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_hw.h b/drivers/net/ethernet/qlogic/qed/qed_hw.h +index 2734f49956f76..e535983ce21bb 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_hw.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_hw.h +@@ -53,85 +53,94 @@ enum _dmae_cmd_crc_mask { + #define DMAE_MAX_CLIENTS 32 + + /** +- * @brief qed_gtt_init - Initialize GTT windows ++ * qed_gtt_init(): Initialize GTT windows. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_gtt_init(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ptt_invalidate - Forces all ptt entries to be re-configured ++ * qed_ptt_invalidate(): Forces all ptt entries to be re-configured ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_ptt_invalidate(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ptt_pool_alloc - Allocate and initialize PTT pool ++ * qed_ptt_pool_alloc(): Allocate and initialize PTT pool. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return struct _qed_status - success (0), negative - error. ++ * Return: struct _qed_status - success (0), negative - error. + */ + int qed_ptt_pool_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ptt_pool_free - ++ * qed_ptt_pool_free(): Free PTT pool. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_ptt_pool_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ptt_get_hw_addr - Get PTT's GRC/HW address ++ * qed_ptt_get_hw_addr(): Get PTT's GRC/HW address. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt + * +- * @return u32 ++ * Return: u32. + */ + u32 qed_ptt_get_hw_addr(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief qed_ptt_get_bar_addr - Get PPT's external BAR address ++ * qed_ptt_get_bar_addr(): Get PPT's external BAR address. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_ptt: P_ptt + * +- * @return u32 ++ * Return: u32. + */ + u32 qed_ptt_get_bar_addr(struct qed_ptt *p_ptt); + + /** +- * @brief qed_ptt_set_win - Set PTT Window's GRC BAR address ++ * qed_ptt_set_win(): Set PTT Window's GRC BAR address + * +- * @param p_hwfn +- * @param new_hw_addr +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @new_hw_addr: New HW address. ++ * @p_ptt: P_Ptt ++ * ++ * Return: Void. + */ + void qed_ptt_set_win(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 new_hw_addr); + + /** +- * @brief qed_get_reserved_ptt - Get a specific reserved PTT ++ * qed_get_reserved_ptt(): Get a specific reserved PTT. + * +- * @param p_hwfn +- * @param ptt_idx ++ * @p_hwfn: HW device data. ++ * @ptt_idx: Ptt Index. + * +- * @return struct qed_ptt * ++ * Return: struct qed_ptt *. + */ + struct qed_ptt *qed_get_reserved_ptt(struct qed_hwfn *p_hwfn, + enum reserved_ptts ptt_idx); + + /** +- * @brief qed_wr - Write value to BAR using the given ptt ++ * qed_wr(): Write value to BAR using the given ptt. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @val: Val. ++ * @hw_addr: HW address + * +- * @param p_hwfn +- * @param p_ptt +- * @param val +- * @param hw_addr ++ * Return: Void. + */ + void qed_wr(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -139,26 +148,28 @@ void qed_wr(struct qed_hwfn *p_hwfn, + u32 val); + + /** +- * @brief qed_rd - Read value from BAR using the given ptt ++ * qed_rd(): Read value from BAR using the given ptt. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @hw_addr: HW address + * +- * @param p_hwfn +- * @param p_ptt +- * @param val +- * @param hw_addr ++ * Return: Void. + */ + u32 qed_rd(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 hw_addr); + + /** +- * @brief qed_memcpy_from - copy n bytes from BAR using the given +- * ptt +- * +- * @param p_hwfn +- * @param p_ptt +- * @param dest +- * @param hw_addr +- * @param n ++ * qed_memcpy_from(): Copy n bytes from BAR using the given ptt. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @dest: Destination. ++ * @hw_addr: HW address. ++ * @n: N ++ * ++ * Return: Void. + */ + void qed_memcpy_from(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -167,14 +178,15 @@ void qed_memcpy_from(struct qed_hwfn *p_hwfn, + size_t n); + + /** +- * @brief qed_memcpy_to - copy n bytes to BAR using the given +- * ptt +- * +- * @param p_hwfn +- * @param p_ptt +- * @param hw_addr +- * @param src +- * @param n ++ * qed_memcpy_to(): Copy n bytes to BAR using the given ptt ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @hw_addr: HW address. ++ * @src: Source. ++ * @n: N ++ * ++ * Return: Void. + */ + void qed_memcpy_to(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -182,83 +194,97 @@ void qed_memcpy_to(struct qed_hwfn *p_hwfn, + void *src, + size_t n); + /** +- * @brief qed_fid_pretend - pretend to another function when +- * accessing the ptt window. There is no way to unpretend +- * a function. The only way to cancel a pretend is to +- * pretend back to the original function. +- * +- * @param p_hwfn +- * @param p_ptt +- * @param fid - fid field of pxp_pretend structure. Can contain +- * either pf / vf, port/path fields are don't care. ++ * qed_fid_pretend(): pretend to another function when ++ * accessing the ptt window. There is no way to unpretend ++ * a function. The only way to cancel a pretend is to ++ * pretend back to the original function. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @fid: fid field of pxp_pretend structure. Can contain ++ * either pf / vf, port/path fields are don't care. ++ * ++ * Return: Void. + */ + void qed_fid_pretend(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u16 fid); + + /** +- * @brief qed_port_pretend - pretend to another port when +- * accessing the ptt window ++ * qed_port_pretend(): Pretend to another port when accessing the ptt window + * +- * @param p_hwfn +- * @param p_ptt +- * @param port_id - the port to pretend to ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @port_id: The port to pretend to ++ * ++ * Return: Void. + */ + void qed_port_pretend(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u8 port_id); + + /** +- * @brief qed_port_unpretend - cancel any previously set port +- * pretend ++ * qed_port_unpretend(): Cancel any previously set port pretend ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param p_hwfn +- * @param p_ptt ++ * Return: Void. + */ + void qed_port_unpretend(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief qed_port_fid_pretend - pretend to another port and another function +- * when accessing the ptt window ++ * qed_port_fid_pretend(): Pretend to another port and another function ++ * when accessing the ptt window ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @port_id: The port to pretend to ++ * @fid: fid field of pxp_pretend structure. Can contain either pf / vf. + * +- * @param p_hwfn +- * @param p_ptt +- * @param port_id - the port to pretend to +- * @param fid - fid field of pxp_pretend structure. Can contain either pf / vf. ++ * Return: Void. + */ + void qed_port_fid_pretend(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u8 port_id, u16 fid); + + /** +- * @brief qed_vfid_to_concrete - build a concrete FID for a +- * given VF ID ++ * qed_vfid_to_concrete(): Build a concrete FID for a given VF ID + * +- * @param p_hwfn +- * @param p_ptt +- * @param vfid ++ * @p_hwfn: HW device data. ++ * @vfid: VFID. ++ * ++ * Return: Void. + */ + u32 qed_vfid_to_concrete(struct qed_hwfn *p_hwfn, u8 vfid); + + /** +- * @brief qed_dmae_idx_to_go_cmd - map the idx to dmae cmd +- * this is declared here since other files will require it. +- * @param idx ++ * qed_dmae_idx_to_go_cmd(): Map the idx to dmae cmd ++ * this is declared here since other files will require it. ++ * ++ * @idx: Index ++ * ++ * Return: Void. + */ + u32 qed_dmae_idx_to_go_cmd(u8 idx); + + /** +- * @brief qed_dmae_info_alloc - Init the dmae_info structure +- * which is part of p_hwfn. +- * @param p_hwfn ++ * qed_dmae_info_alloc(): Init the dmae_info structure ++ * which is part of p_hwfn. ++ * ++ * @p_hwfn: HW device data. ++ * ++ * Return: Int. + */ + int qed_dmae_info_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_dmae_info_free - Free the dmae_info structure +- * which is part of p_hwfn ++ * qed_dmae_info_free(): Free the dmae_info structure ++ * which is part of p_hwfn. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_dmae_info_free(struct qed_hwfn *p_hwfn); + +@@ -292,14 +318,16 @@ int qed_dmae_sanity(struct qed_hwfn *p_hwfn, + #define QED_HW_ERR_MAX_STR_SIZE 256 + + /** +- * @brief qed_hw_err_notify - Notify upper layer driver and management FW +- * about a HW error. +- * +- * @param p_hwfn +- * @param p_ptt +- * @param err_type +- * @param fmt - debug data buffer to send to the MFW +- * @param ... - buffer format args ++ * qed_hw_err_notify(): Notify upper layer driver and management FW ++ * about a HW error. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @err_type: Err Type. ++ * @fmt: Debug data buffer to send to the MFW ++ * @...: buffer format args ++ * ++ * Return void. + */ + void __printf(4, 5) __cold qed_hw_err_notify(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +diff --git a/drivers/net/ethernet/qlogic/qed/qed_init_ops.h b/drivers/net/ethernet/qlogic/qed/qed_init_ops.h +index a573c89219820..1dbc460c9eec8 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_init_ops.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_init_ops.h +@@ -12,23 +12,24 @@ + #include "qed.h" + + /** +- * @brief qed_init_iro_array - init iro_arr. ++ * qed_init_iro_array(): init iro_arr. + * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Void. + */ + void qed_init_iro_array(struct qed_dev *cdev); + + /** +- * @brief qed_init_run - Run the init-sequence. ++ * qed_init_run(): Run the init-sequence. + * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @phase: Phase. ++ * @phase_id: Phase ID. ++ * @modes: Mode. + * +- * @param p_hwfn +- * @param p_ptt +- * @param phase +- * @param phase_id +- * @param modes +- * @return _qed_status_t ++ * Return: _qed_status_t + */ + int qed_init_run(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -37,30 +38,31 @@ int qed_init_run(struct qed_hwfn *p_hwfn, + int modes); + + /** +- * @brief qed_init_hwfn_allocate - Allocate RT array, Store 'values' ptrs. ++ * qed_init_alloc(): Allocate RT array, Store 'values' ptrs. + * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn +- * +- * @return _qed_status_t ++ * Return: _qed_status_t. + */ + int qed_init_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_init_hwfn_deallocate ++ * qed_init_free(): Init HW function deallocate. + * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_init_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_init_store_rt_reg - Store a configuration value in the RT array. ++ * qed_init_store_rt_reg(): Store a configuration value in the RT array. + * ++ * @p_hwfn: HW device data. ++ * @rt_offset: RT offset. ++ * @val: Val. + * +- * @param p_hwfn +- * @param rt_offset +- * @param val ++ * Return: Void. + */ + void qed_init_store_rt_reg(struct qed_hwfn *p_hwfn, + u32 rt_offset, +@@ -72,15 +74,6 @@ void qed_init_store_rt_reg(struct qed_hwfn *p_hwfn, + #define OVERWRITE_RT_REG(hwfn, offset, val) \ + qed_init_store_rt_reg(hwfn, offset, val) + +-/** +- * @brief +- * +- * +- * @param p_hwfn +- * @param rt_offset +- * @param val +- * @param size +- */ + void qed_init_store_rt_agg(struct qed_hwfn *p_hwfn, + u32 rt_offset, + u32 *val, +@@ -90,11 +83,12 @@ void qed_init_store_rt_agg(struct qed_hwfn *p_hwfn, + qed_init_store_rt_agg(hwfn, offset, (u32 *)&val, sizeof(val)) + + /** +- * @brief +- * Initialize GTT global windows and set admin window +- * related params of GTT/PTT to default values. ++ * qed_gtt_init(): Initialize GTT global windows and set admin window ++ * related params of GTT/PTT to default values. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return Void. + */ + void qed_gtt_init(struct qed_hwfn *p_hwfn); + #endif +diff --git a/drivers/net/ethernet/qlogic/qed/qed_int.h b/drivers/net/ethernet/qlogic/qed/qed_int.h +index c5550e96bbe1f..eb8e0f4242d79 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_int.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_int.h +@@ -53,51 +53,54 @@ enum qed_coalescing_fsm { + }; + + /** +- * @brief qed_int_igu_enable_int - enable device interrupts ++ * qed_int_igu_enable_int(): Enable device interrupts. + * +- * @param p_hwfn +- * @param p_ptt +- * @param int_mode - interrupt mode to use ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @int_mode: Interrupt mode to use. ++ * ++ * Return: Void. + */ + void qed_int_igu_enable_int(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + enum qed_int_mode int_mode); + + /** +- * @brief qed_int_igu_disable_int - disable device interrupts ++ * qed_int_igu_disable_int(): Disable device interrupts. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param p_hwfn +- * @param p_ptt ++ * Return: Void. + */ + void qed_int_igu_disable_int(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief qed_int_igu_read_sisr_reg - Reads the single isr multiple dpc +- * register from igu. ++ * qed_int_igu_read_sisr_reg(): Reads the single isr multiple dpc ++ * register from igu. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return u64 ++ * Return: u64. + */ + u64 qed_int_igu_read_sisr_reg(struct qed_hwfn *p_hwfn); + + #define QED_SP_SB_ID 0xffff + /** +- * @brief qed_int_sb_init - Initializes the sb_info structure. ++ * qed_int_sb_init(): Initializes the sb_info structure. + * +- * once the structure is initialized it can be passed to sb related functions. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @sb_info: points to an uninitialized (but allocated) sb_info structure ++ * @sb_virt_addr: SB Virtual address. ++ * @sb_phy_addr: SB Physial address. ++ * @sb_id: the sb_id to be used (zero based in driver) ++ * should use QED_SP_SB_ID for SP Status block + * +- * @param p_hwfn +- * @param p_ptt +- * @param sb_info points to an uninitialized (but +- * allocated) sb_info structure +- * @param sb_virt_addr +- * @param sb_phy_addr +- * @param sb_id the sb_id to be used (zero based in driver) +- * should use QED_SP_SB_ID for SP Status block ++ * Return: int. + * +- * @return int ++ * Once the structure is initialized it can be passed to sb related functions. + */ + int qed_int_sb_init(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -106,82 +109,91 @@ int qed_int_sb_init(struct qed_hwfn *p_hwfn, + dma_addr_t sb_phy_addr, + u16 sb_id); + /** +- * @brief qed_int_sb_setup - Setup the sb. ++ * qed_int_sb_setup(): Setup the sb. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @sb_info: Initialized sb_info structure. + * +- * @param p_hwfn +- * @param p_ptt +- * @param sb_info initialized sb_info structure ++ * Return: Void. + */ + void qed_int_sb_setup(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + struct qed_sb_info *sb_info); + + /** +- * @brief qed_int_sb_release - releases the sb_info structure. ++ * qed_int_sb_release(): Releases the sb_info structure. + * +- * once the structure is released, it's memory can be freed ++ * @p_hwfn: HW device data. ++ * @sb_info: Points to an allocated sb_info structure. ++ * @sb_id: The sb_id to be used (zero based in driver) ++ * should never be equal to QED_SP_SB_ID ++ * (SP Status block). + * +- * @param p_hwfn +- * @param sb_info points to an allocated sb_info structure +- * @param sb_id the sb_id to be used (zero based in driver) +- * should never be equal to QED_SP_SB_ID +- * (SP Status block) ++ * Return: int. + * +- * @return int ++ * Once the structure is released, it's memory can be freed. + */ + int qed_int_sb_release(struct qed_hwfn *p_hwfn, + struct qed_sb_info *sb_info, + u16 sb_id); + + /** +- * @brief qed_int_sp_dpc - To be called when an interrupt is received on the +- * default status block. ++ * qed_int_sp_dpc(): To be called when an interrupt is received on the ++ * default status block. + * +- * @param p_hwfn - pointer to hwfn ++ * @t: Tasklet. ++ * ++ * Return: Void. + * + */ + void qed_int_sp_dpc(struct tasklet_struct *t); + + /** +- * @brief qed_int_get_num_sbs - get the number of status +- * blocks configured for this funciton in the igu. ++ * qed_int_get_num_sbs(): Get the number of status blocks configured ++ * for this funciton in the igu. + * +- * @param p_hwfn +- * @param p_sb_cnt_info ++ * @p_hwfn: HW device data. ++ * @p_sb_cnt_info: Pointer to SB count info. + * +- * @return int - number of status blocks configured ++ * Return: Void. + */ + void qed_int_get_num_sbs(struct qed_hwfn *p_hwfn, + struct qed_sb_cnt_info *p_sb_cnt_info); + + /** +- * @brief qed_int_disable_post_isr_release - performs the cleanup post ISR ++ * qed_int_disable_post_isr_release(): Performs the cleanup post ISR + * release. The API need to be called after releasing all slowpath IRQs + * of the device. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * ++ * Return: Void. + */ + void qed_int_disable_post_isr_release(struct qed_dev *cdev); + + /** +- * @brief qed_int_attn_clr_enable - sets whether the general behavior is ++ * qed_int_attn_clr_enable: Sets whether the general behavior is + * preventing attentions from being reasserted, or following the + * attributes of the specific attention. + * +- * @param cdev +- * @param clr_enable ++ * @cdev: Qed dev pointer. ++ * @clr_enable: Clear enable ++ * ++ * Return: Void. + * + */ + void qed_int_attn_clr_enable(struct qed_dev *cdev, bool clr_enable); + + /** +- * @brief - Doorbell Recovery handler. ++ * qed_db_rec_handler(): Doorbell Recovery handler. + * Run doorbell recovery in case of PF overflow (and flush DORQ if + * needed). + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Int. + */ + int qed_db_rec_handler(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + +@@ -223,30 +235,34 @@ struct qed_igu_info { + }; + + /** +- * @brief - Make sure the IGU CAM reflects the resources provided by MFW ++ * qed_int_igu_reset_cam(): Make sure the IGU CAM reflects the resources ++ * provided by MFW. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param p_hwfn +- * @param p_ptt ++ * Return: Void. + */ + int qed_int_igu_reset_cam(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Translate the weakly-defined client sb-id into an IGU sb-id ++ * qed_get_igu_sb_id(): Translate the weakly-defined client sb-id into ++ * an IGU sb-id + * +- * @param p_hwfn +- * @param sb_id - user provided sb_id ++ * @p_hwfn: HW device data. ++ * @sb_id: user provided sb_id. + * +- * @return an index inside IGU CAM where the SB resides ++ * Return: An index inside IGU CAM where the SB resides. + */ + u16 qed_get_igu_sb_id(struct qed_hwfn *p_hwfn, u16 sb_id); + + /** +- * @brief return a pointer to an unused valid SB ++ * qed_get_igu_free_sb(): Return a pointer to an unused valid SB + * +- * @param p_hwfn +- * @param b_is_pf - true iff we want a SB belonging to a PF ++ * @p_hwfn: HW device data. ++ * @b_is_pf: True iff we want a SB belonging to a PF. + * +- * @return point to an igu_block, NULL if none is available ++ * Return: Point to an igu_block, NULL if none is available. + */ + struct qed_igu_block *qed_get_igu_free_sb(struct qed_hwfn *p_hwfn, + bool b_is_pf); +@@ -259,15 +275,15 @@ void qed_int_igu_init_pure_rt(struct qed_hwfn *p_hwfn, + void qed_int_igu_init_rt(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_int_igu_read_cam - Reads the IGU CAM. ++ * qed_int_igu_read_cam(): Reads the IGU CAM. + * This function needs to be called during hardware + * prepare. It reads the info from igu cam to know which + * status block is the default / base status block etc. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int ++ * Return: Int. + */ + int qed_int_igu_read_cam(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); +@@ -275,24 +291,22 @@ int qed_int_igu_read_cam(struct qed_hwfn *p_hwfn, + typedef int (*qed_int_comp_cb_t)(struct qed_hwfn *p_hwfn, + void *cookie); + /** +- * @brief qed_int_register_cb - Register callback func for +- * slowhwfn statusblock. +- * +- * Every protocol that uses the slowhwfn status block +- * should register a callback function that will be called +- * once there is an update of the sp status block. +- * +- * @param p_hwfn +- * @param comp_cb - function to be called when there is an +- * interrupt on the sp sb +- * +- * @param cookie - passed to the callback function +- * @param sb_idx - OUT parameter which gives the chosen index +- * for this protocol. +- * @param p_fw_cons - pointer to the actual address of the +- * consumer for this protocol. +- * +- * @return int ++ * qed_int_register_cb(): Register callback func for slowhwfn statusblock. ++ * ++ * @p_hwfn: HW device data. ++ * @comp_cb: Function to be called when there is an ++ * interrupt on the sp sb ++ * @cookie: Passed to the callback function ++ * @sb_idx: (OUT) parameter which gives the chosen index ++ * for this protocol. ++ * @p_fw_cons: Pointer to the actual address of the ++ * consumer for this protocol. ++ * ++ * Return: Int. ++ * ++ * Every protocol that uses the slowhwfn status block ++ * should register a callback function that will be called ++ * once there is an update of the sp status block. + */ + int qed_int_register_cb(struct qed_hwfn *p_hwfn, + qed_int_comp_cb_t comp_cb, +@@ -301,37 +315,40 @@ int qed_int_register_cb(struct qed_hwfn *p_hwfn, + __le16 **p_fw_cons); + + /** +- * @brief qed_int_unregister_cb - Unregisters callback +- * function from sp sb. +- * Partner of qed_int_register_cb -> should be called +- * when no longer required. ++ * qed_int_unregister_cb(): Unregisters callback function from sp sb. ++ * ++ * @p_hwfn: HW device data. ++ * @pi: Producer Index. + * +- * @param p_hwfn +- * @param pi ++ * Return: Int. + * +- * @return int ++ * Partner of qed_int_register_cb -> should be called ++ * when no longer required. + */ + int qed_int_unregister_cb(struct qed_hwfn *p_hwfn, + u8 pi); + + /** +- * @brief qed_int_get_sp_sb_id - Get the slowhwfn sb id. ++ * qed_int_get_sp_sb_id(): Get the slowhwfn sb id. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return u16 ++ * Return: u16. + */ + u16 qed_int_get_sp_sb_id(struct qed_hwfn *p_hwfn); + + /** +- * @brief Status block cleanup. Should be called for each status +- * block that will be used -> both PF / VF +- * +- * @param p_hwfn +- * @param p_ptt +- * @param igu_sb_id - igu status block id +- * @param opaque - opaque fid of the sb owner. +- * @param b_set - set(1) / clear(0) ++ * qed_int_igu_init_pure_rt_single(): Status block cleanup. ++ * Should be called for each status ++ * block that will be used -> both PF / VF. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @igu_sb_id: IGU status block id. ++ * @opaque: Opaque fid of the sb owner. ++ * @b_set: Set(1) / Clear(0). ++ * ++ * Return: Void. + */ + void qed_int_igu_init_pure_rt_single(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -340,15 +357,16 @@ void qed_int_igu_init_pure_rt_single(struct qed_hwfn *p_hwfn, + bool b_set); + + /** +- * @brief qed_int_cau_conf - configure cau for a given status +- * block +- * +- * @param p_hwfn +- * @param ptt +- * @param sb_phys +- * @param igu_sb_id +- * @param vf_number +- * @param vf_valid ++ * qed_int_cau_conf_sb(): Configure cau for a given status block. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @sb_phys: SB Physical. ++ * @igu_sb_id: IGU status block id. ++ * @vf_number: VF number ++ * @vf_valid: VF valid or not. ++ * ++ * Return: Void. + */ + void qed_int_cau_conf_sb(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -358,52 +376,58 @@ void qed_int_cau_conf_sb(struct qed_hwfn *p_hwfn, + u8 vf_valid); + + /** +- * @brief qed_int_alloc ++ * qed_int_alloc(): QED interrupt alloc. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int ++ * Return: Int. + */ + int qed_int_alloc(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief qed_int_free ++ * qed_int_free(): QED interrupt free. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_int_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_int_setup ++ * qed_int_setup(): QED interrupt setup. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Void. + */ + void qed_int_setup(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief - Enable Interrupt & Attention for hw function ++ * qed_int_igu_enable(): Enable Interrupt & Attention for hw function. + * +- * @param p_hwfn +- * @param p_ptt +- * @param int_mode ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @int_mode: Interrut mode + * +- * @return int ++ * Return: Int. + */ + int qed_int_igu_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + enum qed_int_mode int_mode); + + /** +- * @brief - Initialize CAU status block entry ++ * qed_init_cau_sb_entry(): Initialize CAU status block entry. ++ * ++ * @p_hwfn: HW device data. ++ * @p_sb_entry: Pointer SB entry. ++ * @pf_id: PF number ++ * @vf_number: VF number ++ * @vf_valid: VF valid or not. + * +- * @param p_hwfn +- * @param p_sb_entry +- * @param pf_id +- * @param vf_number +- * @param vf_valid ++ * Return: Void. + */ + void qed_init_cau_sb_entry(struct qed_hwfn *p_hwfn, + struct cau_sb_entry *p_sb_entry, +diff --git a/drivers/net/ethernet/qlogic/qed/qed_iscsi.h b/drivers/net/ethernet/qlogic/qed/qed_iscsi.h +index dab7a5d09f874..dec2b00259d42 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_iscsi.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_iscsi.h +@@ -34,10 +34,13 @@ void qed_iscsi_setup(struct qed_hwfn *p_hwfn); + void qed_iscsi_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief - Fills provided statistics struct with statistics. ++ * qed_get_protocol_stats_iscsi(): Fills provided statistics ++ * struct with statistics. + * +- * @param cdev +- * @param stats - points to struct that will be filled with statistics. ++ * @cdev: Qed dev pointer. ++ * @stats: Points to struct that will be filled with statistics. ++ * ++ * Return: Void. + */ + void qed_get_protocol_stats_iscsi(struct qed_dev *cdev, + struct qed_mcp_iscsi_stats *stats); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_l2.h b/drivers/net/ethernet/qlogic/qed/qed_l2.h +index 8eceeebb1a7be..2ab7f3f0cf6c9 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_l2.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_l2.h +@@ -92,18 +92,18 @@ struct qed_filter_mcast { + }; + + /** +- * @brief qed_eth_rx_queue_stop - This ramrod closes an Rx queue ++ * qed_eth_rx_queue_stop(): This ramrod closes an Rx queue. + * +- * @param p_hwfn +- * @param p_rxq Handler of queue to close +- * @param eq_completion_only If True completion will be on +- * EQe, if False completion will be +- * on EQe if p_hwfn opaque +- * different from the RXQ opaque +- * otherwise on CQe. +- * @param cqe_completion If True completion will be +- * receive on CQe. +- * @return int ++ * @p_hwfn: HW device data. ++ * @p_rxq: Handler of queue to close ++ * @eq_completion_only: If True completion will be on ++ * EQe, if False completion will be ++ * on EQe if p_hwfn opaque ++ * different from the RXQ opaque ++ * otherwise on CQe. ++ * @cqe_completion: If True completion will be receive on CQe. ++ * ++ * Return: Int. + */ + int + qed_eth_rx_queue_stop(struct qed_hwfn *p_hwfn, +@@ -111,12 +111,12 @@ qed_eth_rx_queue_stop(struct qed_hwfn *p_hwfn, + bool eq_completion_only, bool cqe_completion); + + /** +- * @brief qed_eth_tx_queue_stop - closes a Tx queue ++ * qed_eth_tx_queue_stop(): Closes a Tx queue. + * +- * @param p_hwfn +- * @param p_txq - handle to Tx queue needed to be closed ++ * @p_hwfn: HW device data. ++ * @p_txq: handle to Tx queue needed to be closed. + * +- * @return int ++ * Return: Int. + */ + int qed_eth_tx_queue_stop(struct qed_hwfn *p_hwfn, void *p_txq); + +@@ -205,16 +205,15 @@ int qed_sp_vport_update(struct qed_hwfn *p_hwfn, + struct qed_spq_comp_cb *p_comp_data); + + /** +- * @brief qed_sp_vport_stop - +- * +- * This ramrod closes a VPort after all its RX and TX queues are terminated. +- * An Assert is generated if any queues are left open. ++ * qed_sp_vport_stop: This ramrod closes a VPort after all its ++ * RX and TX queues are terminated. ++ * An Assert is generated if any queues are left open. + * +- * @param p_hwfn +- * @param opaque_fid +- * @param vport_id VPort ID ++ * @p_hwfn: HW device data. ++ * @opaque_fid: Opaque FID ++ * @vport_id: VPort ID. + * +- * @return int ++ * Return: Int. + */ + int qed_sp_vport_stop(struct qed_hwfn *p_hwfn, u16 opaque_fid, u8 vport_id); + +@@ -225,22 +224,21 @@ int qed_sp_eth_filter_ucast(struct qed_hwfn *p_hwfn, + struct qed_spq_comp_cb *p_comp_data); + + /** +- * @brief qed_sp_rx_eth_queues_update - +- * +- * This ramrod updates an RX queue. It is used for setting the active state +- * of the queue and updating the TPA and SGE parameters. ++ * qed_sp_eth_rx_queues_update(): This ramrod updates an RX queue. ++ * It is used for setting the active state ++ * of the queue and updating the TPA and ++ * SGE parameters. ++ * @p_hwfn: HW device data. ++ * @pp_rxq_handlers: An array of queue handlers to be updated. ++ * @num_rxqs: number of queues to update. ++ * @complete_cqe_flg: Post completion to the CQE Ring if set. ++ * @complete_event_flg: Post completion to the Event Ring if set. ++ * @comp_mode: Comp mode. ++ * @p_comp_data: Pointer Comp data. + * +- * @note At the moment - only used by non-linux VFs. ++ * Return: Int. + * +- * @param p_hwfn +- * @param pp_rxq_handlers An array of queue handlers to be updated. +- * @param num_rxqs number of queues to update. +- * @param complete_cqe_flg Post completion to the CQE Ring if set +- * @param complete_event_flg Post completion to the Event Ring if set +- * @param comp_mode +- * @param p_comp_data +- * +- * @return int ++ * Note At the moment - only used by non-linux VFs. + */ + + int +@@ -257,30 +255,32 @@ void qed_get_vport_stats(struct qed_dev *cdev, struct qed_eth_stats *stats); + void qed_reset_vport_stats(struct qed_dev *cdev); + + /** +- * *@brief qed_arfs_mode_configure - +- * +- **Enable or disable rfs mode. It must accept atleast one of tcp or udp true +- **and atleast one of ipv4 or ipv6 true to enable rfs mode. ++ * qed_arfs_mode_configure(): Enable or disable rfs mode. ++ * It must accept at least one of tcp or udp true ++ * and at least one of ipv4 or ipv6 true to enable ++ * rfs mode. + * +- **@param p_hwfn +- **@param p_ptt +- **@param p_cfg_params - arfs mode configuration parameters. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_cfg_params: arfs mode configuration parameters. + * ++ * Return. Void. + */ + void qed_arfs_mode_configure(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + struct qed_arfs_config_params *p_cfg_params); + + /** +- * @brief - qed_configure_rfs_ntuple_filter ++ * qed_configure_rfs_ntuple_filter(): This ramrod should be used to add ++ * or remove arfs hw filter + * +- * This ramrod should be used to add or remove arfs hw filter ++ * @p_hwfn: HW device data. ++ * @p_cb: Used for QED_SPQ_MODE_CB,where client would initialize ++ * it with cookie and callback function address, if not ++ * using this mode then client must pass NULL. ++ * @p_params: Pointer to params. + * +- * @params p_hwfn +- * @params p_cb - Used for QED_SPQ_MODE_CB,where client would initialize +- * it with cookie and callback function address, if not +- * using this mode then client must pass NULL. +- * @params p_params ++ * Return: Void. + */ + int + qed_configure_rfs_ntuple_filter(struct qed_hwfn *p_hwfn, +@@ -374,16 +374,17 @@ qed_sp_eth_vport_start(struct qed_hwfn *p_hwfn, + struct qed_sp_vport_start_params *p_params); + + /** +- * @brief - Starts an Rx queue, when queue_cid is already prepared ++ * qed_eth_rxq_start_ramrod(): Starts an Rx queue, when queue_cid is ++ * already prepared + * +- * @param p_hwfn +- * @param p_cid +- * @param bd_max_bytes +- * @param bd_chain_phys_addr +- * @param cqe_pbl_addr +- * @param cqe_pbl_size ++ * @p_hwfn: HW device data. ++ * @p_cid: Pointer CID. ++ * @bd_max_bytes: Max bytes. ++ * @bd_chain_phys_addr: Chain physcial address. ++ * @cqe_pbl_addr: PBL address. ++ * @cqe_pbl_size: PBL size. + * +- * @return int ++ * Return: Int. + */ + int + qed_eth_rxq_start_ramrod(struct qed_hwfn *p_hwfn, +@@ -393,15 +394,16 @@ qed_eth_rxq_start_ramrod(struct qed_hwfn *p_hwfn, + dma_addr_t cqe_pbl_addr, u16 cqe_pbl_size); + + /** +- * @brief - Starts a Tx queue, where queue_cid is already prepared ++ * qed_eth_txq_start_ramrod(): Starts a Tx queue, where queue_cid is ++ * already prepared + * +- * @param p_hwfn +- * @param p_cid +- * @param pbl_addr +- * @param pbl_size +- * @param p_pq_params - parameters for choosing the PQ for this Tx queue ++ * @p_hwfn: HW device data. ++ * @p_cid: Pointer CID. ++ * @pbl_addr: PBL address. ++ * @pbl_size: PBL size. ++ * @pq_id: Parameters for choosing the PQ for this Tx queue. + * +- * @return int ++ * Return: Int. + */ + int + qed_eth_txq_start_ramrod(struct qed_hwfn *p_hwfn, +diff --git a/drivers/net/ethernet/qlogic/qed/qed_ll2.h b/drivers/net/ethernet/qlogic/qed/qed_ll2.h +index df88d00053a29..f80f7739ff8d6 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_ll2.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_ll2.h +@@ -119,41 +119,41 @@ struct qed_ll2_info { + extern const struct qed_ll2_ops qed_ll2_ops_pass; + + /** +- * @brief qed_ll2_acquire_connection - allocate resources, +- * starts rx & tx (if relevant) queues pair. Provides +- * connecion handler as output parameter. ++ * qed_ll2_acquire_connection(): Allocate resources, ++ * starts rx & tx (if relevant) queues pair. ++ * Provides connecion handler as output ++ * parameter. + * ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @data: Describes connection parameters. + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param data - describes connection parameters +- * @return int ++ * Return: Int. + */ + int qed_ll2_acquire_connection(void *cxt, struct qed_ll2_acquire_data *data); + + /** +- * @brief qed_ll2_establish_connection - start previously +- * allocated LL2 queues pair ++ * qed_ll2_establish_connection(): start previously allocated LL2 queues pair + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param p_ptt +- * @param connection_handle LL2 connection's handle obtained from +- * qed_ll2_require_connection ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_establish_connection(void *cxt, u8 connection_handle); + + /** +- * @brief qed_ll2_post_rx_buffers - submit buffers to LL2 Rx queue. ++ * qed_ll2_post_rx_buffer(): Submit buffers to LL2 Rx queue. + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle LL2 connection's handle obtained from +- * qed_ll2_require_connection +- * @param addr rx (physical address) buffers to submit +- * @param cookie +- * @param notify_fw produce corresponding Rx BD immediately ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. ++ * @addr: RX (physical address) buffers to submit. ++ * @buf_len: Buffer Len. ++ * @cookie: Cookie. ++ * @notify_fw: Produce corresponding Rx BD immediately. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_post_rx_buffer(void *cxt, + u8 connection_handle, +@@ -161,15 +161,15 @@ int qed_ll2_post_rx_buffer(void *cxt, + u16 buf_len, void *cookie, u8 notify_fw); + + /** +- * @brief qed_ll2_prepare_tx_packet - request for start Tx BD +- * to prepare Tx packet submission to FW. ++ * qed_ll2_prepare_tx_packet(): Request for start Tx BD ++ * to prepare Tx packet submission to FW. + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle +- * @param pkt - info regarding the tx packet +- * @param notify_fw - issue doorbell to fw for this packet ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: Connection handle. ++ * @pkt: Info regarding the tx packet. ++ * @notify_fw: Issue doorbell to fw for this packet. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_prepare_tx_packet(void *cxt, + u8 connection_handle, +@@ -177,81 +177,83 @@ int qed_ll2_prepare_tx_packet(void *cxt, + bool notify_fw); + + /** +- * @brief qed_ll2_release_connection - releases resources +- * allocated for LL2 connection ++ * qed_ll2_release_connection(): Releases resources allocated for LL2 ++ * connection. + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle LL2 connection's handle obtained from +- * qed_ll2_require_connection ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. ++ * ++ * Return: Void. + */ + void qed_ll2_release_connection(void *cxt, u8 connection_handle); + + /** +- * @brief qed_ll2_set_fragment_of_tx_packet - provides fragments to fill +- * Tx BD of BDs requested by +- * qed_ll2_prepare_tx_packet ++ * qed_ll2_set_fragment_of_tx_packet(): Provides fragments to fill ++ * Tx BD of BDs requested by ++ * qed_ll2_prepare_tx_packet + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle LL2 connection's handle +- * obtained from +- * qed_ll2_require_connection +- * @param addr +- * @param nbytes ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. ++ * @addr: Address. ++ * @nbytes: Number of bytes. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_set_fragment_of_tx_packet(void *cxt, + u8 connection_handle, + dma_addr_t addr, u16 nbytes); + + /** +- * @brief qed_ll2_terminate_connection - stops Tx/Rx queues +- * ++ * qed_ll2_terminate_connection(): Stops Tx/Rx queues + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle LL2 connection's handle +- * obtained from +- * qed_ll2_require_connection ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_terminate_connection(void *cxt, u8 connection_handle); + + /** +- * @brief qed_ll2_get_stats - get LL2 queue's statistics +- * ++ * qed_ll2_get_stats(): Get LL2 queue's statistics + * +- * @param cxt - pointer to the hw-function [opaque to some] +- * @param connection_handle LL2 connection's handle obtained from +- * qed_ll2_require_connection +- * @param p_stats ++ * @cxt: Pointer to the hw-function [opaque to some]. ++ * @connection_handle: LL2 connection's handle obtained from ++ * qed_ll2_require_connection. ++ * @p_stats: Pointer Status. + * +- * @return 0 on success, failure otherwise ++ * Return: 0 on success, failure otherwise. + */ + int qed_ll2_get_stats(void *cxt, + u8 connection_handle, struct qed_ll2_stats *p_stats); + + /** +- * @brief qed_ll2_alloc - Allocates LL2 connections set ++ * qed_ll2_alloc(): Allocates LL2 connections set. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_ll2_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ll2_setup - Inits LL2 connections set ++ * qed_ll2_setup(): Inits LL2 connections set. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + * + */ + void qed_ll2_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_ll2_free - Releases LL2 connections set ++ * qed_ll2_free(): Releases LL2 connections set ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + * + */ + void qed_ll2_free(struct qed_hwfn *p_hwfn); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_mcp.h b/drivers/net/ethernet/qlogic/qed/qed_mcp.h +index 8edb450d0abfc..352b757183e8e 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_mcp.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_mcp.h +@@ -266,97 +266,97 @@ union qed_mfw_tlv_data { + #define QED_NVM_CFG_OPTION_ENTITY_SEL BIT(4) + + /** +- * @brief - returns the link params of the hw function ++ * qed_mcp_get_link_params(): Returns the link params of the hw function. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @returns pointer to link params ++ * Returns: Pointer to link params. + */ +-struct qed_mcp_link_params *qed_mcp_get_link_params(struct qed_hwfn *); ++struct qed_mcp_link_params *qed_mcp_get_link_params(struct qed_hwfn *p_hwfn); + + /** +- * @brief - return the link state of the hw function ++ * qed_mcp_get_link_state(): Return the link state of the hw function. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @returns pointer to link state ++ * Returns: Pointer to link state. + */ +-struct qed_mcp_link_state *qed_mcp_get_link_state(struct qed_hwfn *); ++struct qed_mcp_link_state *qed_mcp_get_link_state(struct qed_hwfn *p_hwfn); + + /** +- * @brief - return the link capabilities of the hw function ++ * qed_mcp_get_link_capabilities(): Return the link capabilities of the ++ * hw function. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @returns pointer to link capabilities ++ * Returns: Pointer to link capabilities. + */ + struct qed_mcp_link_capabilities + *qed_mcp_get_link_capabilities(struct qed_hwfn *p_hwfn); + + /** +- * @brief Request the MFW to set the the link according to 'link_input'. ++ * qed_mcp_set_link(): Request the MFW to set the link according ++ * to 'link_input'. + * +- * @param p_hwfn +- * @param p_ptt +- * @param b_up - raise link if `true'. Reset link if `false'. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @b_up: Raise link if `true'. Reset link if `false'. + * +- * @return int ++ * Return: Int. + */ + int qed_mcp_set_link(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + bool b_up); + + /** +- * @brief Get the management firmware version value ++ * qed_mcp_get_mfw_ver(): Get the management firmware version value. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_mfw_ver - mfw version value +- * @param p_running_bundle_id - image id in nvram; Optional. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_mfw_ver: MFW version value. ++ * @p_running_bundle_id: Image id in nvram; Optional. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - operation was successful. + */ + int qed_mcp_get_mfw_ver(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *p_mfw_ver, u32 *p_running_bundle_id); + + /** +- * @brief Get the MBI version value ++ * qed_mcp_get_mbi_ver(): Get the MBI version value. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_mbi_ver - A pointer to a variable to be filled with the MBI version. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_mbi_ver: A pointer to a variable to be filled with the MBI version. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - operation was successful. + */ + int qed_mcp_get_mbi_ver(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *p_mbi_ver); + + /** +- * @brief Get media type value of the port. ++ * qed_mcp_get_media_type(): Get media type value of the port. + * +- * @param cdev - qed dev pointer +- * @param p_ptt +- * @param mfw_ver - media type value ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @media_type: Media type value + * +- * @return int - +- * 0 - Operation was successul. +- * -EBUSY - Operation failed ++ * Return: Int - 0 - Operation was successul. ++ * -EBUSY - Operation failed + */ + int qed_mcp_get_media_type(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *media_type); + + /** +- * @brief Get transceiver data of the port. ++ * qed_mcp_get_transceiver_data(): Get transceiver data of the port. + * +- * @param cdev - qed dev pointer +- * @param p_ptt +- * @param p_transceiver_state - transceiver state. +- * @param p_transceiver_type - media type value ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_transceiver_state: Transceiver state. ++ * @p_tranceiver_type: Media type value. + * +- * @return int - +- * 0 - Operation was successful. +- * -EBUSY - Operation failed ++ * Return: Int - 0 - Operation was successul. ++ * -EBUSY - Operation failed + */ + int qed_mcp_get_transceiver_data(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -364,50 +364,48 @@ int qed_mcp_get_transceiver_data(struct qed_hwfn *p_hwfn, + u32 *p_tranceiver_type); + + /** +- * @brief Get transceiver supported speed mask. ++ * qed_mcp_trans_speed_mask(): Get transceiver supported speed mask. + * +- * @param cdev - qed dev pointer +- * @param p_ptt +- * @param p_speed_mask - Bit mask of all supported speeds. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_speed_mask: Bit mask of all supported speeds. + * +- * @return int - +- * 0 - Operation was successful. +- * -EBUSY - Operation failed ++ * Return: Int - 0 - Operation was successul. ++ * -EBUSY - Operation failed + */ + + int qed_mcp_trans_speed_mask(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *p_speed_mask); + + /** +- * @brief Get board configuration. ++ * qed_mcp_get_board_config(): Get board configuration. + * +- * @param cdev - qed dev pointer +- * @param p_ptt +- * @param p_board_config - Board config. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_board_config: Board config. + * +- * @return int - +- * 0 - Operation was successful. +- * -EBUSY - Operation failed ++ * Return: Int - 0 - Operation was successul. ++ * -EBUSY - Operation failed + */ + int qed_mcp_get_board_config(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *p_board_config); + + /** +- * @brief General function for sending commands to the MCP +- * mailbox. It acquire mutex lock for the entire +- * operation, from sending the request until the MCP +- * response. Waiting for MCP response will be checked up +- * to 5 seconds every 5ms. ++ * qed_mcp_cmd(): General function for sending commands to the MCP ++ * mailbox. It acquire mutex lock for the entire ++ * operation, from sending the request until the MCP ++ * response. Waiting for MCP response will be checked up ++ * to 5 seconds every 5ms. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access +- * @param cmd - command to be sent to the MCP. +- * @param param - Optional param +- * @param o_mcp_resp - The MCP response code (exclude sequence). +- * @param o_mcp_param- Optional parameter provided by the MCP ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @cmd: command to be sent to the MCP. ++ * @param: Optional param ++ * @o_mcp_resp: The MCP response code (exclude sequence). ++ * @o_mcp_param: Optional parameter provided by the MCP + * response +- * @return int - 0 - operation +- * was successul. ++ * ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_cmd(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -417,37 +415,39 @@ int qed_mcp_cmd(struct qed_hwfn *p_hwfn, + u32 *o_mcp_param); + + /** +- * @brief - drains the nig, allowing completion to pass in case of pauses. +- * (Should be called only from sleepable context) ++ * qed_mcp_drain(): drains the nig, allowing completion to pass in ++ * case of pauses. ++ * (Should be called only from sleepable context) + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * ++ * Return: Int. + */ + int qed_mcp_drain(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Get the flash size value ++ * qed_mcp_get_flash_size(): Get the flash size value. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_flash_size - flash size in bytes to be filled. ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @p_flash_size: Flash size in bytes to be filled. + * +- * @return int - 0 - operation was successul. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_get_flash_size(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *p_flash_size); + + /** +- * @brief Send driver version to MFW ++ * qed_mcp_send_drv_version(): Send driver version to MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param version - Version value +- * @param name - Protocol driver name ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @p_ver: Version value. + * +- * @return int - 0 - operation was successul. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_send_drv_version(struct qed_hwfn *p_hwfn, +@@ -455,146 +455,148 @@ qed_mcp_send_drv_version(struct qed_hwfn *p_hwfn, + struct qed_mcp_drv_version *p_ver); + + /** +- * @brief Read the MFW process kill counter ++ * qed_get_process_kill_counter(): Read the MFW process kill counter. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. + * +- * @return u32 ++ * Return: u32. + */ + u32 qed_get_process_kill_counter(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Trigger a recovery process ++ * qed_start_recovery_process(): Trigger a recovery process. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. + * +- * @return int ++ * Return: Int. + */ + int qed_start_recovery_process(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief A recovery handler must call this function as its first step. +- * It is assumed that the handler is not run from an interrupt context. ++ * qed_recovery_prolog(): A recovery handler must call this function ++ * as its first step. ++ * It is assumed that the handler is not run from ++ * an interrupt context. + * +- * @param cdev +- * @param p_ptt ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: int. + */ + int qed_recovery_prolog(struct qed_dev *cdev); + + /** +- * @brief Notify MFW about the change in base device properties ++ * qed_mcp_ov_update_current_config(): Notify MFW about the change in base ++ * device properties + * +- * @param p_hwfn +- * @param p_ptt +- * @param client - qed client type ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @client: Qed client type. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_current_config(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + enum qed_ov_client client); + + /** +- * @brief Notify MFW about the driver state ++ * qed_mcp_ov_update_driver_state(): Notify MFW about the driver state. + * +- * @param p_hwfn +- * @param p_ptt +- * @param drv_state - Driver state ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @drv_state: Driver state. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_driver_state(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + enum qed_ov_driver_state drv_state); + + /** +- * @brief Send MTU size to MFW ++ * qed_mcp_ov_update_mtu(): Send MTU size to MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param mtu - MTU size ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @mtu: MTU size. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_mtu(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u16 mtu); + + /** +- * @brief Send MAC address to MFW ++ * qed_mcp_ov_update_mac(): Send MAC address to MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param mac - MAC address ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @mac: MAC address. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_mac(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u8 *mac); + + /** +- * @brief Send WOL mode to MFW ++ * qed_mcp_ov_update_wol(): Send WOL mode to MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param wol - WOL mode ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @wol: WOL mode. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_wol(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + enum qed_ov_wol wol); + + /** +- * @brief Set LED status ++ * qed_mcp_set_led(): Set LED status. + * +- * @param p_hwfn +- * @param p_ptt +- * @param mode - LED mode ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @mode: LED mode. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_set_led(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + enum qed_led_mode mode); + + /** +- * @brief Read from nvm ++ * qed_mcp_nvm_read(): Read from NVM. + * +- * @param cdev +- * @param addr - nvm offset +- * @param p_buf - nvm read buffer +- * @param len - buffer len ++ * @cdev: Qed dev pointer. ++ * @addr: NVM offset. ++ * @p_buf: NVM read buffer. ++ * @len: Buffer len. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_nvm_read(struct qed_dev *cdev, u32 addr, u8 *p_buf, u32 len); + + /** +- * @brief Write to nvm ++ * qed_mcp_nvm_write(): Write to NVM. + * +- * @param cdev +- * @param addr - nvm offset +- * @param cmd - nvm command +- * @param p_buf - nvm write buffer +- * @param len - buffer len ++ * @cdev: Qed dev pointer. ++ * @addr: NVM offset. ++ * @cmd: NVM command. ++ * @p_buf: NVM write buffer. ++ * @len: Buffer len. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_nvm_write(struct qed_dev *cdev, + u32 cmd, u32 addr, u8 *p_buf, u32 len); + + /** +- * @brief Check latest response ++ * qed_mcp_nvm_resp(): Check latest response. + * +- * @param cdev +- * @param p_buf - nvm write buffer ++ * @cdev: Qed dev pointer. ++ * @p_buf: NVM write buffer. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_nvm_resp(struct qed_dev *cdev, u8 *p_buf); + +@@ -604,13 +606,13 @@ struct qed_nvm_image_att { + }; + + /** +- * @brief Allows reading a whole nvram image ++ * qed_mcp_get_nvm_image_att(): Allows reading a whole nvram image. + * +- * @param p_hwfn +- * @param image_id - image to get attributes for +- * @param p_image_att - image attributes structure into which to fill data ++ * @p_hwfn: HW device data. ++ * @image_id: Image to get attributes for. ++ * @p_image_att: Image attributes structure into which to fill data. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_get_nvm_image_att(struct qed_hwfn *p_hwfn, +@@ -618,64 +620,65 @@ qed_mcp_get_nvm_image_att(struct qed_hwfn *p_hwfn, + struct qed_nvm_image_att *p_image_att); + + /** +- * @brief Allows reading a whole nvram image ++ * qed_mcp_get_nvm_image(): Allows reading a whole nvram image. + * +- * @param p_hwfn +- * @param image_id - image requested for reading +- * @param p_buffer - allocated buffer into which to fill data +- * @param buffer_len - length of the allocated buffer. ++ * @p_hwfn: HW device data. ++ * @image_id: image requested for reading. ++ * @p_buffer: allocated buffer into which to fill data. ++ * @buffer_len: length of the allocated buffer. + * +- * @return 0 iff p_buffer now contains the nvram image. ++ * Return: 0 if p_buffer now contains the nvram image. + */ + int qed_mcp_get_nvm_image(struct qed_hwfn *p_hwfn, + enum qed_nvm_images image_id, + u8 *p_buffer, u32 buffer_len); + + /** +- * @brief Bist register test ++ * qed_mcp_bist_register_test(): Bist register test. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_bist_register_test(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Bist clock test ++ * qed_mcp_bist_clock_test(): Bist clock test. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_bist_clock_test(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Bist nvm test - get number of images ++ * qed_mcp_bist_nvm_get_num_images(): Bist nvm test - get number of images. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access +- * @param num_images - number of images if operation was ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @num_images: number of images if operation was + * successful. 0 if not. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_bist_nvm_get_num_images(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + u32 *num_images); + + /** +- * @brief Bist nvm test - get image attributes by index ++ * qed_mcp_bist_nvm_get_image_att(): Bist nvm test - get image attributes ++ * by index. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access +- * @param p_image_att - Attributes of image +- * @param image_index - Index of image to get information for ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @p_image_att: Attributes of image. ++ * @image_index: Index of image to get information for. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_bist_nvm_get_image_att(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -683,23 +686,26 @@ int qed_mcp_bist_nvm_get_image_att(struct qed_hwfn *p_hwfn, + u32 image_index); + + /** +- * @brief - Processes the TLV request from MFW i.e., get the required TLV info +- * from the qed client and send it to the MFW. ++ * qed_mfw_process_tlv_req(): Processes the TLV request from MFW i.e., ++ * get the required TLV info ++ * from the qed client and send it to the MFW. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mfw_process_tlv_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Send raw debug data to the MFW ++ * qed_mcp_send_raw_debug_data(): Send raw debug data to the MFW ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_buf: raw debug data buffer. ++ * @size: Buffer size. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_buf - raw debug data buffer +- * @param size - buffer size ++ * Return : Int. + */ + int + qed_mcp_send_raw_debug_data(struct qed_hwfn *p_hwfn, +@@ -796,47 +802,49 @@ qed_mcp_is_ext_speed_supported(const struct qed_hwfn *p_hwfn) + } + + /** +- * @brief Initialize the interface with the MCP ++ * qed_mcp_cmd_init(): Initialize the interface with the MCP. + * +- * @param p_hwfn - HW func +- * @param p_ptt - PTT required for register access ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. + * +- * @return int ++ * Return: Int. + */ + int qed_mcp_cmd_init(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Initialize the port interface with the MCP ++ * qed_mcp_cmd_port_init(): Initialize the port interface with the MCP ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Void. + * +- * @param p_hwfn +- * @param p_ptt + * Can only be called after `num_ports_in_engines' is set + */ + void qed_mcp_cmd_port_init(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + /** +- * @brief Releases resources allocated during the init process. ++ * qed_mcp_free(): Releases resources allocated during the init process. + * +- * @param p_hwfn - HW func +- * @param p_ptt - PTT required for register access ++ * @p_hwfn: HW function. + * +- * @return int ++ * Return: Int. + */ + + int qed_mcp_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief This function is called from the DPC context. After +- * pointing PTT to the mfw mb, check for events sent by the MCP +- * to the driver and ack them. In case a critical event +- * detected, it will be handled here, otherwise the work will be +- * queued to a sleepable work-queue. ++ * qed_mcp_handle_events(): This function is called from the DPC context. ++ * After pointing PTT to the mfw mb, check for events sent by ++ * the MCP to the driver and ack them. In case a critical event ++ * detected, it will be handled here, otherwise the work will be ++ * queued to a sleepable work-queue. ++ * ++ * @p_hwfn: HW function. ++ * @p_ptt: PTT required for register access. + * +- * @param p_hwfn - HW function +- * @param p_ptt - PTT required for register access +- * @return int - 0 - operation +- * was successul. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_handle_events(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); +@@ -858,106 +866,111 @@ struct qed_load_req_params { + }; + + /** +- * @brief Sends a LOAD_REQ to the MFW, and in case the operation succeeds, +- * returns whether this PF is the first on the engine/port or function. ++ * qed_mcp_load_req(): Sends a LOAD_REQ to the MFW, and in case the ++ * operation succeeds, returns whether this PF is ++ * the first on the engine/port or function. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_params ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_params: Params. + * +- * @return int - 0 - Operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_load_req(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, + struct qed_load_req_params *p_params); + + /** +- * @brief Sends a LOAD_DONE message to the MFW ++ * qed_mcp_load_done(): Sends a LOAD_DONE message to the MFW. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int - 0 - Operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_load_done(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Sends a UNLOAD_REQ message to the MFW ++ * qed_mcp_unload_req(): Sends a UNLOAD_REQ message to the MFW. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int - 0 - Operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_unload_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Sends a UNLOAD_DONE message to the MFW ++ * qed_mcp_unload_done(): Sends a UNLOAD_DONE message to the MFW + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int - 0 - Operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_unload_done(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Read the MFW mailbox into Current buffer. ++ * qed_mcp_read_mb(): Read the MFW mailbox into Current buffer. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Void. + */ + void qed_mcp_read_mb(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief Ack to mfw that driver finished FLR process for VFs ++ * qed_mcp_ack_vf_flr(): Ack to mfw that driver finished FLR process for VFs + * +- * @param p_hwfn +- * @param p_ptt +- * @param vfs_to_ack - bit mask of all engine VFs for which the PF acks. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @vfs_to_ack: bit mask of all engine VFs for which the PF acks. + * +- * @param return int - 0 upon success. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ack_vf_flr(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 *vfs_to_ack); + + /** +- * @brief - calls during init to read shmem of all function-related info. ++ * qed_mcp_fill_shmem_func_info(): Calls during init to read shmem of ++ * all function-related info. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mcp_fill_shmem_func_info(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief - Reset the MCP using mailbox command. ++ * qed_mcp_reset(): Reset the MCP using mailbox command. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mcp_reset(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt); + + /** +- * @brief - Sends an NVM read command request to the MFW to get +- * a buffer. ++ * qed_mcp_nvm_rd_cmd(): Sends an NVM read command request to the MFW to get ++ * a buffer. + * +- * @param p_hwfn +- * @param p_ptt +- * @param cmd - Command: DRV_MSG_CODE_NVM_GET_FILE_DATA or +- * DRV_MSG_CODE_NVM_READ_NVRAM commands +- * @param param - [0:23] - Offset [24:31] - Size +- * @param o_mcp_resp - MCP response +- * @param o_mcp_param - MCP response param +- * @param o_txn_size - Buffer size output +- * @param o_buf - Pointer to the buffer returned by the MFW. ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @cmd: (Command) DRV_MSG_CODE_NVM_GET_FILE_DATA or ++ * DRV_MSG_CODE_NVM_READ_NVRAM commands. ++ * @param: [0:23] - Offset [24:31] - Size. ++ * @o_mcp_resp: MCP response. ++ * @o_mcp_param: MCP response param. ++ * @o_txn_size: Buffer size output. ++ * @o_buf: Pointer to the buffer returned by the MFW. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mcp_nvm_rd_cmd(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -967,60 +980,61 @@ int qed_mcp_nvm_rd_cmd(struct qed_hwfn *p_hwfn, + u32 *o_mcp_param, u32 *o_txn_size, u32 *o_buf); + + /** +- * @brief Read from sfp ++ * qed_mcp_phy_sfp_read(): Read from sfp. + * +- * @param p_hwfn - hw function +- * @param p_ptt - PTT required for register access +- * @param port - transceiver port +- * @param addr - I2C address +- * @param offset - offset in sfp +- * @param len - buffer length +- * @param p_buf - buffer to read into ++ * @p_hwfn: HW device data. ++ * @p_ptt: PTT required for register access. ++ * @port: transceiver port. ++ * @addr: I2C address. ++ * @offset: offset in sfp. ++ * @len: buffer length. ++ * @p_buf: buffer to read into. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_phy_sfp_read(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + u32 port, u32 addr, u32 offset, u32 len, u8 *p_buf); + + /** +- * @brief indicates whether the MFW objects [under mcp_info] are accessible ++ * qed_mcp_is_init(): indicates whether the MFW objects [under mcp_info] ++ * are accessible + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return true iff MFW is running and mcp_info is initialized ++ * Return: true if MFW is running and mcp_info is initialized. + */ + bool qed_mcp_is_init(struct qed_hwfn *p_hwfn); + + /** +- * @brief request MFW to configure MSI-X for a VF ++ * qed_mcp_config_vf_msix(): Request MFW to configure MSI-X for a VF. + * +- * @param p_hwfn +- * @param p_ptt +- * @param vf_id - absolute inside engine +- * @param num_sbs - number of entries to request ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @vf_id: absolute inside engine. ++ * @num: number of entries to request. + * +- * @return int ++ * Return: Int. + */ + int qed_mcp_config_vf_msix(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u8 vf_id, u8 num); + + /** +- * @brief - Halt the MCP. ++ * qed_mcp_halt(): Halt the MCP. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mcp_halt(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief - Wake up the MCP. ++ * qed_mcp_resume: Wake up the MCP. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param return 0 upon success. ++ * Return: 0 upon success. + */ + int qed_mcp_resume(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + +@@ -1038,13 +1052,13 @@ int __qed_configure_pf_min_bandwidth(struct qed_hwfn *p_hwfn, + int qed_mcp_mask_parities(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, u32 mask_parities); + +-/* @brief - Gets the mdump retained data from the MFW. ++/* qed_mcp_mdump_get_retain(): Gets the mdump retained data from the MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_mdump_retain ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_mdump_retain: mdump retain. + * +- * @param return 0 upon success. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_mdump_get_retain(struct qed_hwfn *p_hwfn, +@@ -1052,15 +1066,15 @@ qed_mcp_mdump_get_retain(struct qed_hwfn *p_hwfn, + struct mdump_retain_data_stc *p_mdump_retain); + + /** +- * @brief - Sets the MFW's max value for the given resource ++ * qed_mcp_set_resc_max_val(): Sets the MFW's max value for the given resource. + * +- * @param p_hwfn +- * @param p_ptt +- * @param res_id +- * @param resc_max_val +- * @param p_mcp_resp ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @res_id: RES ID. ++ * @resc_max_val: Resec max val. ++ * @p_mcp_resp: MCP Resp + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_set_resc_max_val(struct qed_hwfn *p_hwfn, +@@ -1069,16 +1083,17 @@ qed_mcp_set_resc_max_val(struct qed_hwfn *p_hwfn, + u32 resc_max_val, u32 *p_mcp_resp); + + /** +- * @brief - Gets the MFW allocation info for the given resource ++ * qed_mcp_get_resc_info(): Gets the MFW allocation info for the given ++ * resource. + * +- * @param p_hwfn +- * @param p_ptt +- * @param res_id +- * @param p_mcp_resp +- * @param p_resc_num +- * @param p_resc_start ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @res_id: Res ID. ++ * @p_mcp_resp: MCP resp. ++ * @p_resc_num: Resc num. ++ * @p_resc_start: Resc start. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_get_resc_info(struct qed_hwfn *p_hwfn, +@@ -1087,13 +1102,13 @@ qed_mcp_get_resc_info(struct qed_hwfn *p_hwfn, + u32 *p_mcp_resp, u32 *p_resc_num, u32 *p_resc_start); + + /** +- * @brief Send eswitch mode to MFW ++ * qed_mcp_ov_update_eswitch(): Send eswitch mode to MFW. + * +- * @param p_hwfn +- * @param p_ptt +- * @param eswitch - eswitch mode ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @eswitch: eswitch mode. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_ov_update_eswitch(struct qed_hwfn *p_hwfn, + struct qed_ptt *p_ptt, +@@ -1113,12 +1128,12 @@ enum qed_resc_lock { + }; + + /** +- * @brief - Initiates PF FLR ++ * qed_mcp_initiate_pf_flr(): Initiates PF FLR. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int qed_mcp_initiate_pf_flr(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + struct qed_resc_lock_params { +@@ -1151,13 +1166,13 @@ struct qed_resc_lock_params { + }; + + /** +- * @brief Acquires MFW generic resource lock ++ * qed_mcp_resc_lock(): Acquires MFW generic resource lock. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_params ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_params: Params. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_resc_lock(struct qed_hwfn *p_hwfn, +@@ -1175,13 +1190,13 @@ struct qed_resc_unlock_params { + }; + + /** +- * @brief Releases MFW generic resource lock ++ * qed_mcp_resc_unlock(): Releases MFW generic resource lock. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_params ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_params: Params. + * +- * @return int - 0 - operation was successful. ++ * Return: Int - 0 - Operation was successul. + */ + int + qed_mcp_resc_unlock(struct qed_hwfn *p_hwfn, +@@ -1189,12 +1204,15 @@ qed_mcp_resc_unlock(struct qed_hwfn *p_hwfn, + struct qed_resc_unlock_params *p_params); + + /** +- * @brief - default initialization for lock/unlock resource structs ++ * qed_mcp_resc_lock_default_init(): Default initialization for ++ * lock/unlock resource structs. + * +- * @param p_lock - lock params struct to be initialized; Can be NULL +- * @param p_unlock - unlock params struct to be initialized; Can be NULL +- * @param resource - the requested resource +- * @paral b_is_permanent - disable retries & aging when set ++ * @p_lock: lock params struct to be initialized; Can be NULL. ++ * @p_unlock: unlock params struct to be initialized; Can be NULL. ++ * @resource: the requested resource. ++ * @b_is_permanent: disable retries & aging when set. ++ * ++ * Return: Void. + */ + void qed_mcp_resc_lock_default_init(struct qed_resc_lock_params *p_lock, + struct qed_resc_unlock_params *p_unlock, +@@ -1202,94 +1220,117 @@ void qed_mcp_resc_lock_default_init(struct qed_resc_lock_params *p_lock, + resource, bool b_is_permanent); + + /** +- * @brief - Return whether management firmware support smart AN ++ * qed_mcp_is_smart_an_supported(): Return whether management firmware ++ * support smart AN + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return bool - true if feature is supported. ++ * Return: bool true if feature is supported. + */ + bool qed_mcp_is_smart_an_supported(struct qed_hwfn *p_hwfn); + + /** +- * @brief Learn of supported MFW features; To be done during early init ++ * qed_mcp_get_capabilities(): Learn of supported MFW features; ++ * To be done during early init. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Int. + */ + int qed_mcp_get_capabilities(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Inform MFW of set of features supported by driver. Should be done +- * inside the content of the LOAD_REQ. ++ * qed_mcp_set_capabilities(): Inform MFW of set of features supported ++ * by driver. Should be done inside the content ++ * of the LOAD_REQ. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param p_hwfn +- * @param p_ptt ++ * Return: Int. + */ + int qed_mcp_set_capabilities(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Read ufp config from the shared memory. ++ * qed_mcp_read_ufp_config(): Read ufp config from the shared memory. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. + * +- * @param p_hwfn +- * @param p_ptt ++ * Return: Void. + */ + void qed_mcp_read_ufp_config(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Populate the nvm info shadow in the given hardware function ++ * qed_mcp_nvm_info_populate(): Populate the nvm info shadow in the given ++ * hardware function. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Int. + */ + int qed_mcp_nvm_info_populate(struct qed_hwfn *p_hwfn); + + /** +- * @brief Delete nvm info shadow in the given hardware function ++ * qed_mcp_nvm_info_free(): Delete nvm info shadow in the given ++ * hardware function. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_mcp_nvm_info_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief Get the engine affinity configuration. ++ * qed_mcp_get_engine_config(): Get the engine affinity configuration. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Int. + */ + int qed_mcp_get_engine_config(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Get the PPFID bitmap. ++ * qed_mcp_get_ppfid_bitmap(): Get the PPFID bitmap. + * +- * @param p_hwfn +- * @param p_ptt ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * ++ * Return: Int. + */ + int qed_mcp_get_ppfid_bitmap(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + + /** +- * @brief Get NVM config attribute value. ++ * qed_mcp_nvm_get_cfg(): Get NVM config attribute value. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @option_id: Option ID. ++ * @entity_id: Entity ID. ++ * @flags: Flags. ++ * @p_buf: Buf. ++ * @p_len: Len. + * +- * @param p_hwfn +- * @param p_ptt +- * @param option_id +- * @param entity_id +- * @param flags +- * @param p_buf +- * @param p_len ++ * Return: Int. + */ + int qed_mcp_nvm_get_cfg(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + u16 option_id, u8 entity_id, u16 flags, u8 *p_buf, + u32 *p_len); + + /** +- * @brief Set NVM config attribute value. ++ * qed_mcp_nvm_set_cfg(): Set NVM config attribute value. + * +- * @param p_hwfn +- * @param p_ptt +- * @param option_id +- * @param entity_id +- * @param flags +- * @param p_buf +- * @param len ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @option_id: Option ID. ++ * @entity_id: Entity ID. ++ * @flags: Flags. ++ * @p_buf: Buf. ++ * @len: Len. ++ * ++ * Return: Int. + */ + int qed_mcp_nvm_set_cfg(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + u16 option_id, u8 entity_id, u16 flags, u8 *p_buf, +diff --git a/drivers/net/ethernet/qlogic/qed/qed_selftest.h b/drivers/net/ethernet/qlogic/qed/qed_selftest.h +index e27dd9a4547e8..7a3bd749e1e4c 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_selftest.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_selftest.h +@@ -6,47 +6,47 @@ + #include + + /** +- * @brief qed_selftest_memory - Perform memory test ++ * qed_selftest_memory(): Perform memory test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_selftest_memory(struct qed_dev *cdev); + + /** +- * @brief qed_selftest_interrupt - Perform interrupt test ++ * qed_selftest_interrupt(): Perform interrupt test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_selftest_interrupt(struct qed_dev *cdev); + + /** +- * @brief qed_selftest_register - Perform register test ++ * qed_selftest_register(): Perform register test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_selftest_register(struct qed_dev *cdev); + + /** +- * @brief qed_selftest_clock - Perform clock test ++ * qed_selftest_clock(): Perform clock test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_selftest_clock(struct qed_dev *cdev); + + /** +- * @brief qed_selftest_nvram - Perform nvram test ++ * qed_selftest_nvram(): Perform nvram test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return int ++ * Return: Int. + */ + int qed_selftest_nvram(struct qed_dev *cdev); + +diff --git a/drivers/net/ethernet/qlogic/qed/qed_sp.h b/drivers/net/ethernet/qlogic/qed/qed_sp.h +index 60ff3222bf551..c5a38f3c92b04 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_sp.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_sp.h +@@ -31,23 +31,18 @@ struct qed_spq_comp_cb { + }; + + /** +- * @brief qed_eth_cqe_completion - handles the completion of a +- * ramrod on the cqe ring ++ * qed_eth_cqe_completion(): handles the completion of a ++ * ramrod on the cqe ring. + * +- * @param p_hwfn +- * @param cqe ++ * @p_hwfn: HW device data. ++ * @cqe: CQE. + * +- * @return int ++ * Return: Int. + */ + int qed_eth_cqe_completion(struct qed_hwfn *p_hwfn, + struct eth_slow_path_rx_cqe *cqe); + +-/** +- * @file +- * +- * QED Slow-hwfn queue interface +- */ +- ++ /* QED Slow-hwfn queue interface */ + union ramrod_data { + struct pf_start_ramrod_data pf_start; + struct pf_update_ramrod_data pf_update; +@@ -207,117 +202,128 @@ struct qed_spq { + }; + + /** +- * @brief qed_spq_post - Posts a Slow hwfn request to FW, or lacking that +- * Pends it to the future list. ++ * qed_spq_post(): Posts a Slow hwfn request to FW, or lacking that ++ * Pends it to the future list. + * +- * @param p_hwfn +- * @param p_req ++ * @p_hwfn: HW device data. ++ * @p_ent: Ent. ++ * @fw_return_code: Return code from firmware. + * +- * @return int ++ * Return: Int. + */ + int qed_spq_post(struct qed_hwfn *p_hwfn, + struct qed_spq_entry *p_ent, + u8 *fw_return_code); + + /** +- * @brief qed_spq_allocate - Alloocates & initializes the SPQ and EQ. ++ * qed_spq_alloc(): Alloocates & initializes the SPQ and EQ. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_spq_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_spq_setup - Reset the SPQ to its start state. ++ * qed_spq_setup(): Reset the SPQ to its start state. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_spq_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_spq_deallocate - Deallocates the given SPQ struct. ++ * qed_spq_free(): Deallocates the given SPQ struct. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_spq_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_spq_get_entry - Obtain an entrry from the spq +- * free pool list. +- * +- * ++ * qed_spq_get_entry(): Obtain an entrry from the spq ++ * free pool list. + * +- * @param p_hwfn +- * @param pp_ent ++ * @p_hwfn: HW device data. ++ * @pp_ent: PP ENT. + * +- * @return int ++ * Return: Int. + */ + int + qed_spq_get_entry(struct qed_hwfn *p_hwfn, + struct qed_spq_entry **pp_ent); + + /** +- * @brief qed_spq_return_entry - Return an entry to spq free +- * pool list ++ * qed_spq_return_entry(): Return an entry to spq free pool list. + * +- * @param p_hwfn +- * @param p_ent ++ * @p_hwfn: HW device data. ++ * @p_ent: P ENT. ++ * ++ * Return: Void. + */ + void qed_spq_return_entry(struct qed_hwfn *p_hwfn, + struct qed_spq_entry *p_ent); + /** +- * @brief qed_eq_allocate - Allocates & initializes an EQ struct ++ * qed_eq_alloc(): Allocates & initializes an EQ struct. + * +- * @param p_hwfn +- * @param num_elem number of elements in the eq ++ * @p_hwfn: HW device data. ++ * @num_elem: number of elements in the eq. + * +- * @return int ++ * Return: Int. + */ + int qed_eq_alloc(struct qed_hwfn *p_hwfn, u16 num_elem); + + /** +- * @brief qed_eq_setup - Reset the EQ to its start state. ++ * qed_eq_setup(): Reset the EQ to its start state. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_eq_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_eq_free - deallocates the given EQ struct. ++ * qed_eq_free(): deallocates the given EQ struct. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_eq_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_eq_prod_update - update the FW with default EQ producer ++ * qed_eq_prod_update(): update the FW with default EQ producer. ++ * ++ * @p_hwfn: HW device data. ++ * @prod: Prod. + * +- * @param p_hwfn +- * @param prod ++ * Return: Void. + */ + void qed_eq_prod_update(struct qed_hwfn *p_hwfn, + u16 prod); + + /** +- * @brief qed_eq_completion - Completes currently pending EQ elements ++ * qed_eq_completion(): Completes currently pending EQ elements. + * +- * @param p_hwfn +- * @param cookie ++ * @p_hwfn: HW device data. ++ * @cookie: Cookie. + * +- * @return int ++ * Return: Int. + */ + int qed_eq_completion(struct qed_hwfn *p_hwfn, + void *cookie); + + /** +- * @brief qed_spq_completion - Completes a single event ++ * qed_spq_completion(): Completes a single event. + * +- * @param p_hwfn +- * @param echo - echo value from cookie (used for determining completion) +- * @param p_data - data from cookie (used in callback function if applicable) ++ * @p_hwfn: HW device data. ++ * @echo: echo value from cookie (used for determining completion). ++ * @fw_return_code: FW return code. ++ * @p_data: data from cookie (used in callback function if applicable). + * +- * @return int ++ * Return: Int. + */ + int qed_spq_completion(struct qed_hwfn *p_hwfn, + __le16 echo, +@@ -325,44 +331,43 @@ int qed_spq_completion(struct qed_hwfn *p_hwfn, + union event_ring_data *p_data); + + /** +- * @brief qed_spq_get_cid - Given p_hwfn, return cid for the hwfn's SPQ ++ * qed_spq_get_cid(): Given p_hwfn, return cid for the hwfn's SPQ. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return u32 - SPQ CID ++ * Return: u32 - SPQ CID. + */ + u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_consq_alloc - Allocates & initializes an ConsQ +- * struct ++ * qed_consq_alloc(): Allocates & initializes an ConsQ struct. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_consq_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_consq_setup - Reset the ConsQ to its start state. ++ * qed_consq_setup(): Reset the ConsQ to its start state. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return Void. + */ + void qed_consq_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_consq_free - deallocates the given ConsQ struct. ++ * qed_consq_free(): deallocates the given ConsQ struct. ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return Void. + */ + void qed_consq_free(struct qed_hwfn *p_hwfn); + int qed_spq_pend_post(struct qed_hwfn *p_hwfn); + +-/** +- * @file +- * +- * @brief Slow-hwfn low-level commands (Ramrods) function definitions. +- */ ++/* Slow-hwfn low-level commands (Ramrods) function definitions. */ + + #define QED_SP_EQ_COMPLETION 0x01 + #define QED_SP_CQE_COMPLETION 0x02 +@@ -377,12 +382,15 @@ struct qed_sp_init_data { + }; + + /** +- * @brief Returns a SPQ entry to the pool / frees the entry if allocated. +- * Should be called on in error flows after initializing the SPQ entry +- * and before posting it. ++ * qed_sp_destroy_request(): Returns a SPQ entry to the pool / frees the ++ * entry if allocated. Should be called on in error ++ * flows after initializing the SPQ entry ++ * and before posting it. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ent: Ent. + * +- * @param p_hwfn +- * @param p_ent ++ * Return: Void. + */ + void qed_sp_destroy_request(struct qed_hwfn *p_hwfn, + struct qed_spq_entry *p_ent); +@@ -394,7 +402,14 @@ int qed_sp_init_request(struct qed_hwfn *p_hwfn, + struct qed_sp_init_data *p_data); + + /** +- * @brief qed_sp_pf_start - PF Function Start Ramrod ++ * qed_sp_pf_start(): PF Function Start Ramrod. ++ * ++ * @p_hwfn: HW device data. ++ * @p_ptt: P_ptt. ++ * @p_tunn: P_tunn. ++ * @allow_npar_tx_switch: Allow NPAR TX Switch. ++ * ++ * Return: Int. + * + * This ramrod is sent to initialize a physical function (PF). It will + * configure the function related parameters and write its completion to the +@@ -404,12 +419,6 @@ int qed_sp_init_request(struct qed_hwfn *p_hwfn, + * allocated by the driver on host memory and its parameters are written + * to the internal RAM of the UStorm by the Function Start Ramrod. + * +- * @param p_hwfn +- * @param p_ptt +- * @param p_tunn +- * @param allow_npar_tx_switch +- * +- * @return int + */ + + int qed_sp_pf_start(struct qed_hwfn *p_hwfn, +@@ -418,47 +427,33 @@ int qed_sp_pf_start(struct qed_hwfn *p_hwfn, + bool allow_npar_tx_switch); + + /** +- * @brief qed_sp_pf_update - PF Function Update Ramrod ++ * qed_sp_pf_update(): PF Function Update Ramrod. + * +- * This ramrod updates function-related parameters. Every parameter can be +- * updated independently, according to configuration flags. ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Int. + * +- * @return int ++ * This ramrod updates function-related parameters. Every parameter can be ++ * updated independently, according to configuration flags. + */ + + int qed_sp_pf_update(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_sp_pf_update_stag - Update firmware of new outer tag ++ * qed_sp_pf_update_stag(): Update firmware of new outer tag. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_sp_pf_update_stag(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_sp_pf_stop - PF Function Stop Ramrod +- * +- * This ramrod is sent to close a Physical Function (PF). It is the last ramrod +- * sent and the last completion written to the PFs Event Ring. This ramrod also +- * deletes the context for the Slowhwfn connection on this PF. +- * +- * @note Not required for first packet. +- * +- * @param p_hwfn +- * +- * @return int +- */ +- +-/** +- * @brief qed_sp_pf_update_ufp - PF ufp update Ramrod ++ * qed_sp_pf_update_ufp(): PF ufp update Ramrod. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_sp_pf_update_ufp(struct qed_hwfn *p_hwfn); + +@@ -470,11 +465,11 @@ int qed_sp_pf_update_tunn_cfg(struct qed_hwfn *p_hwfn, + enum spq_mode comp_mode, + struct qed_spq_comp_cb *p_comp_data); + /** +- * @brief qed_sp_heartbeat_ramrod - Send empty Ramrod ++ * qed_sp_heartbeat_ramrod(): Send empty Ramrod. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + + int qed_sp_heartbeat_ramrod(struct qed_hwfn *p_hwfn); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_sriov.h b/drivers/net/ethernet/qlogic/qed/qed_sriov.h +index 7ff23ef8ccc17..0a1e44d45c1a2 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_sriov.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_sriov.h +@@ -251,29 +251,31 @@ extern const struct qed_iov_hv_ops qed_iov_ops_pass; + + #ifdef CONFIG_QED_SRIOV + /** +- * @brief Check if given VF ID @vfid is valid +- * w.r.t. @b_enabled_only value +- * if b_enabled_only = true - only enabled VF id is valid +- * else any VF id less than max_vfs is valid ++ * qed_iov_is_valid_vfid(): Check if given VF ID @vfid is valid ++ * w.r.t. @b_enabled_only value ++ * if b_enabled_only = true - only enabled ++ * VF id is valid. ++ * else any VF id less than max_vfs is valid. + * +- * @param p_hwfn +- * @param rel_vf_id - Relative VF ID +- * @param b_enabled_only - consider only enabled VF +- * @param b_non_malicious - true iff we want to validate vf isn't malicious. ++ * @p_hwfn: HW device data. ++ * @rel_vf_id: Relative VF ID. ++ * @b_enabled_only: consider only enabled VF. ++ * @b_non_malicious: true iff we want to validate vf isn't malicious. + * +- * @return bool - true for valid VF ID ++ * Return: bool - true for valid VF ID + */ + bool qed_iov_is_valid_vfid(struct qed_hwfn *p_hwfn, + int rel_vf_id, + bool b_enabled_only, bool b_non_malicious); + + /** +- * @brief - Given a VF index, return index of next [including that] active VF. ++ * qed_iov_get_next_active_vf(): Given a VF index, return index of ++ * next [including that] active VF. + * +- * @param p_hwfn +- * @param rel_vf_id ++ * @p_hwfn: HW device data. ++ * @rel_vf_id: VF ID. + * +- * @return MAX_NUM_VFS in case no further active VFs, otherwise index. ++ * Return: MAX_NUM_VFS in case no further active VFs, otherwise index. + */ + u16 qed_iov_get_next_active_vf(struct qed_hwfn *p_hwfn, u16 rel_vf_id); + +@@ -281,83 +283,92 @@ void qed_iov_bulletin_set_udp_ports(struct qed_hwfn *p_hwfn, + int vfid, u16 vxlan_port, u16 geneve_port); + + /** +- * @brief Read sriov related information and allocated resources +- * reads from configuration space, shmem, etc. ++ * qed_iov_hw_info(): Read sriov related information and allocated resources ++ * reads from configuration space, shmem, etc. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_iov_hw_info(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_add_tlv - place a given tlv on the tlv buffer at next offset ++ * qed_add_tlv(): place a given tlv on the tlv buffer at next offset + * +- * @param p_hwfn +- * @param p_iov +- * @param type +- * @param length ++ * @p_hwfn: HW device data. ++ * @offset: offset. ++ * @type: Type ++ * @length: Length. + * +- * @return pointer to the newly placed tlv ++ * Return: pointer to the newly placed tlv + */ + void *qed_add_tlv(struct qed_hwfn *p_hwfn, u8 **offset, u16 type, u16 length); + + /** +- * @brief list the types and lengths of the tlvs on the buffer ++ * qed_dp_tlv_list(): list the types and lengths of the tlvs on the buffer + * +- * @param p_hwfn +- * @param tlvs_list ++ * @p_hwfn: HW device data. ++ * @tlvs_list: Tlvs_list. ++ * ++ * Return: Void. + */ + void qed_dp_tlv_list(struct qed_hwfn *p_hwfn, void *tlvs_list); + + /** +- * @brief qed_iov_alloc - allocate sriov related resources ++ * qed_iov_alloc(): allocate sriov related resources + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_iov_alloc(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_iov_setup - setup sriov related resources ++ * qed_iov_setup(): setup sriov related resources ++ * ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn ++ * Return: Void. + */ + void qed_iov_setup(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_iov_free - free sriov related resources ++ * qed_iov_free(): free sriov related resources + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. ++ * ++ * Return: Void. + */ + void qed_iov_free(struct qed_hwfn *p_hwfn); + + /** +- * @brief free sriov related memory that was allocated during hw_prepare ++ * qed_iov_free_hw_info(): free sriov related memory that was ++ * allocated during hw_prepare ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Void. + */ + void qed_iov_free_hw_info(struct qed_dev *cdev); + + /** +- * @brief Mark structs of vfs that have been FLR-ed. ++ * qed_iov_mark_vf_flr(): Mark structs of vfs that have been FLR-ed. + * +- * @param p_hwfn +- * @param disabled_vfs - bitmask of all VFs on path that were FLRed ++ * @p_hwfn: HW device data. ++ * @disabled_vfs: bitmask of all VFs on path that were FLRed + * +- * @return true iff one of the PF's vfs got FLRed. false otherwise. ++ * Return: true iff one of the PF's vfs got FLRed. false otherwise. + */ + bool qed_iov_mark_vf_flr(struct qed_hwfn *p_hwfn, u32 *disabled_vfs); + + /** +- * @brief Search extended TLVs in request/reply buffer. ++ * qed_iov_search_list_tlvs(): Search extended TLVs in request/reply buffer. + * +- * @param p_hwfn +- * @param p_tlvs_list - Pointer to tlvs list +- * @param req_type - Type of TLV ++ * @p_hwfn: HW device data. ++ * @p_tlvs_list: Pointer to tlvs list ++ * @req_type: Type of TLV + * +- * @return pointer to tlv type if found, otherwise returns NULL. ++ * Return: pointer to tlv type if found, otherwise returns NULL. + */ + void *qed_iov_search_list_tlvs(struct qed_hwfn *p_hwfn, + void *p_tlvs_list, u16 req_type); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_vf.h b/drivers/net/ethernet/qlogic/qed/qed_vf.h +index 60d2bb64e65fb..976201fc7d4ae 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_vf.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_vf.h +@@ -688,13 +688,16 @@ struct qed_vf_iov { + }; + + /** +- * @brief VF - Set Rx/Tx coalesce per VF's relative queue. +- * Coalesce value '0' will omit the configuration. ++ * qed_vf_pf_set_coalesce(): VF - Set Rx/Tx coalesce per VF's relative queue. ++ * Coalesce value '0' will omit the ++ * configuration. + * +- * @param p_hwfn +- * @param rx_coal - coalesce value in micro second for rx queue +- * @param tx_coal - coalesce value in micro second for tx queue +- * @param p_cid - queue cid ++ * @p_hwfn: HW device data. ++ * @rx_coal: coalesce value in micro second for rx queue. ++ * @tx_coal: coalesce value in micro second for tx queue. ++ * @p_cid: queue cid. ++ * ++ * Return: Int. + * + **/ + int qed_vf_pf_set_coalesce(struct qed_hwfn *p_hwfn, +@@ -702,148 +705,172 @@ int qed_vf_pf_set_coalesce(struct qed_hwfn *p_hwfn, + u16 tx_coal, struct qed_queue_cid *p_cid); + + /** +- * @brief VF - Get coalesce per VF's relative queue. ++ * qed_vf_pf_get_coalesce(): VF - Get coalesce per VF's relative queue. + * +- * @param p_hwfn +- * @param p_coal - coalesce value in micro second for VF queues. +- * @param p_cid - queue cid ++ * @p_hwfn: HW device data. ++ * @p_coal: coalesce value in micro second for VF queues. ++ * @p_cid: queue cid. + * ++ * Return: Int. + **/ + int qed_vf_pf_get_coalesce(struct qed_hwfn *p_hwfn, + u16 *p_coal, struct qed_queue_cid *p_cid); + + #ifdef CONFIG_QED_SRIOV + /** +- * @brief Read the VF bulletin and act on it if needed ++ * qed_vf_read_bulletin(): Read the VF bulletin and act on it if needed. + * +- * @param p_hwfn +- * @param p_change - qed fills 1 iff bulletin board has changed, 0 otherwise. ++ * @p_hwfn: HW device data. ++ * @p_change: qed fills 1 iff bulletin board has changed, 0 otherwise. + * +- * @return enum _qed_status ++ * Return: enum _qed_status. + */ + int qed_vf_read_bulletin(struct qed_hwfn *p_hwfn, u8 *p_change); + + /** +- * @brief Get link paramters for VF from qed ++ * qed_vf_get_link_params(): Get link parameters for VF from qed ++ * ++ * @p_hwfn: HW device data. ++ * @params: the link params structure to be filled for the VF. + * +- * @param p_hwfn +- * @param params - the link params structure to be filled for the VF ++ * Return: Void. + */ + void qed_vf_get_link_params(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_params *params); + + /** +- * @brief Get link state for VF from qed ++ * qed_vf_get_link_state(): Get link state for VF from qed. ++ * ++ * @p_hwfn: HW device data. ++ * @link: the link state structure to be filled for the VF + * +- * @param p_hwfn +- * @param link - the link state structure to be filled for the VF ++ * Return: Void. + */ + void qed_vf_get_link_state(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_state *link); + + /** +- * @brief Get link capabilities for VF from qed ++ * qed_vf_get_link_caps(): Get link capabilities for VF from qed. + * +- * @param p_hwfn +- * @param p_link_caps - the link capabilities structure to be filled for the VF ++ * @p_hwfn: HW device data. ++ * @p_link_caps: the link capabilities structure to be filled for the VF ++ * ++ * Return: Void. + */ + void qed_vf_get_link_caps(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_capabilities *p_link_caps); + + /** +- * @brief Get number of Rx queues allocated for VF by qed ++ * qed_vf_get_num_rxqs(): Get number of Rx queues allocated for VF by qed ++ * ++ * @p_hwfn: HW device data. ++ * @num_rxqs: allocated RX queues + * +- * @param p_hwfn +- * @param num_rxqs - allocated RX queues ++ * Return: Void. + */ + void qed_vf_get_num_rxqs(struct qed_hwfn *p_hwfn, u8 *num_rxqs); + + /** +- * @brief Get number of Rx queues allocated for VF by qed ++ * qed_vf_get_num_txqs(): Get number of Rx queues allocated for VF by qed + * +- * @param p_hwfn +- * @param num_txqs - allocated RX queues ++ * @p_hwfn: HW device data. ++ * @num_txqs: allocated RX queues ++ * ++ * Return: Void. + */ + void qed_vf_get_num_txqs(struct qed_hwfn *p_hwfn, u8 *num_txqs); + + /** +- * @brief Get number of available connections [both Rx and Tx] for VF ++ * qed_vf_get_num_cids(): Get number of available connections ++ * [both Rx and Tx] for VF ++ * ++ * @p_hwfn: HW device data. ++ * @num_cids: allocated number of connections + * +- * @param p_hwfn +- * @param num_cids - allocated number of connections ++ * Return: Void. + */ + void qed_vf_get_num_cids(struct qed_hwfn *p_hwfn, u8 *num_cids); + + /** +- * @brief Get port mac address for VF ++ * qed_vf_get_port_mac(): Get port mac address for VF. + * +- * @param p_hwfn +- * @param port_mac - destination location for port mac ++ * @p_hwfn: HW device data. ++ * @port_mac: destination location for port mac ++ * ++ * Return: Void. + */ + void qed_vf_get_port_mac(struct qed_hwfn *p_hwfn, u8 *port_mac); + + /** +- * @brief Get number of VLAN filters allocated for VF by qed ++ * qed_vf_get_num_vlan_filters(): Get number of VLAN filters allocated ++ * for VF by qed. ++ * ++ * @p_hwfn: HW device data. ++ * @num_vlan_filters: allocated VLAN filters + * +- * @param p_hwfn +- * @param num_rxqs - allocated VLAN filters ++ * Return: Void. + */ + void qed_vf_get_num_vlan_filters(struct qed_hwfn *p_hwfn, + u8 *num_vlan_filters); + + /** +- * @brief Get number of MAC filters allocated for VF by qed ++ * qed_vf_get_num_mac_filters(): Get number of MAC filters allocated ++ * for VF by qed + * +- * @param p_hwfn +- * @param num_rxqs - allocated MAC filters ++ * @p_hwfn: HW device data. ++ * @num_mac_filters: allocated MAC filters ++ * ++ * Return: Void. + */ + void qed_vf_get_num_mac_filters(struct qed_hwfn *p_hwfn, u8 *num_mac_filters); + + /** +- * @brief Check if VF can set a MAC address ++ * qed_vf_check_mac(): Check if VF can set a MAC address + * +- * @param p_hwfn +- * @param mac ++ * @p_hwfn: HW device data. ++ * @mac: Mac. + * +- * @return bool ++ * Return: bool. + */ + bool qed_vf_check_mac(struct qed_hwfn *p_hwfn, u8 *mac); + + /** +- * @brief Set firmware version information in dev_info from VFs acquire response tlv ++ * qed_vf_get_fw_version(): Set firmware version information ++ * in dev_info from VFs acquire response tlv ++ * ++ * @p_hwfn: HW device data. ++ * @fw_major: FW major. ++ * @fw_minor: FW minor. ++ * @fw_rev: FW rev. ++ * @fw_eng: FW eng. + * +- * @param p_hwfn +- * @param fw_major +- * @param fw_minor +- * @param fw_rev +- * @param fw_eng ++ * Return: Void. + */ + void qed_vf_get_fw_version(struct qed_hwfn *p_hwfn, + u16 *fw_major, u16 *fw_minor, + u16 *fw_rev, u16 *fw_eng); + + /** +- * @brief hw preparation for VF +- * sends ACQUIRE message ++ * qed_vf_hw_prepare(): hw preparation for VF sends ACQUIRE message + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return int ++ * Return: Int. + */ + int qed_vf_hw_prepare(struct qed_hwfn *p_hwfn); + + /** +- * @brief VF - start the RX Queue by sending a message to the PF +- * @param p_hwfn +- * @param p_cid - Only relative fields are relevant +- * @param bd_max_bytes - maximum number of bytes per bd +- * @param bd_chain_phys_addr - physical address of bd chain +- * @param cqe_pbl_addr - physical address of pbl +- * @param cqe_pbl_size - pbl size +- * @param pp_prod - pointer to the producer to be +- * used in fastpath ++ * qed_vf_pf_rxq_start(): start the RX Queue by sending a message to the PF ++ * ++ * @p_hwfn: HW device data. ++ * @p_cid: Only relative fields are relevant ++ * @bd_max_bytes: maximum number of bytes per bd ++ * @bd_chain_phys_addr: physical address of bd chain ++ * @cqe_pbl_addr: physical address of pbl ++ * @cqe_pbl_size: pbl size ++ * @pp_prod: pointer to the producer to be used in fastpath + * +- * @return int ++ * Return: Int. + */ + int qed_vf_pf_rxq_start(struct qed_hwfn *p_hwfn, + struct qed_queue_cid *p_cid, +@@ -853,18 +880,16 @@ int qed_vf_pf_rxq_start(struct qed_hwfn *p_hwfn, + u16 cqe_pbl_size, void __iomem **pp_prod); + + /** +- * @brief VF - start the TX queue by sending a message to the +- * PF. ++ * qed_vf_pf_txq_start(): VF - start the TX queue by sending a message to the ++ * PF. + * +- * @param p_hwfn +- * @param tx_queue_id - zero based within the VF +- * @param sb - status block for this queue +- * @param sb_index - index within the status block +- * @param bd_chain_phys_addr - physical address of tx chain +- * @param pp_doorbell - pointer to address to which to +- * write the doorbell too.. ++ * @p_hwfn: HW device data. ++ * @p_cid: CID. ++ * @pbl_addr: PBL address. ++ * @pbl_size: PBL Size. ++ * @pp_doorbell: pointer to address to which to write the doorbell too. + * +- * @return int ++ * Return: Int. + */ + int + qed_vf_pf_txq_start(struct qed_hwfn *p_hwfn, +@@ -873,90 +898,91 @@ qed_vf_pf_txq_start(struct qed_hwfn *p_hwfn, + u16 pbl_size, void __iomem **pp_doorbell); + + /** +- * @brief VF - stop the RX queue by sending a message to the PF ++ * qed_vf_pf_rxq_stop(): VF - stop the RX queue by sending a message to the PF. + * +- * @param p_hwfn +- * @param p_cid +- * @param cqe_completion ++ * @p_hwfn: HW device data. ++ * @p_cid: CID. ++ * @cqe_completion: CQE Completion. + * +- * @return int ++ * Return: Int. + */ + int qed_vf_pf_rxq_stop(struct qed_hwfn *p_hwfn, + struct qed_queue_cid *p_cid, bool cqe_completion); + + /** +- * @brief VF - stop the TX queue by sending a message to the PF ++ * qed_vf_pf_txq_stop(): VF - stop the TX queue by sending a message to the PF. + * +- * @param p_hwfn +- * @param tx_qid ++ * @p_hwfn: HW device data. ++ * @p_cid: CID. + * +- * @return int ++ * Return: Int. + */ + int qed_vf_pf_txq_stop(struct qed_hwfn *p_hwfn, struct qed_queue_cid *p_cid); + + /** +- * @brief VF - send a vport update command ++ * qed_vf_pf_vport_update(): VF - send a vport update command. + * +- * @param p_hwfn +- * @param params ++ * @p_hwfn: HW device data. ++ * @p_params: Params + * +- * @return int ++ * Return: Int. + */ + int qed_vf_pf_vport_update(struct qed_hwfn *p_hwfn, + struct qed_sp_vport_update_params *p_params); + + /** ++ * qed_vf_pf_reset(): VF - send a close message to PF. + * +- * @brief VF - send a close message to PF ++ * @p_hwfn: HW device data. + * +- * @param p_hwfn +- * +- * @return enum _qed_status ++ * Return: enum _qed_status + */ + int qed_vf_pf_reset(struct qed_hwfn *p_hwfn); + + /** +- * @brief VF - free vf`s memories ++ * qed_vf_pf_release(): VF - free vf`s memories. + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return enum _qed_status ++ * Return: enum _qed_status + */ + int qed_vf_pf_release(struct qed_hwfn *p_hwfn); + + /** +- * @brief qed_vf_get_igu_sb_id - Get the IGU SB ID for a given ++ * qed_vf_get_igu_sb_id(): Get the IGU SB ID for a given + * sb_id. For VFs igu sbs don't have to be contiguous + * +- * @param p_hwfn +- * @param sb_id ++ * @p_hwfn: HW device data. ++ * @sb_id: SB ID. + * +- * @return INLINE u16 ++ * Return: INLINE u16 + */ + u16 qed_vf_get_igu_sb_id(struct qed_hwfn *p_hwfn, u16 sb_id); + + /** +- * @brief Stores [or removes] a configured sb_info. ++ * qed_vf_set_sb_info(): Stores [or removes] a configured sb_info. ++ * ++ * @p_hwfn: HW device data. ++ * @sb_id: zero-based SB index [for fastpath] ++ * @p_sb: may be NULL [during removal]. + * +- * @param p_hwfn +- * @param sb_id - zero-based SB index [for fastpath] +- * @param sb_info - may be NULL [during removal]. ++ * Return: Void. + */ + void qed_vf_set_sb_info(struct qed_hwfn *p_hwfn, + u16 sb_id, struct qed_sb_info *p_sb); + + /** +- * @brief qed_vf_pf_vport_start - perform vport start for VF. ++ * qed_vf_pf_vport_start(): perform vport start for VF. + * +- * @param p_hwfn +- * @param vport_id +- * @param mtu +- * @param inner_vlan_removal +- * @param tpa_mode +- * @param max_buffers_per_cqe, +- * @param only_untagged - default behavior regarding vlan acceptance ++ * @p_hwfn: HW device data. ++ * @vport_id: Vport ID. ++ * @mtu: MTU. ++ * @inner_vlan_removal: Innter VLAN removal. ++ * @tpa_mode: TPA mode ++ * @max_buffers_per_cqe: Max buffer pre CQE. ++ * @only_untagged: default behavior regarding vlan acceptance + * +- * @return enum _qed_status ++ * Return: enum _qed_status + */ + int qed_vf_pf_vport_start(struct qed_hwfn *p_hwfn, + u8 vport_id, +@@ -966,11 +992,11 @@ int qed_vf_pf_vport_start(struct qed_hwfn *p_hwfn, + u8 max_buffers_per_cqe, u8 only_untagged); + + /** +- * @brief qed_vf_pf_vport_stop - stop the VF's vport ++ * qed_vf_pf_vport_stop(): stop the VF's vport + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return enum _qed_status ++ * Return: enum _qed_status + */ + int qed_vf_pf_vport_stop(struct qed_hwfn *p_hwfn); + +@@ -981,42 +1007,49 @@ void qed_vf_pf_filter_mcast(struct qed_hwfn *p_hwfn, + struct qed_filter_mcast *p_filter_cmd); + + /** +- * @brief qed_vf_pf_int_cleanup - clean the SB of the VF ++ * qed_vf_pf_int_cleanup(): clean the SB of the VF + * +- * @param p_hwfn ++ * @p_hwfn: HW device data. + * +- * @return enum _qed_status ++ * Return: enum _qed_status + */ + int qed_vf_pf_int_cleanup(struct qed_hwfn *p_hwfn); + + /** +- * @brief - return the link params in a given bulletin board ++ * __qed_vf_get_link_params(): return the link params in a given bulletin board + * +- * @param p_hwfn +- * @param p_params - pointer to a struct to fill with link params +- * @param p_bulletin ++ * @p_hwfn: HW device data. ++ * @p_params: pointer to a struct to fill with link params ++ * @p_bulletin: Bulletin. ++ * ++ * Return: Void. + */ + void __qed_vf_get_link_params(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_params *p_params, + struct qed_bulletin_content *p_bulletin); + + /** +- * @brief - return the link state in a given bulletin board ++ * __qed_vf_get_link_state(): return the link state in a given bulletin board ++ * ++ * @p_hwfn: HW device data. ++ * @p_link: pointer to a struct to fill with link state ++ * @p_bulletin: Bulletin. + * +- * @param p_hwfn +- * @param p_link - pointer to a struct to fill with link state +- * @param p_bulletin ++ * Return: Void. + */ + void __qed_vf_get_link_state(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_state *p_link, + struct qed_bulletin_content *p_bulletin); + + /** +- * @brief - return the link capabilities in a given bulletin board ++ * __qed_vf_get_link_caps(): return the link capabilities in a given ++ * bulletin board + * +- * @param p_hwfn +- * @param p_link - pointer to a struct to fill with link capabilities +- * @param p_bulletin ++ * @p_hwfn: HW device data. ++ * @p_link_caps: pointer to a struct to fill with link capabilities ++ * @p_bulletin: Bulletin. ++ * ++ * Return: Void. + */ + void __qed_vf_get_link_caps(struct qed_hwfn *p_hwfn, + struct qed_mcp_link_capabilities *p_link_caps, +@@ -1029,9 +1062,13 @@ int qed_vf_pf_tunnel_param_update(struct qed_hwfn *p_hwfn, + + u32 qed_vf_hw_bar_size(struct qed_hwfn *p_hwfn, enum BAR_ID bar_id); + /** +- * @brief - Ask PF to update the MAC address in it's bulletin board ++ * qed_vf_pf_bulletin_update_mac(): Ask PF to update the MAC address in ++ * it's bulletin board ++ * ++ * @p_hwfn: HW device data. ++ * @p_mac: mac address to be updated in bulletin board + * +- * @param p_mac - mac address to be updated in bulletin board ++ * Return: Int. + */ + int qed_vf_pf_bulletin_update_mac(struct qed_hwfn *p_hwfn, u8 *p_mac); + +diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c +index 6c22bfc16ee6b..fee47c8eeff49 100644 +--- a/drivers/net/ethernet/qlogic/qede/qede_main.c ++++ b/drivers/net/ethernet/qlogic/qede/qede_main.c +@@ -2832,10 +2832,13 @@ static void qede_get_eth_tlv_data(void *dev, void *data) + } + + /** +- * qede_io_error_detected - called when PCI error is detected ++ * qede_io_error_detected(): Called when PCI error is detected ++ * + * @pdev: Pointer to PCI device + * @state: The current pci connection state + * ++ *Return: pci_ers_result_t. ++ * + * This function is called after a PCI bus error affecting + * this device has been detected. + */ +diff --git a/include/linux/qed/qed_chain.h b/include/linux/qed/qed_chain.h +index f34dbd0db7952..a84063492c71a 100644 +--- a/include/linux/qed/qed_chain.h ++++ b/include/linux/qed/qed_chain.h +@@ -268,14 +268,15 @@ static inline dma_addr_t qed_chain_get_pbl_phys(const struct qed_chain *chain) + } + + /** +- * @brief qed_chain_advance_page - ++ * qed_chain_advance_page(): Advance the next element across pages for a ++ * linked chain. + * +- * Advance the next element across pages for a linked chain ++ * @p_chain: P_chain. ++ * @p_next_elem: P_next_elem. ++ * @idx_to_inc: Idx_to_inc. ++ * @page_to_inc: page_to_inc. + * +- * @param p_chain +- * @param p_next_elem +- * @param idx_to_inc +- * @param page_to_inc ++ * Return: Void. + */ + static inline void + qed_chain_advance_page(struct qed_chain *p_chain, +@@ -336,12 +337,14 @@ qed_chain_advance_page(struct qed_chain *p_chain, + } while (0) + + /** +- * @brief qed_chain_return_produced - ++ * qed_chain_return_produced(): A chain in which the driver "Produces" ++ * elements should use this API ++ * to indicate previous produced elements ++ * are now consumed. + * +- * A chain in which the driver "Produces" elements should use this API +- * to indicate previous produced elements are now consumed. ++ * @p_chain: Chain. + * +- * @param p_chain ++ * Return: Void. + */ + static inline void qed_chain_return_produced(struct qed_chain *p_chain) + { +@@ -353,15 +356,15 @@ static inline void qed_chain_return_produced(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_produce - ++ * qed_chain_produce(): A chain in which the driver "Produces" ++ * elements should use this to get a pointer to ++ * the next element which can be "Produced". It's driver ++ * responsibility to validate that the chain has room for ++ * new element. + * +- * A chain in which the driver "Produces" elements should use this to get +- * a pointer to the next element which can be "Produced". It's driver +- * responsibility to validate that the chain has room for new element. ++ * @p_chain: Chain. + * +- * @param p_chain +- * +- * @return void*, a pointer to next element ++ * Return: void*, a pointer to next element. + */ + static inline void *qed_chain_produce(struct qed_chain *p_chain) + { +@@ -395,14 +398,11 @@ static inline void *qed_chain_produce(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_get_capacity - +- * +- * Get the maximum number of BDs in chain ++ * qed_chain_get_capacity(): Get the maximum number of BDs in chain + * +- * @param p_chain +- * @param num ++ * @p_chain: Chain. + * +- * @return number of unusable BDs ++ * Return: number of unusable BDs. + */ + static inline u32 qed_chain_get_capacity(struct qed_chain *p_chain) + { +@@ -410,12 +410,14 @@ static inline u32 qed_chain_get_capacity(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_recycle_consumed - ++ * qed_chain_recycle_consumed(): Returns an element which was ++ * previously consumed; ++ * Increments producers so they could ++ * be written to FW. + * +- * Returns an element which was previously consumed; +- * Increments producers so they could be written to FW. ++ * @p_chain: Chain. + * +- * @param p_chain ++ * Return: Void. + */ + static inline void qed_chain_recycle_consumed(struct qed_chain *p_chain) + { +@@ -427,14 +429,13 @@ static inline void qed_chain_recycle_consumed(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_consume - ++ * qed_chain_consume(): A Chain in which the driver utilizes data written ++ * by a different source (i.e., FW) should use this to ++ * access passed buffers. + * +- * A Chain in which the driver utilizes data written by a different source +- * (i.e., FW) should use this to access passed buffers. ++ * @p_chain: Chain. + * +- * @param p_chain +- * +- * @return void*, a pointer to the next buffer written ++ * Return: void*, a pointer to the next buffer written. + */ + static inline void *qed_chain_consume(struct qed_chain *p_chain) + { +@@ -468,9 +469,11 @@ static inline void *qed_chain_consume(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_reset - Resets the chain to its start state ++ * qed_chain_reset(): Resets the chain to its start state. ++ * ++ * @p_chain: pointer to a previously allocated chain. + * +- * @param p_chain pointer to a previously allocated chain ++ * Return Void. + */ + static inline void qed_chain_reset(struct qed_chain *p_chain) + { +@@ -519,13 +522,12 @@ static inline void qed_chain_reset(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_get_last_elem - ++ * qed_chain_get_last_elem(): Returns a pointer to the last element of the ++ * chain. + * +- * Returns a pointer to the last element of the chain ++ * @p_chain: Chain. + * +- * @param p_chain +- * +- * @return void* ++ * Return: void*. + */ + static inline void *qed_chain_get_last_elem(struct qed_chain *p_chain) + { +@@ -563,10 +565,13 @@ static inline void *qed_chain_get_last_elem(struct qed_chain *p_chain) + } + + /** +- * @brief qed_chain_set_prod - sets the prod to the given value ++ * qed_chain_set_prod(): sets the prod to the given value. ++ * ++ * @p_chain: Chain. ++ * @prod_idx: Prod Idx. ++ * @p_prod_elem: Prod elem. + * +- * @param prod_idx +- * @param p_prod_elem ++ * Return Void. + */ + static inline void qed_chain_set_prod(struct qed_chain *p_chain, + u32 prod_idx, void *p_prod_elem) +@@ -610,9 +615,11 @@ static inline void qed_chain_set_prod(struct qed_chain *p_chain, + } + + /** +- * @brief qed_chain_pbl_zero_mem - set chain memory to 0 ++ * qed_chain_pbl_zero_mem(): set chain memory to 0. ++ * ++ * @p_chain: Chain. + * +- * @param p_chain ++ * Return: Void. + */ + static inline void qed_chain_pbl_zero_mem(struct qed_chain *p_chain) + { +diff --git a/include/linux/qed/qed_if.h b/include/linux/qed/qed_if.h +index 850b989916703..f39451aaaeec2 100644 +--- a/include/linux/qed/qed_if.h ++++ b/include/linux/qed/qed_if.h +@@ -819,47 +819,47 @@ struct qed_common_cb_ops { + + struct qed_selftest_ops { + /** +- * @brief selftest_interrupt - Perform interrupt test ++ * selftest_interrupt(): Perform interrupt test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*selftest_interrupt)(struct qed_dev *cdev); + + /** +- * @brief selftest_memory - Perform memory test ++ * selftest_memory(): Perform memory test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*selftest_memory)(struct qed_dev *cdev); + + /** +- * @brief selftest_register - Perform register test ++ * selftest_register(): Perform register test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*selftest_register)(struct qed_dev *cdev); + + /** +- * @brief selftest_clock - Perform clock test ++ * selftest_clock(): Perform clock test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*selftest_clock)(struct qed_dev *cdev); + + /** +- * @brief selftest_nvram - Perform nvram test ++ * selftest_nvram(): Perform nvram test. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*selftest_nvram) (struct qed_dev *cdev); + }; +@@ -927,47 +927,53 @@ struct qed_common_ops { + enum qed_hw_err_type err_type); + + /** +- * @brief can_link_change - can the instance change the link or not ++ * can_link_change(): can the instance change the link or not. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return true if link-change is allowed, false otherwise. ++ * Return: true if link-change is allowed, false otherwise. + */ + bool (*can_link_change)(struct qed_dev *cdev); + + /** +- * @brief set_link - set links according to params ++ * set_link(): set links according to params. + * +- * @param cdev +- * @param params - values used to override the default link configuration ++ * @cdev: Qed dev pointer. ++ * @params: values used to override the default link configuration. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*set_link)(struct qed_dev *cdev, + struct qed_link_params *params); + + /** +- * @brief get_link - returns the current link state. ++ * get_link(): returns the current link state. + * +- * @param cdev +- * @param if_link - structure to be filled with current link configuration. ++ * @cdev: Qed dev pointer. ++ * @if_link: structure to be filled with current link configuration. ++ * ++ * Return: Void. + */ + void (*get_link)(struct qed_dev *cdev, + struct qed_link_output *if_link); + + /** +- * @brief - drains chip in case Tx completions fail to arrive due to pause. ++ * drain(): drains chip in case Tx completions fail to arrive due to pause. ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: Int. + */ + int (*drain)(struct qed_dev *cdev); + + /** +- * @brief update_msglvl - update module debug level ++ * update_msglvl(): update module debug level. + * +- * @param cdev +- * @param dp_module +- * @param dp_level ++ * @cdev: Qed dev pointer. ++ * @dp_module: Debug module. ++ * @dp_level: Debug level. ++ * ++ * Return: Void. + */ + void (*update_msglvl)(struct qed_dev *cdev, + u32 dp_module, +@@ -981,70 +987,73 @@ struct qed_common_ops { + struct qed_chain *p_chain); + + /** +- * @brief nvm_flash - Flash nvm data. ++ * nvm_flash(): Flash nvm data. + * +- * @param cdev +- * @param name - file containing the data ++ * @cdev: Qed dev pointer. ++ * @name: file containing the data. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*nvm_flash)(struct qed_dev *cdev, const char *name); + + /** +- * @brief nvm_get_image - reads an entire image from nvram ++ * nvm_get_image(): reads an entire image from nvram. + * +- * @param cdev +- * @param type - type of the request nvram image +- * @param buf - preallocated buffer to fill with the image +- * @param len - length of the allocated buffer ++ * @cdev: Qed dev pointer. ++ * @type: type of the request nvram image. ++ * @buf: preallocated buffer to fill with the image. ++ * @len: length of the allocated buffer. + * +- * @return 0 on success, error otherwise ++ * Return: 0 on success, error otherwise. + */ + int (*nvm_get_image)(struct qed_dev *cdev, + enum qed_nvm_images type, u8 *buf, u16 len); + + /** +- * @brief set_coalesce - Configure Rx coalesce value in usec ++ * set_coalesce(): Configure Rx coalesce value in usec. + * +- * @param cdev +- * @param rx_coal - Rx coalesce value in usec +- * @param tx_coal - Tx coalesce value in usec +- * @param qid - Queue index +- * @param sb_id - Status Block Id ++ * @cdev: Qed dev pointer. ++ * @rx_coal: Rx coalesce value in usec. ++ * @tx_coal: Tx coalesce value in usec. ++ * @handle: Handle. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*set_coalesce)(struct qed_dev *cdev, + u16 rx_coal, u16 tx_coal, void *handle); + + /** +- * @brief set_led - Configure LED mode ++ * set_led() - Configure LED mode. + * +- * @param cdev +- * @param mode - LED mode ++ * @cdev: Qed dev pointer. ++ * @mode: LED mode. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*set_led)(struct qed_dev *cdev, + enum qed_led_mode mode); + + /** +- * @brief attn_clr_enable - Prevent attentions from being reasserted ++ * attn_clr_enable(): Prevent attentions from being reasserted. ++ * ++ * @cdev: Qed dev pointer. ++ * @clr_enable: Clear enable. + * +- * @param cdev +- * @param clr_enable ++ * Return: Void. + */ + void (*attn_clr_enable)(struct qed_dev *cdev, bool clr_enable); + + /** +- * @brief db_recovery_add - add doorbell information to the doorbell +- * recovery mechanism. ++ * db_recovery_add(): add doorbell information to the doorbell ++ * recovery mechanism. + * +- * @param cdev +- * @param db_addr - doorbell address +- * @param db_data - address of where db_data is stored +- * @param db_is_32b - doorbell is 32b pr 64b +- * @param db_is_user - doorbell recovery addresses are user or kernel space ++ * @cdev: Qed dev pointer. ++ * @db_addr: Doorbell address. ++ * @db_data: Dddress of where db_data is stored. ++ * @db_width: Doorbell is 32b or 64b. ++ * @db_space: Doorbell recovery addresses are user or kernel space. ++ * ++ * Return: Int. + */ + int (*db_recovery_add)(struct qed_dev *cdev, + void __iomem *db_addr, +@@ -1053,114 +1062,130 @@ struct qed_common_ops { + enum qed_db_rec_space db_space); + + /** +- * @brief db_recovery_del - remove doorbell information from the doorbell ++ * db_recovery_del(): remove doorbell information from the doorbell + * recovery mechanism. db_data serves as key (db_addr is not unique). + * +- * @param cdev +- * @param db_addr - doorbell address +- * @param db_data - address where db_data is stored. Serves as key for the +- * entry to delete. ++ * @cdev: Qed dev pointer. ++ * @db_addr: Doorbell address. ++ * @db_data: Address where db_data is stored. Serves as key for the ++ * entry to delete. ++ * ++ * Return: Int. + */ + int (*db_recovery_del)(struct qed_dev *cdev, + void __iomem *db_addr, void *db_data); + + /** +- * @brief recovery_process - Trigger a recovery process ++ * recovery_process(): Trigger a recovery process. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*recovery_process)(struct qed_dev *cdev); + + /** +- * @brief recovery_prolog - Execute the prolog operations of a recovery process ++ * recovery_prolog(): Execute the prolog operations of a recovery process. + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*recovery_prolog)(struct qed_dev *cdev); + + /** +- * @brief update_drv_state - API to inform the change in the driver state. ++ * update_drv_state(): API to inform the change in the driver state. + * +- * @param cdev +- * @param active ++ * @cdev: Qed dev pointer. ++ * @active: Active + * ++ * Return: Int. + */ + int (*update_drv_state)(struct qed_dev *cdev, bool active); + + /** +- * @brief update_mac - API to inform the change in the mac address ++ * update_mac(): API to inform the change in the mac address. + * +- * @param cdev +- * @param mac ++ * @cdev: Qed dev pointer. ++ * @mac: MAC. + * ++ * Return: Int. + */ + int (*update_mac)(struct qed_dev *cdev, u8 *mac); + + /** +- * @brief update_mtu - API to inform the change in the mtu ++ * update_mtu(): API to inform the change in the mtu. + * +- * @param cdev +- * @param mtu ++ * @cdev: Qed dev pointer. ++ * @mtu: MTU. + * ++ * Return: Int. + */ + int (*update_mtu)(struct qed_dev *cdev, u16 mtu); + + /** +- * @brief update_wol - update of changes in the WoL configuration ++ * update_wol(): Update of changes in the WoL configuration. ++ * ++ * @cdev: Qed dev pointer. ++ * @enabled: true iff WoL should be enabled. + * +- * @param cdev +- * @param enabled - true iff WoL should be enabled. ++ * Return: Int. + */ + int (*update_wol) (struct qed_dev *cdev, bool enabled); + + /** +- * @brief read_module_eeprom ++ * read_module_eeprom(): Read EEPROM. + * +- * @param cdev +- * @param buf - buffer +- * @param dev_addr - PHY device memory region +- * @param offset - offset into eeprom contents to be read +- * @param len - buffer length, i.e., max bytes to be read ++ * @cdev: Qed dev pointer. ++ * @buf: buffer. ++ * @dev_addr: PHY device memory region. ++ * @offset: offset into eeprom contents to be read. ++ * @len: buffer length, i.e., max bytes to be read. ++ * ++ * Return: Int. + */ + int (*read_module_eeprom)(struct qed_dev *cdev, + char *buf, u8 dev_addr, u32 offset, u32 len); + + /** +- * @brief get_affin_hwfn_idx ++ * get_affin_hwfn_idx(): Get affine HW function. ++ * ++ * @cdev: Qed dev pointer. + * +- * @param cdev ++ * Return: u8. + */ + u8 (*get_affin_hwfn_idx)(struct qed_dev *cdev); + + /** +- * @brief read_nvm_cfg - Read NVM config attribute value. +- * @param cdev +- * @param buf - buffer +- * @param cmd - NVM CFG command id +- * @param entity_id - Entity id ++ * read_nvm_cfg(): Read NVM config attribute value. ++ * ++ * @cdev: Qed dev pointer. ++ * @buf: Buffer. ++ * @cmd: NVM CFG command id. ++ * @entity_id: Entity id. + * ++ * Return: Int. + */ + int (*read_nvm_cfg)(struct qed_dev *cdev, u8 **buf, u32 cmd, + u32 entity_id); + /** +- * @brief read_nvm_cfg - Read NVM config attribute value. +- * @param cdev +- * @param cmd - NVM CFG command id ++ * read_nvm_cfg_len(): Read NVM config attribute value. + * +- * @return config id length, 0 on error. ++ * @cdev: Qed dev pointer. ++ * @cmd: NVM CFG command id. ++ * ++ * Return: config id length, 0 on error. + */ + int (*read_nvm_cfg_len)(struct qed_dev *cdev, u32 cmd); + + /** +- * @brief set_grc_config - Configure value for grc config id. +- * @param cdev +- * @param cfg_id - grc config id +- * @param val - grc config value ++ * set_grc_config(): Configure value for grc config id. ++ * ++ * @cdev: Qed dev pointer. ++ * @cfg_id: grc config id ++ * @val: grc config value + * ++ * Return: Int. + */ + int (*set_grc_config)(struct qed_dev *cdev, u32 cfg_id, u32 val); + +@@ -1397,18 +1422,16 @@ static inline u16 qed_sb_update_sb_idx(struct qed_sb_info *sb_info) + } + + /** ++ * qed_sb_ack(): This function creates an update command for interrupts ++ * that is written to the IGU. + * +- * @brief This function creates an update command for interrupts that is +- * written to the IGU. +- * +- * @param sb_info - This is the structure allocated and +- * initialized per status block. Assumption is +- * that it was initialized using qed_sb_init +- * @param int_cmd - Enable/Disable/Nop +- * @param upd_flg - whether igu consumer should be +- * updated. ++ * @sb_info: This is the structure allocated and ++ * initialized per status block. Assumption is ++ * that it was initialized using qed_sb_init ++ * @int_cmd: Enable/Disable/Nop ++ * @upd_flg: Whether igu consumer should be updated. + * +- * @return inline void ++ * Return: inline void. + */ + static inline void qed_sb_ack(struct qed_sb_info *sb_info, + enum igu_int_cmd int_cmd, +diff --git a/include/linux/qed/qed_iscsi_if.h b/include/linux/qed/qed_iscsi_if.h +index 04180d9af560e..494cdc3cd840b 100644 +--- a/include/linux/qed/qed_iscsi_if.h ++++ b/include/linux/qed/qed_iscsi_if.h +@@ -182,7 +182,7 @@ struct qed_iscsi_cb_ops { + * @param stats - pointer to struck that would be filled + * we stats + * @return 0 on success, error otherwise. +- * @change_mac Change MAC of interface ++ * @change_mac: Change MAC of interface + * @param cdev + * @param handle - the connection handle. + * @param mac - new MAC to configure. +diff --git a/include/linux/qed/qed_ll2_if.h b/include/linux/qed/qed_ll2_if.h +index ff808d2488835..5b67cd03276eb 100644 +--- a/include/linux/qed/qed_ll2_if.h ++++ b/include/linux/qed/qed_ll2_if.h +@@ -208,57 +208,57 @@ enum qed_ll2_xmit_flags { + + struct qed_ll2_ops { + /** +- * @brief start - initializes ll2 ++ * start(): Initializes ll2. + * +- * @param cdev +- * @param params - protocol driver configuration for the ll2. ++ * @cdev: Qed dev pointer. ++ * @params: Protocol driver configuration for the ll2. + * +- * @return 0 on success, otherwise error value. ++ * Return: 0 on success, otherwise error value. + */ + int (*start)(struct qed_dev *cdev, struct qed_ll2_params *params); + + /** +- * @brief stop - stops the ll2 ++ * stop(): Stops the ll2 + * +- * @param cdev ++ * @cdev: Qed dev pointer. + * +- * @return 0 on success, otherwise error value. ++ * Return: 0 on success, otherwise error value. + */ + int (*stop)(struct qed_dev *cdev); + + /** +- * @brief start_xmit - transmits an skb over the ll2 interface ++ * start_xmit(): Transmits an skb over the ll2 interface + * +- * @param cdev +- * @param skb +- * @param xmit_flags - Transmit options defined by the enum qed_ll2_xmit_flags. ++ * @cdev: Qed dev pointer. ++ * @skb: SKB. ++ * @xmit_flags: Transmit options defined by the enum qed_ll2_xmit_flags. + * +- * @return 0 on success, otherwise error value. ++ * Return: 0 on success, otherwise error value. + */ + int (*start_xmit)(struct qed_dev *cdev, struct sk_buff *skb, + unsigned long xmit_flags); + + /** +- * @brief register_cb_ops - protocol driver register the callback for Rx/Tx ++ * register_cb_ops(): Protocol driver register the callback for Rx/Tx + * packets. Should be called before `start'. + * +- * @param cdev +- * @param cookie - to be passed to the callback functions. +- * @param ops - the callback functions to register for Rx / Tx. ++ * @cdev: Qed dev pointer. ++ * @cookie: to be passed to the callback functions. ++ * @ops: the callback functions to register for Rx / Tx. + * +- * @return 0 on success, otherwise error value. ++ * Return: 0 on success, otherwise error value. + */ + void (*register_cb_ops)(struct qed_dev *cdev, + const struct qed_ll2_cb_ops *ops, + void *cookie); + + /** +- * @brief get LL2 related statistics ++ * get_stats(): Get LL2 related statistics. + * +- * @param cdev +- * @param stats - pointer to struct that would be filled with stats ++ * @cdev: Qed dev pointer. ++ * @stats: Pointer to struct that would be filled with stats. + * +- * @return 0 on success, error otherwise. ++ * Return: 0 on success, error otherwise. + */ + int (*get_stats)(struct qed_dev *cdev, struct qed_ll2_stats *stats); + }; +diff --git a/include/linux/qed/qed_nvmetcp_if.h b/include/linux/qed/qed_nvmetcp_if.h +index 14671bc19ed11..1d51df347560d 100644 +--- a/include/linux/qed/qed_nvmetcp_if.h ++++ b/include/linux/qed/qed_nvmetcp_if.h +@@ -171,6 +171,23 @@ struct nvmetcp_task_params { + * @param dest_port + * @clear_all_filters: Clear all filters. + * @param cdev ++ * @init_read_io: Init read IO. ++ * @task_params ++ * @cmd_pdu_header ++ * @nvme_cmd ++ * @sgl_task_params ++ * @init_write_io: Init write IO. ++ * @task_params ++ * @cmd_pdu_header ++ * @nvme_cmd ++ * @sgl_task_params ++ * @init_icreq_exchange: Exchange ICReq. ++ * @task_params ++ * @init_conn_req_pdu_hdr ++ * @tx_sgl_task_params ++ * @rx_sgl_task_params ++ * @init_task_cleanup: Init task cleanup. ++ * @task_params + */ + struct qed_nvmetcp_ops { + const struct qed_common_ops *common; +-- +2.40.1 + diff --git a/queue-5.15/qed-fix-scheduling-in-a-tasklet-while-getting-stats.patch b/queue-5.15/qed-fix-scheduling-in-a-tasklet-while-getting-stats.patch new file mode 100644 index 00000000000..4bc88c0505c --- /dev/null +++ b/queue-5.15/qed-fix-scheduling-in-a-tasklet-while-getting-stats.patch @@ -0,0 +1,452 @@ +From 2718952e90824d9f9452c1a9763be8fdb05378aa Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 27 Jul 2023 18:26:09 +0300 +Subject: qed: Fix scheduling in a tasklet while getting stats + +From: Konstantin Khorenko + +[ Upstream commit e346e231b42bcae6822a6326acfb7b741e9e6026 ] + +Here we've got to a situation when tasklet called usleep_range() in PTT +acquire logic, thus welcome to the "scheduling while atomic" BUG(). + + BUG: scheduling while atomic: swapper/24/0/0x00000100 + + [] schedule+0x29/0x70 + [] schedule_hrtimeout_range_clock+0xb2/0x150 + [] schedule_hrtimeout_range+0x13/0x20 + [] usleep_range+0x4f/0x70 + [] qed_ptt_acquire+0x38/0x100 [qed] + [] _qed_get_vport_stats+0x458/0x580 [qed] + [] qed_get_vport_stats+0x1c/0xd0 [qed] + [] qed_get_protocol_stats+0x93/0x100 [qed] + qed_mcp_send_protocol_stats + case MFW_DRV_MSG_GET_LAN_STATS: + case MFW_DRV_MSG_GET_FCOE_STATS: + case MFW_DRV_MSG_GET_ISCSI_STATS: + case MFW_DRV_MSG_GET_RDMA_STATS: + [] qed_mcp_handle_events+0x2d8/0x890 [qed] + qed_int_assertion + qed_int_attentions + [] qed_int_sp_dpc+0xa50/0xdc0 [qed] + [] tasklet_action+0x83/0x140 + [] __do_softirq+0x125/0x2bb + [] call_softirq+0x1c/0x30 + [] do_softirq+0x65/0xa0 + [] irq_exit+0x105/0x110 + [] do_IRQ+0x56/0xf0 + +Fix this by making caller to provide the context whether it could be in +atomic context flow or not when getting stats from QED driver. +QED driver based on the context provided decide to schedule out or not +when acquiring the PTT BAR window. + +We faced the BUG_ON() while getting vport stats, but according to the +code same issue could happen for fcoe and iscsi statistics as well, so +fixing them too. + +Fixes: 6c75424612a7 ("qed: Add support for NCSI statistics.") +Fixes: 1e128c81290a ("qed: Add support for hardware offloaded FCoE.") +Fixes: 2f2b2614e893 ("qed: Provide iSCSI statistics to management") +Cc: Sudarsana Kalluru +Cc: David Miller +Cc: Manish Chopra + +Signed-off-by: Konstantin Khorenko +Reviewed-by: Simon Horman +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + drivers/net/ethernet/qlogic/qed/qed_dev_api.h | 16 ++++++++++++ + drivers/net/ethernet/qlogic/qed/qed_fcoe.c | 19 ++++++++++---- + drivers/net/ethernet/qlogic/qed/qed_fcoe.h | 17 ++++++++++-- + drivers/net/ethernet/qlogic/qed/qed_hw.c | 26 ++++++++++++++++--- + drivers/net/ethernet/qlogic/qed/qed_iscsi.c | 19 ++++++++++---- + drivers/net/ethernet/qlogic/qed/qed_iscsi.h | 8 ++++-- + drivers/net/ethernet/qlogic/qed/qed_l2.c | 19 ++++++++++---- + drivers/net/ethernet/qlogic/qed/qed_l2.h | 24 +++++++++++++++++ + drivers/net/ethernet/qlogic/qed/qed_main.c | 6 ++--- + 9 files changed, 128 insertions(+), 26 deletions(-) + +diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev_api.h b/drivers/net/ethernet/qlogic/qed/qed_dev_api.h +index f0a825b985a4b..a0a766a1723cc 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_dev_api.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_dev_api.h +@@ -194,6 +194,22 @@ void qed_hw_remove(struct qed_dev *cdev); + */ + struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn); + ++/** ++ * qed_ptt_acquire_context(): Allocate a PTT window honoring the context ++ * atomicy. ++ * ++ * @p_hwfn: HW device data. ++ * @is_atomic: Hint from the caller - if the func can sleep or not. ++ * ++ * Context: The function should not sleep in case is_atomic == true. ++ * Return: struct qed_ptt. ++ * ++ * Should be called at the entry point to the driver ++ * (at the beginning of an exported function). ++ */ ++struct qed_ptt *qed_ptt_acquire_context(struct qed_hwfn *p_hwfn, ++ bool is_atomic); ++ + /** + * qed_ptt_release(): Release PTT Window. + * +diff --git a/drivers/net/ethernet/qlogic/qed/qed_fcoe.c b/drivers/net/ethernet/qlogic/qed/qed_fcoe.c +index b768f0698170e..0c55249b3a358 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_fcoe.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_fcoe.c +@@ -694,13 +694,14 @@ static void _qed_fcoe_get_pstats(struct qed_hwfn *p_hwfn, + } + + static int qed_fcoe_get_stats(struct qed_hwfn *p_hwfn, +- struct qed_fcoe_stats *p_stats) ++ struct qed_fcoe_stats *p_stats, ++ bool is_atomic) + { + struct qed_ptt *p_ptt; + + memset(p_stats, 0, sizeof(*p_stats)); + +- p_ptt = qed_ptt_acquire(p_hwfn); ++ p_ptt = qed_ptt_acquire_context(p_hwfn, is_atomic); + + if (!p_ptt) { + DP_ERR(p_hwfn, "Failed to acquire ptt\n"); +@@ -974,19 +975,27 @@ static int qed_fcoe_destroy_conn(struct qed_dev *cdev, + QED_SPQ_MODE_EBLOCK, NULL); + } + ++static int qed_fcoe_stats_context(struct qed_dev *cdev, ++ struct qed_fcoe_stats *stats, ++ bool is_atomic) ++{ ++ return qed_fcoe_get_stats(QED_AFFIN_HWFN(cdev), stats, is_atomic); ++} ++ + static int qed_fcoe_stats(struct qed_dev *cdev, struct qed_fcoe_stats *stats) + { +- return qed_fcoe_get_stats(QED_AFFIN_HWFN(cdev), stats); ++ return qed_fcoe_stats_context(cdev, stats, false); + } + + void qed_get_protocol_stats_fcoe(struct qed_dev *cdev, +- struct qed_mcp_fcoe_stats *stats) ++ struct qed_mcp_fcoe_stats *stats, ++ bool is_atomic) + { + struct qed_fcoe_stats proto_stats; + + /* Retrieve FW statistics */ + memset(&proto_stats, 0, sizeof(proto_stats)); +- if (qed_fcoe_stats(cdev, &proto_stats)) { ++ if (qed_fcoe_stats_context(cdev, &proto_stats, is_atomic)) { + DP_VERBOSE(cdev, QED_MSG_STORAGE, + "Failed to collect FCoE statistics\n"); + return; +diff --git a/drivers/net/ethernet/qlogic/qed/qed_fcoe.h b/drivers/net/ethernet/qlogic/qed/qed_fcoe.h +index 19c85adf4ceb1..214e8299ecb4e 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_fcoe.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_fcoe.h +@@ -28,8 +28,20 @@ int qed_fcoe_alloc(struct qed_hwfn *p_hwfn); + void qed_fcoe_setup(struct qed_hwfn *p_hwfn); + + void qed_fcoe_free(struct qed_hwfn *p_hwfn); ++/** ++ * qed_get_protocol_stats_fcoe(): Fills provided statistics ++ * struct with statistics. ++ * ++ * @cdev: Qed dev pointer. ++ * @stats: Points to struct that will be filled with statistics. ++ * @is_atomic: Hint from the caller - if the func can sleep or not. ++ * ++ * Context: The function should not sleep in case is_atomic == true. ++ * Return: Void. ++ */ + void qed_get_protocol_stats_fcoe(struct qed_dev *cdev, +- struct qed_mcp_fcoe_stats *stats); ++ struct qed_mcp_fcoe_stats *stats, ++ bool is_atomic); + #else /* CONFIG_QED_FCOE */ + static inline int qed_fcoe_alloc(struct qed_hwfn *p_hwfn) + { +@@ -40,7 +52,8 @@ static inline void qed_fcoe_setup(struct qed_hwfn *p_hwfn) {} + static inline void qed_fcoe_free(struct qed_hwfn *p_hwfn) {} + + static inline void qed_get_protocol_stats_fcoe(struct qed_dev *cdev, +- struct qed_mcp_fcoe_stats *stats) ++ struct qed_mcp_fcoe_stats *stats, ++ bool is_atomic) + { + } + #endif /* CONFIG_QED_FCOE */ +diff --git a/drivers/net/ethernet/qlogic/qed/qed_hw.c b/drivers/net/ethernet/qlogic/qed/qed_hw.c +index 554f30b0cfd5e..6263f847b6b92 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_hw.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_hw.c +@@ -23,7 +23,10 @@ + #include "qed_reg_addr.h" + #include "qed_sriov.h" + +-#define QED_BAR_ACQUIRE_TIMEOUT 1000 ++#define QED_BAR_ACQUIRE_TIMEOUT_USLEEP_CNT 1000 ++#define QED_BAR_ACQUIRE_TIMEOUT_USLEEP 1000 ++#define QED_BAR_ACQUIRE_TIMEOUT_UDELAY_CNT 100000 ++#define QED_BAR_ACQUIRE_TIMEOUT_UDELAY 10 + + /* Invalid values */ + #define QED_BAR_INVALID_OFFSET (cpu_to_le32(-1)) +@@ -84,12 +87,22 @@ void qed_ptt_pool_free(struct qed_hwfn *p_hwfn) + } + + struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn) ++{ ++ return qed_ptt_acquire_context(p_hwfn, false); ++} ++ ++struct qed_ptt *qed_ptt_acquire_context(struct qed_hwfn *p_hwfn, bool is_atomic) + { + struct qed_ptt *p_ptt; +- unsigned int i; ++ unsigned int i, count; ++ ++ if (is_atomic) ++ count = QED_BAR_ACQUIRE_TIMEOUT_UDELAY_CNT; ++ else ++ count = QED_BAR_ACQUIRE_TIMEOUT_USLEEP_CNT; + + /* Take the free PTT from the list */ +- for (i = 0; i < QED_BAR_ACQUIRE_TIMEOUT; i++) { ++ for (i = 0; i < count; i++) { + spin_lock_bh(&p_hwfn->p_ptt_pool->lock); + + if (!list_empty(&p_hwfn->p_ptt_pool->free_list)) { +@@ -105,7 +118,12 @@ struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn) + } + + spin_unlock_bh(&p_hwfn->p_ptt_pool->lock); +- usleep_range(1000, 2000); ++ ++ if (is_atomic) ++ udelay(QED_BAR_ACQUIRE_TIMEOUT_UDELAY); ++ else ++ usleep_range(QED_BAR_ACQUIRE_TIMEOUT_USLEEP, ++ QED_BAR_ACQUIRE_TIMEOUT_USLEEP * 2); + } + + DP_NOTICE(p_hwfn, "PTT acquire timeout - failed to allocate PTT\n"); +diff --git a/drivers/net/ethernet/qlogic/qed/qed_iscsi.c b/drivers/net/ethernet/qlogic/qed/qed_iscsi.c +index db926d8b30334..f111391772778 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_iscsi.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_iscsi.c +@@ -1000,13 +1000,14 @@ static void _qed_iscsi_get_pstats(struct qed_hwfn *p_hwfn, + } + + static int qed_iscsi_get_stats(struct qed_hwfn *p_hwfn, +- struct qed_iscsi_stats *stats) ++ struct qed_iscsi_stats *stats, ++ bool is_atomic) + { + struct qed_ptt *p_ptt; + + memset(stats, 0, sizeof(*stats)); + +- p_ptt = qed_ptt_acquire(p_hwfn); ++ p_ptt = qed_ptt_acquire_context(p_hwfn, is_atomic); + if (!p_ptt) { + DP_ERR(p_hwfn, "Failed to acquire ptt\n"); + return -EAGAIN; +@@ -1337,9 +1338,16 @@ static int qed_iscsi_destroy_conn(struct qed_dev *cdev, + QED_SPQ_MODE_EBLOCK, NULL); + } + ++static int qed_iscsi_stats_context(struct qed_dev *cdev, ++ struct qed_iscsi_stats *stats, ++ bool is_atomic) ++{ ++ return qed_iscsi_get_stats(QED_AFFIN_HWFN(cdev), stats, is_atomic); ++} ++ + static int qed_iscsi_stats(struct qed_dev *cdev, struct qed_iscsi_stats *stats) + { +- return qed_iscsi_get_stats(QED_AFFIN_HWFN(cdev), stats); ++ return qed_iscsi_stats_context(cdev, stats, false); + } + + static int qed_iscsi_change_mac(struct qed_dev *cdev, +@@ -1359,13 +1367,14 @@ static int qed_iscsi_change_mac(struct qed_dev *cdev, + } + + void qed_get_protocol_stats_iscsi(struct qed_dev *cdev, +- struct qed_mcp_iscsi_stats *stats) ++ struct qed_mcp_iscsi_stats *stats, ++ bool is_atomic) + { + struct qed_iscsi_stats proto_stats; + + /* Retrieve FW statistics */ + memset(&proto_stats, 0, sizeof(proto_stats)); +- if (qed_iscsi_stats(cdev, &proto_stats)) { ++ if (qed_iscsi_stats_context(cdev, &proto_stats, is_atomic)) { + DP_VERBOSE(cdev, QED_MSG_STORAGE, + "Failed to collect ISCSI statistics\n"); + return; +diff --git a/drivers/net/ethernet/qlogic/qed/qed_iscsi.h b/drivers/net/ethernet/qlogic/qed/qed_iscsi.h +index dec2b00259d42..974cb8d26608c 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_iscsi.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_iscsi.h +@@ -39,11 +39,14 @@ void qed_iscsi_free(struct qed_hwfn *p_hwfn); + * + * @cdev: Qed dev pointer. + * @stats: Points to struct that will be filled with statistics. ++ * @is_atomic: Hint from the caller - if the func can sleep or not. + * ++ * Context: The function should not sleep in case is_atomic == true. + * Return: Void. + */ + void qed_get_protocol_stats_iscsi(struct qed_dev *cdev, +- struct qed_mcp_iscsi_stats *stats); ++ struct qed_mcp_iscsi_stats *stats, ++ bool is_atomic); + #else /* IS_ENABLED(CONFIG_QED_ISCSI) */ + static inline int qed_iscsi_alloc(struct qed_hwfn *p_hwfn) + { +@@ -56,7 +59,8 @@ static inline void qed_iscsi_free(struct qed_hwfn *p_hwfn) {} + + static inline void + qed_get_protocol_stats_iscsi(struct qed_dev *cdev, +- struct qed_mcp_iscsi_stats *stats) {} ++ struct qed_mcp_iscsi_stats *stats, ++ bool is_atomic) {} + #endif /* IS_ENABLED(CONFIG_QED_ISCSI) */ + + #endif +diff --git a/drivers/net/ethernet/qlogic/qed/qed_l2.c b/drivers/net/ethernet/qlogic/qed/qed_l2.c +index bc17bc36d346e..6ffa6425a75a5 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_l2.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_l2.c +@@ -1863,7 +1863,8 @@ static void __qed_get_vport_stats(struct qed_hwfn *p_hwfn, + } + + static void _qed_get_vport_stats(struct qed_dev *cdev, +- struct qed_eth_stats *stats) ++ struct qed_eth_stats *stats, ++ bool is_atomic) + { + u8 fw_vport = 0; + int i; +@@ -1872,10 +1873,11 @@ static void _qed_get_vport_stats(struct qed_dev *cdev, + + for_each_hwfn(cdev, i) { + struct qed_hwfn *p_hwfn = &cdev->hwfns[i]; +- struct qed_ptt *p_ptt = IS_PF(cdev) ? qed_ptt_acquire(p_hwfn) +- : NULL; ++ struct qed_ptt *p_ptt; + bool b_get_port_stats; + ++ p_ptt = IS_PF(cdev) ? qed_ptt_acquire_context(p_hwfn, is_atomic) ++ : NULL; + if (IS_PF(cdev)) { + /* The main vport index is relative first */ + if (qed_fw_vport(p_hwfn, 0, &fw_vport)) { +@@ -1900,6 +1902,13 @@ static void _qed_get_vport_stats(struct qed_dev *cdev, + } + + void qed_get_vport_stats(struct qed_dev *cdev, struct qed_eth_stats *stats) ++{ ++ qed_get_vport_stats_context(cdev, stats, false); ++} ++ ++void qed_get_vport_stats_context(struct qed_dev *cdev, ++ struct qed_eth_stats *stats, ++ bool is_atomic) + { + u32 i; + +@@ -1908,7 +1917,7 @@ void qed_get_vport_stats(struct qed_dev *cdev, struct qed_eth_stats *stats) + return; + } + +- _qed_get_vport_stats(cdev, stats); ++ _qed_get_vport_stats(cdev, stats, is_atomic); + + if (!cdev->reset_stats) + return; +@@ -1960,7 +1969,7 @@ void qed_reset_vport_stats(struct qed_dev *cdev) + if (!cdev->reset_stats) { + DP_INFO(cdev, "Reset stats not allocated\n"); + } else { +- _qed_get_vport_stats(cdev, cdev->reset_stats); ++ _qed_get_vport_stats(cdev, cdev->reset_stats, false); + cdev->reset_stats->common.link_change_count = 0; + } + } +diff --git a/drivers/net/ethernet/qlogic/qed/qed_l2.h b/drivers/net/ethernet/qlogic/qed/qed_l2.h +index 2ab7f3f0cf6c9..602a12a348b2e 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_l2.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_l2.h +@@ -250,8 +250,32 @@ qed_sp_eth_rx_queues_update(struct qed_hwfn *p_hwfn, + enum spq_mode comp_mode, + struct qed_spq_comp_cb *p_comp_data); + ++/** ++ * qed_get_vport_stats(): Fills provided statistics ++ * struct with statistics. ++ * ++ * @cdev: Qed dev pointer. ++ * @stats: Points to struct that will be filled with statistics. ++ * ++ * Return: Void. ++ */ + void qed_get_vport_stats(struct qed_dev *cdev, struct qed_eth_stats *stats); + ++/** ++ * qed_get_vport_stats_context(): Fills provided statistics ++ * struct with statistics. ++ * ++ * @cdev: Qed dev pointer. ++ * @stats: Points to struct that will be filled with statistics. ++ * @is_atomic: Hint from the caller - if the func can sleep or not. ++ * ++ * Context: The function should not sleep in case is_atomic == true. ++ * Return: Void. ++ */ ++void qed_get_vport_stats_context(struct qed_dev *cdev, ++ struct qed_eth_stats *stats, ++ bool is_atomic); ++ + void qed_reset_vport_stats(struct qed_dev *cdev); + + /** +diff --git a/drivers/net/ethernet/qlogic/qed/qed_main.c b/drivers/net/ethernet/qlogic/qed/qed_main.c +index d10e1cd6d2ba9..26700b0b4b370 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_main.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_main.c +@@ -3054,7 +3054,7 @@ void qed_get_protocol_stats(struct qed_dev *cdev, + + switch (type) { + case QED_MCP_LAN_STATS: +- qed_get_vport_stats(cdev, ð_stats); ++ qed_get_vport_stats_context(cdev, ð_stats, true); + stats->lan_stats.ucast_rx_pkts = + eth_stats.common.rx_ucast_pkts; + stats->lan_stats.ucast_tx_pkts = +@@ -3062,10 +3062,10 @@ void qed_get_protocol_stats(struct qed_dev *cdev, + stats->lan_stats.fcs_err = -1; + break; + case QED_MCP_FCOE_STATS: +- qed_get_protocol_stats_fcoe(cdev, &stats->fcoe_stats); ++ qed_get_protocol_stats_fcoe(cdev, &stats->fcoe_stats, true); + break; + case QED_MCP_ISCSI_STATS: +- qed_get_protocol_stats_iscsi(cdev, &stats->iscsi_stats); ++ qed_get_protocol_stats_iscsi(cdev, &stats->iscsi_stats, true); + break; + default: + DP_VERBOSE(cdev, QED_MSG_SP, +-- +2.40.1 + diff --git a/queue-5.15/rtnetlink-let-rtnl_bridge_setlink-checks-ifla_bridge.patch b/queue-5.15/rtnetlink-let-rtnl_bridge_setlink-checks-ifla_bridge.patch new file mode 100644 index 00000000000..d437b387a11 --- /dev/null +++ b/queue-5.15/rtnetlink-let-rtnl_bridge_setlink-checks-ifla_bridge.patch @@ -0,0 +1,66 @@ +From 49f95e739d9c0223f184c675ecca0db599baab35 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 26 Jul 2023 15:53:14 +0800 +Subject: rtnetlink: let rtnl_bridge_setlink checks IFLA_BRIDGE_MODE length + +From: Lin Ma + +[ Upstream commit d73ef2d69c0dba5f5a1cb9600045c873bab1fb7f ] + +There are totally 9 ndo_bridge_setlink handlers in the current kernel, +which are 1) bnxt_bridge_setlink, 2) be_ndo_bridge_setlink 3) +i40e_ndo_bridge_setlink 4) ice_bridge_setlink 5) +ixgbe_ndo_bridge_setlink 6) mlx5e_bridge_setlink 7) +nfp_net_bridge_setlink 8) qeth_l2_bridge_setlink 9) br_setlink. + +By investigating the code, we find that 1-7 parse and use nlattr +IFLA_BRIDGE_MODE but 3 and 4 forget to do the nla_len check. This can +lead to an out-of-attribute read and allow a malformed nlattr (e.g., +length 0) to be viewed as a 2 byte integer. + +To avoid such issues, also for other ndo_bridge_setlink handlers in the +future. This patch adds the nla_len check in rtnl_bridge_setlink and +does an early error return if length mismatches. To make it works, the +break is removed from the parsing for IFLA_BRIDGE_FLAGS to make sure +this nla_for_each_nested iterates every attribute. + +Fixes: b1edc14a3fbf ("ice: Implement ice_bridge_getlink and ice_bridge_setlink") +Fixes: 51616018dd1b ("i40e: Add support for getlink, setlink ndo ops") +Suggested-by: Jakub Kicinski +Signed-off-by: Lin Ma +Acked-by: Nikolay Aleksandrov +Reviewed-by: Hangbin Liu +Link: https://lore.kernel.org/r/20230726075314.1059224-1-linma@zju.edu.cn +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/core/rtnetlink.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c +index 49766446797c1..b055e196f5306 100644 +--- a/net/core/rtnetlink.c ++++ b/net/core/rtnetlink.c +@@ -4919,13 +4919,17 @@ static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, + br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); + if (br_spec) { + nla_for_each_nested(attr, br_spec, rem) { +- if (nla_type(attr) == IFLA_BRIDGE_FLAGS) { ++ if (nla_type(attr) == IFLA_BRIDGE_FLAGS && !have_flags) { + if (nla_len(attr) < sizeof(flags)) + return -EINVAL; + + have_flags = true; + flags = nla_get_u16(attr); +- break; ++ } ++ ++ if (nla_type(attr) == IFLA_BRIDGE_MODE) { ++ if (nla_len(attr) < sizeof(u16)) ++ return -EINVAL; + } + } + } +-- +2.40.1 + diff --git a/queue-5.15/s390-qeth-don-t-call-dev_close-dev_open-down-up.patch b/queue-5.15/s390-qeth-don-t-call-dev_close-dev_open-down-up.patch new file mode 100644 index 00000000000..742ef63190a --- /dev/null +++ b/queue-5.15/s390-qeth-don-t-call-dev_close-dev_open-down-up.patch @@ -0,0 +1,104 @@ +From eef58eb8d42cde6fba85860085f12a18ac9a11b5 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 1 Aug 2023 10:00:16 +0200 +Subject: s390/qeth: Don't call dev_close/dev_open (DOWN/UP) + +From: Alexandra Winter + +[ Upstream commit 1cfef80d4c2b2c599189f36f36320b205d9447d9 ] + +dev_close() and dev_open() are issued to change the interface state to DOWN +or UP (dev->flags IFF_UP). When the netdev is set DOWN it loses e.g its +Ipv6 addresses and routes. We don't want this in cases of device recovery +(triggered by hardware or software) or when the qeth device is set +offline. + +Setting a qeth device offline or online and device recovery actions call +netif_device_detach() and/or netif_device_attach(). That will reset or +set the LOWER_UP indication i.e. change the dev->state Bit +__LINK_STATE_PRESENT. That is enough to e.g. cause bond failovers, and +still preserves the interface settings that are handled by the network +stack. + +Don't call dev_open() nor dev_close() from the qeth device driver. Let the +network stack handle this. + +Fixes: d4560150cb47 ("s390/qeth: call dev_close() during recovery") +Signed-off-by: Alexandra Winter +Reviewed-by: Wenjia Zhang +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + drivers/s390/net/qeth_core.h | 1 - + drivers/s390/net/qeth_core_main.c | 2 -- + drivers/s390/net/qeth_l2_main.c | 9 ++++++--- + drivers/s390/net/qeth_l3_main.c | 8 +++++--- + 4 files changed, 11 insertions(+), 9 deletions(-) + +diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h +index a5aa0bdc61d69..e8c360879883b 100644 +--- a/drivers/s390/net/qeth_core.h ++++ b/drivers/s390/net/qeth_core.h +@@ -717,7 +717,6 @@ struct qeth_card_info { + u16 chid; + u8 ids_valid:1; /* cssid,iid,chid */ + u8 dev_addr_is_registered:1; +- u8 open_when_online:1; + u8 promisc_mode:1; + u8 use_v1_blkt:1; + u8 is_vm_nic:1; +diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c +index e9807d2996a9d..62e7576bff536 100644 +--- a/drivers/s390/net/qeth_core_main.c ++++ b/drivers/s390/net/qeth_core_main.c +@@ -5459,8 +5459,6 @@ int qeth_set_offline(struct qeth_card *card, const struct qeth_discipline *disc, + qeth_clear_ipacmd_list(card); + + rtnl_lock(); +- card->info.open_when_online = card->dev->flags & IFF_UP; +- dev_close(card->dev); + netif_device_detach(card->dev); + netif_carrier_off(card->dev); + rtnl_unlock(); +diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c +index d694e3ff80865..7cdf3274cf964 100644 +--- a/drivers/s390/net/qeth_l2_main.c ++++ b/drivers/s390/net/qeth_l2_main.c +@@ -2373,9 +2373,12 @@ static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok) + qeth_enable_hw_features(dev); + qeth_l2_enable_brport_features(card); + +- if (card->info.open_when_online) { +- card->info.open_when_online = 0; +- dev_open(dev, NULL); ++ if (netif_running(dev)) { ++ local_bh_disable(); ++ napi_schedule(&card->napi); ++ /* kick-start the NAPI softirq: */ ++ local_bh_enable(); ++ qeth_l2_set_rx_mode(dev); + } + rtnl_unlock(); + } +diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c +index 6fd3e288f0595..93f55c7348026 100644 +--- a/drivers/s390/net/qeth_l3_main.c ++++ b/drivers/s390/net/qeth_l3_main.c +@@ -2029,9 +2029,11 @@ static int qeth_l3_set_online(struct qeth_card *card, bool carrier_ok) + netif_device_attach(dev); + qeth_enable_hw_features(dev); + +- if (card->info.open_when_online) { +- card->info.open_when_online = 0; +- dev_open(dev, NULL); ++ if (netif_running(dev)) { ++ local_bh_disable(); ++ napi_schedule(&card->napi); ++ /* kick-start the NAPI softirq: */ ++ local_bh_enable(); + } + rtnl_unlock(); + } +-- +2.40.1 + diff --git a/queue-5.15/series b/queue-5.15/series index 88239c2d9df..adef30f54ff 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -7,3 +7,47 @@ iommu-arm-smmu-v3-work-around-mmu-600-erratum-1076982.patch iommu-arm-smmu-v3-document-mmu-700-erratum-2812531.patch iommu-arm-smmu-v3-add-explicit-feature-for-nesting.patch iommu-arm-smmu-v3-document-nesting-related-errata.patch +arm64-dts-imx8mn-var-som-add-missing-pull-up-for-onb.patch +firmware-arm_scmi-fix-chan_free-cleanup-on-smc.patch +word-at-a-time-use-the-same-return-type-for-has_zero.patch +kvm-s390-fix-sthyi-error-handling.patch +wifi-cfg80211-fix-return-value-in-scan-logic.patch +net-mlx5-dr-fix-memory-leak-in-mlx5dr_cmd_create_ref.patch +net-mlx5e-fix-return-value-check-in-mlx5e_ipsec_remo.patch +bpf-add-length-check-for-sk_diag_bpf_storage_req_map.patch +rtnetlink-let-rtnl_bridge_setlink-checks-ifla_bridge.patch +net-dsa-fix-value-check-in-bcm_sf2_sw_probe.patch +perf-test-uprobe_from_different_cu-skip-if-there-is-.patch +net-sched-cls_u32-fix-match-key-mis-addressing.patch +misdn-hfcpci-fix-potential-deadlock-on-hc-lock.patch +qed-fix-kernel-doc-warnings.patch +qed-fix-scheduling-in-a-tasklet-while-getting-stats.patch +net-annotate-data-races-around-sk-sk_max_pacing_rate.patch +net-add-missing-read_once-sk-sk_rcvlowat-annotation.patch +net-add-missing-read_once-sk-sk_sndbuf-annotation.patch +net-add-missing-read_once-sk-sk_rcvbuf-annotation.patch +net-add-missing-data-race-annotations-around-sk-sk_p.patch +net-add-missing-data-race-annotation-for-sk_ll_usec.patch +net-sched-taprio-limit-tca_taprio_attr_sched_cycle_t.patch +bpf-cpumap-handle-skb-as-well-when-clean-up-ptr_ring.patch +net-sched-cls_u32-no-longer-copy-tcf_result-on-updat.patch +net-sched-cls_fw-no-longer-copy-tcf_result-on-update.patch +net-sched-cls_route-no-longer-copy-tcf_result-on-upd.patch +bpf-sockmap-remove-preempt_disable-in-sock_map_sk_ac.patch +net-ll_temac-switch-to-use-dev_err_probe-helper.patch +net-ll_temac-fix-error-checking-of-irq_of_parse_and_.patch +net-korina-handle-clk-prepare-error-in-korina_probe.patch +net-netsec-ignore-phy-mode-on-synquacer-in-dt-mode.patch +net-dcb-choose-correct-policy-to-parse-dcb_attr_bcn.patch +s390-qeth-don-t-call-dev_close-dev_open-down-up.patch +ip6mr-fix-skb_under_panic-in-ip6mr_cache_report.patch +vxlan-fix-nexthop-hash-size.patch +net-mlx5-fs_core-make-find_closest_ft-more-generic.patch +net-mlx5-fs_core-skip-the-fts-in-the-same-fs_type_pr.patch +prestera-fix-fallback-to-previous-version-on-same-ma.patch +tcp_metrics-fix-addr_same-helper.patch +tcp_metrics-annotate-data-races-around-tm-tcpm_stamp.patch +tcp_metrics-annotate-data-races-around-tm-tcpm_lock.patch +tcp_metrics-annotate-data-races-around-tm-tcpm_vals.patch +tcp_metrics-annotate-data-races-around-tm-tcpm_net.patch +tcp_metrics-fix-data-race-in-tcpm_suck_dst-vs-fastop.patch diff --git a/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_lock.patch b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_lock.patch new file mode 100644 index 00000000000..654699cb320 --- /dev/null +++ b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_lock.patch @@ -0,0 +1,51 @@ +From d0b27547f4dfbc2478d7dafc48ff921789968601 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:14:57 +0000 +Subject: tcp_metrics: annotate data-races around tm->tcpm_lock + +From: Eric Dumazet + +[ Upstream commit 285ce119a3c6c4502585936650143e54c8692788 ] + +tm->tcpm_lock can be read or written locklessly. + +Add needed READ_ONCE()/WRITE_ONCE() to document this. + +Fixes: 51c5d0c4b169 ("tcp: Maintain dynamic metrics in local cache.") +Signed-off-by: Eric Dumazet +Reviewed-by: David Ahern +Reviewed-by: Kuniyuki Iwashima +Link: https://lore.kernel.org/r/20230802131500.1478140-4-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index cac6548340906..07bce467c71a7 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -59,7 +59,8 @@ static inline struct net *tm_net(struct tcp_metrics_block *tm) + static bool tcp_metric_locked(struct tcp_metrics_block *tm, + enum tcp_metric_index idx) + { +- return tm->tcpm_lock & (1 << idx); ++ /* Paired with WRITE_ONCE() in tcpm_suck_dst() */ ++ return READ_ONCE(tm->tcpm_lock) & (1 << idx); + } + + static u32 tcp_metric_get(struct tcp_metrics_block *tm, +@@ -110,7 +111,8 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm, + val |= 1 << TCP_METRIC_CWND; + if (dst_metric_locked(dst, RTAX_REORDERING)) + val |= 1 << TCP_METRIC_REORDERING; +- tm->tcpm_lock = val; ++ /* Paired with READ_ONCE() in tcp_metric_locked() */ ++ WRITE_ONCE(tm->tcpm_lock, val); + + msval = dst_metric_raw(dst, RTAX_RTT); + tm->tcpm_vals[TCP_METRIC_RTT] = msval * USEC_PER_MSEC; +-- +2.40.1 + diff --git a/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_net.patch b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_net.patch new file mode 100644 index 00000000000..4202a813973 --- /dev/null +++ b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_net.patch @@ -0,0 +1,66 @@ +From 5440121210f955781f75e5cfd95ac199f70c1b99 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:14:59 +0000 +Subject: tcp_metrics: annotate data-races around tm->tcpm_net + +From: Eric Dumazet + +[ Upstream commit d5d986ce42c71a7562d32c4e21e026b0f87befec ] + +tm->tcpm_net can be read or written locklessly. + +Instead of changing write_pnet() and read_pnet() and potentially +hurt performance, add the needed READ_ONCE()/WRITE_ONCE() +in tm_net() and tcpm_new(). + +Fixes: 849e8a0ca8d5 ("tcp_metrics: Add a field tcpm_net and verify it matches on lookup") +Signed-off-by: Eric Dumazet +Reviewed-by: David Ahern +Reviewed-by: Kuniyuki Iwashima +Link: https://lore.kernel.org/r/20230802131500.1478140-6-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 11 +++++++---- + 1 file changed, 7 insertions(+), 4 deletions(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index 0c309fd4e04b2..88b0d952a2888 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -40,7 +40,7 @@ struct tcp_fastopen_metrics { + + struct tcp_metrics_block { + struct tcp_metrics_block __rcu *tcpm_next; +- possible_net_t tcpm_net; ++ struct net *tcpm_net; + struct inetpeer_addr tcpm_saddr; + struct inetpeer_addr tcpm_daddr; + unsigned long tcpm_stamp; +@@ -51,9 +51,10 @@ struct tcp_metrics_block { + struct rcu_head rcu_head; + }; + +-static inline struct net *tm_net(struct tcp_metrics_block *tm) ++static inline struct net *tm_net(const struct tcp_metrics_block *tm) + { +- return read_pnet(&tm->tcpm_net); ++ /* Paired with the WRITE_ONCE() in tcpm_new() */ ++ return READ_ONCE(tm->tcpm_net); + } + + static bool tcp_metric_locked(struct tcp_metrics_block *tm, +@@ -197,7 +198,9 @@ static struct tcp_metrics_block *tcpm_new(struct dst_entry *dst, + if (!tm) + goto out_unlock; + } +- write_pnet(&tm->tcpm_net, net); ++ /* Paired with the READ_ONCE() in tm_net() */ ++ WRITE_ONCE(tm->tcpm_net, net); ++ + tm->tcpm_saddr = *saddr; + tm->tcpm_daddr = *daddr; + +-- +2.40.1 + diff --git a/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_stamp.patch b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_stamp.patch new file mode 100644 index 00000000000..08877cde5fa --- /dev/null +++ b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_stamp.patch @@ -0,0 +1,88 @@ +From a662e88a218706128aa48d6d25485ce8577bfe52 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:14:56 +0000 +Subject: tcp_metrics: annotate data-races around tm->tcpm_stamp + +From: Eric Dumazet + +[ Upstream commit 949ad62a5d5311d36fce2e14fe5fed3f936da51c ] + +tm->tcpm_stamp can be read or written locklessly. + +Add needed READ_ONCE()/WRITE_ONCE() to document this. + +Also constify tcpm_check_stamp() dst argument. + +Fixes: 51c5d0c4b169 ("tcp: Maintain dynamic metrics in local cache.") +Signed-off-by: Eric Dumazet +Reviewed-by: David Ahern +Reviewed-by: Kuniyuki Iwashima +Link: https://lore.kernel.org/r/20230802131500.1478140-3-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 19 +++++++++++++------ + 1 file changed, 13 insertions(+), 6 deletions(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index 6a06d2e0e11db..cac6548340906 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -97,7 +97,7 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm, + u32 msval; + u32 val; + +- tm->tcpm_stamp = jiffies; ++ WRITE_ONCE(tm->tcpm_stamp, jiffies); + + val = 0; + if (dst_metric_locked(dst, RTAX_RTT)) +@@ -131,9 +131,15 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm, + + #define TCP_METRICS_TIMEOUT (60 * 60 * HZ) + +-static void tcpm_check_stamp(struct tcp_metrics_block *tm, struct dst_entry *dst) ++static void tcpm_check_stamp(struct tcp_metrics_block *tm, ++ const struct dst_entry *dst) + { +- if (tm && unlikely(time_after(jiffies, tm->tcpm_stamp + TCP_METRICS_TIMEOUT))) ++ unsigned long limit; ++ ++ if (!tm) ++ return; ++ limit = READ_ONCE(tm->tcpm_stamp) + TCP_METRICS_TIMEOUT; ++ if (unlikely(time_after(jiffies, limit))) + tcpm_suck_dst(tm, dst, false); + } + +@@ -174,7 +180,8 @@ static struct tcp_metrics_block *tcpm_new(struct dst_entry *dst, + oldest = deref_locked(tcp_metrics_hash[hash].chain); + for (tm = deref_locked(oldest->tcpm_next); tm; + tm = deref_locked(tm->tcpm_next)) { +- if (time_before(tm->tcpm_stamp, oldest->tcpm_stamp)) ++ if (time_before(READ_ONCE(tm->tcpm_stamp), ++ READ_ONCE(oldest->tcpm_stamp))) + oldest = tm; + } + tm = oldest; +@@ -434,7 +441,7 @@ void tcp_update_metrics(struct sock *sk) + tp->reordering); + } + } +- tm->tcpm_stamp = jiffies; ++ WRITE_ONCE(tm->tcpm_stamp, jiffies); + out_unlock: + rcu_read_unlock(); + } +@@ -647,7 +654,7 @@ static int tcp_metrics_fill_info(struct sk_buff *msg, + } + + if (nla_put_msecs(msg, TCP_METRICS_ATTR_AGE, +- jiffies - tm->tcpm_stamp, ++ jiffies - READ_ONCE(tm->tcpm_stamp), + TCP_METRICS_ATTR_PAD) < 0) + goto nla_put_failure; + +-- +2.40.1 + diff --git a/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_vals.patch b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_vals.patch new file mode 100644 index 00000000000..e89fc81d5e4 --- /dev/null +++ b/queue-5.15/tcp_metrics-annotate-data-races-around-tm-tcpm_vals.patch @@ -0,0 +1,85 @@ +From 51e89fa5f1c28a1b76a852f612758a21cfb2692c Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:14:58 +0000 +Subject: tcp_metrics: annotate data-races around tm->tcpm_vals[] + +From: Eric Dumazet + +[ Upstream commit 8c4d04f6b443869d25e59822f7cec88d647028a9 ] + +tm->tcpm_vals[] values can be read or written locklessly. + +Add needed READ_ONCE()/WRITE_ONCE() to document this, +and force use of tcp_metric_get() and tcp_metric_set() + +Fixes: 51c5d0c4b169 ("tcp: Maintain dynamic metrics in local cache.") +Signed-off-by: Eric Dumazet +Reviewed-by: David Ahern +Reviewed-by: Kuniyuki Iwashima +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 23 ++++++++++++++--------- + 1 file changed, 14 insertions(+), 9 deletions(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index 07bce467c71a7..0c309fd4e04b2 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -63,17 +63,19 @@ static bool tcp_metric_locked(struct tcp_metrics_block *tm, + return READ_ONCE(tm->tcpm_lock) & (1 << idx); + } + +-static u32 tcp_metric_get(struct tcp_metrics_block *tm, ++static u32 tcp_metric_get(const struct tcp_metrics_block *tm, + enum tcp_metric_index idx) + { +- return tm->tcpm_vals[idx]; ++ /* Paired with WRITE_ONCE() in tcp_metric_set() */ ++ return READ_ONCE(tm->tcpm_vals[idx]); + } + + static void tcp_metric_set(struct tcp_metrics_block *tm, + enum tcp_metric_index idx, + u32 val) + { +- tm->tcpm_vals[idx] = val; ++ /* Paired with READ_ONCE() in tcp_metric_get() */ ++ WRITE_ONCE(tm->tcpm_vals[idx], val); + } + + static bool addr_same(const struct inetpeer_addr *a, +@@ -115,13 +117,16 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm, + WRITE_ONCE(tm->tcpm_lock, val); + + msval = dst_metric_raw(dst, RTAX_RTT); +- tm->tcpm_vals[TCP_METRIC_RTT] = msval * USEC_PER_MSEC; ++ tcp_metric_set(tm, TCP_METRIC_RTT, msval * USEC_PER_MSEC); + + msval = dst_metric_raw(dst, RTAX_RTTVAR); +- tm->tcpm_vals[TCP_METRIC_RTTVAR] = msval * USEC_PER_MSEC; +- tm->tcpm_vals[TCP_METRIC_SSTHRESH] = dst_metric_raw(dst, RTAX_SSTHRESH); +- tm->tcpm_vals[TCP_METRIC_CWND] = dst_metric_raw(dst, RTAX_CWND); +- tm->tcpm_vals[TCP_METRIC_REORDERING] = dst_metric_raw(dst, RTAX_REORDERING); ++ tcp_metric_set(tm, TCP_METRIC_RTTVAR, msval * USEC_PER_MSEC); ++ tcp_metric_set(tm, TCP_METRIC_SSTHRESH, ++ dst_metric_raw(dst, RTAX_SSTHRESH)); ++ tcp_metric_set(tm, TCP_METRIC_CWND, ++ dst_metric_raw(dst, RTAX_CWND)); ++ tcp_metric_set(tm, TCP_METRIC_REORDERING, ++ dst_metric_raw(dst, RTAX_REORDERING)); + if (fastopen_clear) { + tm->tcpm_fastopen.mss = 0; + tm->tcpm_fastopen.syn_loss = 0; +@@ -667,7 +672,7 @@ static int tcp_metrics_fill_info(struct sk_buff *msg, + if (!nest) + goto nla_put_failure; + for (i = 0; i < TCP_METRIC_MAX_KERNEL + 1; i++) { +- u32 val = tm->tcpm_vals[i]; ++ u32 val = tcp_metric_get(tm, i); + + if (!val) + continue; +-- +2.40.1 + diff --git a/queue-5.15/tcp_metrics-fix-addr_same-helper.patch b/queue-5.15/tcp_metrics-fix-addr_same-helper.patch new file mode 100644 index 00000000000..065caa8a0fd --- /dev/null +++ b/queue-5.15/tcp_metrics-fix-addr_same-helper.patch @@ -0,0 +1,46 @@ +From 820de33dc110dc218de1380af0fc534885b51fea Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:14:55 +0000 +Subject: tcp_metrics: fix addr_same() helper + +From: Eric Dumazet + +[ Upstream commit e6638094d7af6c7b9dcca05ad009e79e31b4f670 ] + +Because v4 and v6 families use separate inetpeer trees (respectively +net->ipv4.peers and net->ipv6.peers), inetpeer_addr_cmp(a, b) assumes +a & b share the same family. + +tcp_metrics use a common hash table, where entries can have different +families. + +We must therefore make sure to not call inetpeer_addr_cmp() +if the families do not match. + +Fixes: d39d14ffa24c ("net: Add helper function to compare inetpeer addresses") +Signed-off-by: Eric Dumazet +Reviewed-by: David Ahern +Reviewed-by: Kuniyuki Iwashima +Link: https://lore.kernel.org/r/20230802131500.1478140-2-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index d58e672be31c7..6a06d2e0e11db 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -78,7 +78,7 @@ static void tcp_metric_set(struct tcp_metrics_block *tm, + static bool addr_same(const struct inetpeer_addr *a, + const struct inetpeer_addr *b) + { +- return inetpeer_addr_cmp(a, b) == 0; ++ return (a->family == b->family) && !inetpeer_addr_cmp(a, b); + } + + struct tcpm_hash_bucket { +-- +2.40.1 + diff --git a/queue-5.15/tcp_metrics-fix-data-race-in-tcpm_suck_dst-vs-fastop.patch b/queue-5.15/tcp_metrics-fix-data-race-in-tcpm_suck_dst-vs-fastop.patch new file mode 100644 index 00000000000..7c561fb83b1 --- /dev/null +++ b/queue-5.15/tcp_metrics-fix-data-race-in-tcpm_suck_dst-vs-fastop.patch @@ -0,0 +1,85 @@ +From 9444c48fb205e4a6b4d465390cd451446e82e0be Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 2 Aug 2023 13:15:00 +0000 +Subject: tcp_metrics: fix data-race in tcpm_suck_dst() vs fastopen + +From: Eric Dumazet + +[ Upstream commit ddf251fa2bc1d3699eec0bae6ed0bc373b8fda79 ] + +Whenever tcpm_new() reclaims an old entry, tcpm_suck_dst() +would overwrite data that could be read from tcp_fastopen_cache_get() +or tcp_metrics_fill_info(). + +We need to acquire fastopen_seqlock to maintain consistency. + +For newly allocated objects, tcpm_new() can switch to kzalloc() +to avoid an extra fastopen_seqlock acquisition. + +Fixes: 1fe4c481ba63 ("net-tcp: Fast Open client - cookie cache") +Signed-off-by: Eric Dumazet +Cc: Yuchung Cheng +Reviewed-by: Kuniyuki Iwashima +Link: https://lore.kernel.org/r/20230802131500.1478140-7-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Sasha Levin +--- + net/ipv4/tcp_metrics.c | 9 +++++---- + 1 file changed, 5 insertions(+), 4 deletions(-) + +diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c +index 88b0d952a2888..5df97aaac252e 100644 +--- a/net/ipv4/tcp_metrics.c ++++ b/net/ipv4/tcp_metrics.c +@@ -93,6 +93,7 @@ static struct tcpm_hash_bucket *tcp_metrics_hash __read_mostly; + static unsigned int tcp_metrics_hash_log __read_mostly; + + static DEFINE_SPINLOCK(tcp_metrics_lock); ++static DEFINE_SEQLOCK(fastopen_seqlock); + + static void tcpm_suck_dst(struct tcp_metrics_block *tm, + const struct dst_entry *dst, +@@ -129,11 +130,13 @@ static void tcpm_suck_dst(struct tcp_metrics_block *tm, + tcp_metric_set(tm, TCP_METRIC_REORDERING, + dst_metric_raw(dst, RTAX_REORDERING)); + if (fastopen_clear) { ++ write_seqlock(&fastopen_seqlock); + tm->tcpm_fastopen.mss = 0; + tm->tcpm_fastopen.syn_loss = 0; + tm->tcpm_fastopen.try_exp = 0; + tm->tcpm_fastopen.cookie.exp = false; + tm->tcpm_fastopen.cookie.len = 0; ++ write_sequnlock(&fastopen_seqlock); + } + } + +@@ -194,7 +197,7 @@ static struct tcp_metrics_block *tcpm_new(struct dst_entry *dst, + } + tm = oldest; + } else { +- tm = kmalloc(sizeof(*tm), GFP_ATOMIC); ++ tm = kzalloc(sizeof(*tm), GFP_ATOMIC); + if (!tm) + goto out_unlock; + } +@@ -204,7 +207,7 @@ static struct tcp_metrics_block *tcpm_new(struct dst_entry *dst, + tm->tcpm_saddr = *saddr; + tm->tcpm_daddr = *daddr; + +- tcpm_suck_dst(tm, dst, true); ++ tcpm_suck_dst(tm, dst, reclaim); + + if (likely(!reclaim)) { + tm->tcpm_next = tcp_metrics_hash[hash].chain; +@@ -556,8 +559,6 @@ bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst) + return ret; + } + +-static DEFINE_SEQLOCK(fastopen_seqlock); +- + void tcp_fastopen_cache_get(struct sock *sk, u16 *mss, + struct tcp_fastopen_cookie *cookie) + { +-- +2.40.1 + diff --git a/queue-5.15/vxlan-fix-nexthop-hash-size.patch b/queue-5.15/vxlan-fix-nexthop-hash-size.patch new file mode 100644 index 00000000000..22fdaf54692 --- /dev/null +++ b/queue-5.15/vxlan-fix-nexthop-hash-size.patch @@ -0,0 +1,175 @@ +From 9fa8a0b801bafb3ee13aa95485034634d9d949cb Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 31 Jul 2023 16:02:08 -0400 +Subject: vxlan: Fix nexthop hash size + +From: Benjamin Poirier + +[ Upstream commit 0756384fb1bd38adb2ebcfd1307422f433a1d772 ] + +The nexthop code expects a 31 bit hash, such as what is returned by +fib_multipath_hash() and rt6_multipath_hash(). Passing the 32 bit hash +returned by skb_get_hash() can lead to problems related to the fact that +'int hash' is a negative number when the MSB is set. + +In the case of hash threshold nexthop groups, nexthop_select_path_hthr() +will disproportionately select the first nexthop group entry. In the case +of resilient nexthop groups, nexthop_select_path_res() may do an out of +bounds access in nh_buckets[], for example: + hash = -912054133 + num_nh_buckets = 2 + bucket_index = 65535 + +which leads to the following panic: + +BUG: unable to handle page fault for address: ffffc900025910c8 +PGD 100000067 P4D 100000067 PUD 10026b067 PMD 0 +Oops: 0002 [#1] PREEMPT SMP KASAN NOPTI +CPU: 4 PID: 856 Comm: kworker/4:3 Not tainted 6.5.0-rc2+ #34 +Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.2-debian-1.16.2-1 04/01/2014 +Workqueue: ipv6_addrconf addrconf_dad_work +RIP: 0010:nexthop_select_path+0x197/0xbf0 +Code: c1 e4 05 be 08 00 00 00 4c 8b 35 a4 14 7e 01 4e 8d 6c 25 00 4a 8d 7c 25 08 48 01 dd e8 c2 25 15 ff 49 8d 7d 08 e8 39 13 15 ff <4d> 89 75 08 48 89 ef e8 7d 12 15 ff 48 8b 5d 00 e8 14 55 2f 00 85 +RSP: 0018:ffff88810c36f260 EFLAGS: 00010246 +RAX: 0000000000000000 RBX: 00000000002000c0 RCX: ffffffffaf02dd77 +RDX: dffffc0000000000 RSI: 0000000000000008 RDI: ffffc900025910c8 +RBP: ffffc900025910c0 R08: 0000000000000001 R09: fffff520004b2219 +R10: ffffc900025910cf R11: 31392d2068736168 R12: 00000000002000c0 +R13: ffffc900025910c0 R14: 00000000fffef608 R15: ffff88811840e900 +FS: 0000000000000000(0000) GS:ffff8881f7000000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: ffffc900025910c8 CR3: 0000000129d00000 CR4: 0000000000750ee0 +PKRU: 55555554 +Call Trace: + + ? __die+0x23/0x70 + ? page_fault_oops+0x1ee/0x5c0 + ? __pfx_is_prefetch.constprop.0+0x10/0x10 + ? __pfx_page_fault_oops+0x10/0x10 + ? search_bpf_extables+0xfe/0x1c0 + ? fixup_exception+0x3b/0x470 + ? exc_page_fault+0xf6/0x110 + ? asm_exc_page_fault+0x26/0x30 + ? nexthop_select_path+0x197/0xbf0 + ? nexthop_select_path+0x197/0xbf0 + ? lock_is_held_type+0xe7/0x140 + vxlan_xmit+0x5b2/0x2340 + ? __lock_acquire+0x92b/0x3370 + ? __pfx_vxlan_xmit+0x10/0x10 + ? __pfx___lock_acquire+0x10/0x10 + ? __pfx_register_lock_class+0x10/0x10 + ? skb_network_protocol+0xce/0x2d0 + ? dev_hard_start_xmit+0xca/0x350 + ? __pfx_vxlan_xmit+0x10/0x10 + dev_hard_start_xmit+0xca/0x350 + __dev_queue_xmit+0x513/0x1e20 + ? __pfx___dev_queue_xmit+0x10/0x10 + ? __pfx_lock_release+0x10/0x10 + ? mark_held_locks+0x44/0x90 + ? skb_push+0x4c/0x80 + ? eth_header+0x81/0xe0 + ? __pfx_eth_header+0x10/0x10 + ? neigh_resolve_output+0x215/0x310 + ? ip6_finish_output2+0x2ba/0xc90 + ip6_finish_output2+0x2ba/0xc90 + ? lock_release+0x236/0x3e0 + ? ip6_mtu+0xbb/0x240 + ? __pfx_ip6_finish_output2+0x10/0x10 + ? find_held_lock+0x83/0xa0 + ? lock_is_held_type+0xe7/0x140 + ip6_finish_output+0x1ee/0x780 + ip6_output+0x138/0x460 + ? __pfx_ip6_output+0x10/0x10 + ? __pfx___lock_acquire+0x10/0x10 + ? __pfx_ip6_finish_output+0x10/0x10 + NF_HOOK.constprop.0+0xc0/0x420 + ? __pfx_NF_HOOK.constprop.0+0x10/0x10 + ? ndisc_send_skb+0x2c0/0x960 + ? __pfx_lock_release+0x10/0x10 + ? __local_bh_enable_ip+0x93/0x110 + ? lock_is_held_type+0xe7/0x140 + ndisc_send_skb+0x4be/0x960 + ? __pfx_ndisc_send_skb+0x10/0x10 + ? mark_held_locks+0x65/0x90 + ? find_held_lock+0x83/0xa0 + ndisc_send_ns+0xb0/0x110 + ? __pfx_ndisc_send_ns+0x10/0x10 + addrconf_dad_work+0x631/0x8e0 + ? lock_acquire+0x180/0x3f0 + ? __pfx_addrconf_dad_work+0x10/0x10 + ? mark_held_locks+0x24/0x90 + process_one_work+0x582/0x9c0 + ? __pfx_process_one_work+0x10/0x10 + ? __pfx_do_raw_spin_lock+0x10/0x10 + ? mark_held_locks+0x24/0x90 + worker_thread+0x93/0x630 + ? __kthread_parkme+0xdc/0x100 + ? __pfx_worker_thread+0x10/0x10 + kthread+0x1a5/0x1e0 + ? __pfx_kthread+0x10/0x10 + ret_from_fork+0x34/0x60 + ? __pfx_kthread+0x10/0x10 + ret_from_fork_asm+0x1b/0x30 +RIP: 0000:0x0 +Code: Unable to access opcode bytes at 0xffffffffffffffd6. +RSP: 0000:0000000000000000 EFLAGS: 00000000 ORIG_RAX: 0000000000000000 +RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000 +RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000 +RBP: 0000000000000000 R08: 0000000000000000 R09: 0000000000000000 +R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000 +R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000 + +Modules linked in: +CR2: ffffc900025910c8 +---[ end trace 0000000000000000 ]--- +RIP: 0010:nexthop_select_path+0x197/0xbf0 +Code: c1 e4 05 be 08 00 00 00 4c 8b 35 a4 14 7e 01 4e 8d 6c 25 00 4a 8d 7c 25 08 48 01 dd e8 c2 25 15 ff 49 8d 7d 08 e8 39 13 15 ff <4d> 89 75 08 48 89 ef e8 7d 12 15 ff 48 8b 5d 00 e8 14 55 2f 00 85 +RSP: 0018:ffff88810c36f260 EFLAGS: 00010246 +RAX: 0000000000000000 RBX: 00000000002000c0 RCX: ffffffffaf02dd77 +RDX: dffffc0000000000 RSI: 0000000000000008 RDI: ffffc900025910c8 +RBP: ffffc900025910c0 R08: 0000000000000001 R09: fffff520004b2219 +R10: ffffc900025910cf R11: 31392d2068736168 R12: 00000000002000c0 +R13: ffffc900025910c0 R14: 00000000fffef608 R15: ffff88811840e900 +FS: 0000000000000000(0000) GS:ffff8881f7000000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: ffffffffffffffd6 CR3: 0000000129d00000 CR4: 0000000000750ee0 +PKRU: 55555554 +Kernel panic - not syncing: Fatal exception in interrupt +Kernel Offset: 0x2ca00000 from 0xffffffff81000000 (relocation range: 0xffffffff80000000-0xffffffffbfffffff) +---[ end Kernel panic - not syncing: Fatal exception in interrupt ]--- + +Fix this problem by ensuring the MSB of hash is 0 using a right shift - the +same approach used in fib_multipath_hash() and rt6_multipath_hash(). + +Fixes: 1274e1cc4226 ("vxlan: ecmp support for mac fdb entries") +Signed-off-by: Benjamin Poirier +Reviewed-by: Ido Schimmel +Reviewed-by: Simon Horman +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + include/net/vxlan.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/include/net/vxlan.h b/include/net/vxlan.h +index cf1d870f7b9a8..e149a0b6f9a3c 100644 +--- a/include/net/vxlan.h ++++ b/include/net/vxlan.h +@@ -497,12 +497,12 @@ static inline void vxlan_flag_attr_error(int attrtype, + } + + static inline bool vxlan_fdb_nh_path_select(struct nexthop *nh, +- int hash, ++ u32 hash, + struct vxlan_rdst *rdst) + { + struct fib_nh_common *nhc; + +- nhc = nexthop_path_fdb_result(nh, hash); ++ nhc = nexthop_path_fdb_result(nh, hash >> 1); + if (unlikely(!nhc)) + return false; + +-- +2.40.1 + diff --git a/queue-5.15/wifi-cfg80211-fix-return-value-in-scan-logic.patch b/queue-5.15/wifi-cfg80211-fix-return-value-in-scan-logic.patch new file mode 100644 index 00000000000..d57f5859fd6 --- /dev/null +++ b/queue-5.15/wifi-cfg80211-fix-return-value-in-scan-logic.patch @@ -0,0 +1,43 @@ +From 1a8939852fb08c6195c711deff1ea151e91b4c4b Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 23 Jul 2023 23:10:43 +0300 +Subject: wifi: cfg80211: Fix return value in scan logic + +From: Ilan Peer + +[ Upstream commit fd7f08d92fcd7cc3eca0dd6c853f722a4c6176df ] + +The reporter noticed a warning when running iwlwifi: + +WARNING: CPU: 8 PID: 659 at mm/page_alloc.c:4453 __alloc_pages+0x329/0x340 + +As cfg80211_parse_colocated_ap() is not expected to return a negative +value return 0 and not a negative value if cfg80211_calc_short_ssid() +fails. + +Fixes: c8cb5b854b40f ("nl80211/cfg80211: support 6 GHz scanning") +Closes: https://bugzilla.kernel.org/show_bug.cgi?id=217675 +Signed-off-by: Ilan Peer +Signed-off-by: Kalle Valo +Link: https://lore.kernel.org/r/20230723201043.3007430-1-ilan.peer@intel.com +Signed-off-by: Sasha Levin +--- + net/wireless/scan.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/wireless/scan.c b/net/wireless/scan.c +index a565476809f02..c7192d7bcbd76 100644 +--- a/net/wireless/scan.c ++++ b/net/wireless/scan.c +@@ -641,7 +641,7 @@ static int cfg80211_parse_colocated_ap(const struct cfg80211_bss_ies *ies, + + ret = cfg80211_calc_short_ssid(ies, &ssid_elem, &s_ssid_tmp); + if (ret) +- return ret; ++ return 0; + + /* RNR IE may contain more than one NEIGHBOR_AP_INFO */ + while (pos + sizeof(*ap_info) <= end) { +-- +2.40.1 + diff --git a/queue-5.15/word-at-a-time-use-the-same-return-type-for-has_zero.patch b/queue-5.15/word-at-a-time-use-the-same-return-type-for-has_zero.patch new file mode 100644 index 00000000000..0b7f09987ec --- /dev/null +++ b/queue-5.15/word-at-a-time-use-the-same-return-type-for-has_zero.patch @@ -0,0 +1,74 @@ +From 48fca83cdfeb09815ebaf0af184a68b332b59ab9 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 1 Aug 2023 15:22:17 -0700 +Subject: word-at-a-time: use the same return type for has_zero regardless of + endianness + +From: ndesaulniers@google.com + +[ Upstream commit 79e8328e5acbe691bbde029a52c89d70dcbc22f3 ] + +Compiling big-endian targets with Clang produces the diagnostic: + + fs/namei.c:2173:13: warning: use of bitwise '|' with boolean operands [-Wbitwise-instead-of-logical] + } while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants))); + ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + || + fs/namei.c:2173:13: note: cast one or both operands to int to silence this warning + +It appears that when has_zero was introduced, two definitions were +produced with different signatures (in particular different return +types). + +Looking at the usage in hash_name() in fs/namei.c, I suspect that +has_zero() is meant to be invoked twice per while loop iteration; using +logical-or would not update `bdata` when `a` did not have zeros. So I +think it's preferred to always return an unsigned long rather than a +bool than update the while loop in hash_name() to use a logical-or +rather than bitwise-or. + +[ Also changed powerpc version to do the same - Linus ] + +Link: https://github.com/ClangBuiltLinux/linux/issues/1832 +Link: https://lore.kernel.org/lkml/20230801-bitwise-v1-1-799bec468dc4@google.com/ +Fixes: 36126f8f2ed8 ("word-at-a-time: make the interfaces truly generic") +Debugged-by: Nathan Chancellor +Signed-off-by: Nick Desaulniers +Acked-by: Heiko Carstens +Cc: Arnd Bergmann +Signed-off-by: Linus Torvalds +Signed-off-by: Sasha Levin +--- + arch/powerpc/include/asm/word-at-a-time.h | 2 +- + include/asm-generic/word-at-a-time.h | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/arch/powerpc/include/asm/word-at-a-time.h b/arch/powerpc/include/asm/word-at-a-time.h +index f3f4710d4ff52..99129b0cd8b8a 100644 +--- a/arch/powerpc/include/asm/word-at-a-time.h ++++ b/arch/powerpc/include/asm/word-at-a-time.h +@@ -34,7 +34,7 @@ static inline long find_zero(unsigned long mask) + return leading_zero_bits >> 3; + } + +-static inline bool has_zero(unsigned long val, unsigned long *data, const struct word_at_a_time *c) ++static inline unsigned long has_zero(unsigned long val, unsigned long *data, const struct word_at_a_time *c) + { + unsigned long rhs = val | c->low_bits; + *data = rhs; +diff --git a/include/asm-generic/word-at-a-time.h b/include/asm-generic/word-at-a-time.h +index 20c93f08c9933..95a1d214108a5 100644 +--- a/include/asm-generic/word-at-a-time.h ++++ b/include/asm-generic/word-at-a-time.h +@@ -38,7 +38,7 @@ static inline long find_zero(unsigned long mask) + return (mask >> 8) ? byte : byte + 1; + } + +-static inline bool has_zero(unsigned long val, unsigned long *data, const struct word_at_a_time *c) ++static inline unsigned long has_zero(unsigned long val, unsigned long *data, const struct word_at_a_time *c) + { + unsigned long rhs = val | c->low_bits; + *data = rhs; +-- +2.40.1 +