From: Sasha Levin Date: Tue, 8 Apr 2025 00:42:36 +0000 (-0400) Subject: Fixes for 6.14 X-Git-Tag: v5.4.292~75 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=ea072af09bdd95a61570fb07ae6221e27f7d23bf;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 6.14 Signed-off-by: Sasha Levin --- diff --git a/queue-6.14/drm-amdgpu-gfx11-fix-num_mec.patch b/queue-6.14/drm-amdgpu-gfx11-fix-num_mec.patch new file mode 100644 index 0000000000..271bf404a2 --- /dev/null +++ b/queue-6.14/drm-amdgpu-gfx11-fix-num_mec.patch @@ -0,0 +1,35 @@ +From 050be96b7e860a184f8a854a06a5ea3a302bb915 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 26 Mar 2025 09:35:02 -0400 +Subject: drm/amdgpu/gfx11: fix num_mec + +From: Alex Deucher + +[ Upstream commit 4161050d47e1b083a7e1b0b875c9907e1a6f1f1f ] + +GC11 only has 1 mec. + +Fixes: 3d879e81f0f9 ("drm/amdgpu: add init support for GFX11 (v2)") +Reviewed-by: Sunil Khatri +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c +index 56c06b72a70ac..cfb51baa581a1 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c +@@ -1559,7 +1559,7 @@ static int gfx_v11_0_sw_init(struct amdgpu_ip_block *ip_block) + adev->gfx.me.num_me = 1; + adev->gfx.me.num_pipe_per_me = 1; + adev->gfx.me.num_queue_per_pipe = 1; +- adev->gfx.mec.num_mec = 2; ++ adev->gfx.mec.num_mec = 1; + adev->gfx.mec.num_pipe_per_mec = 4; + adev->gfx.mec.num_queue_per_pipe = 4; + break; +-- +2.39.5 + diff --git a/queue-6.14/drm-amdgpu-gfx12-fix-num_mec.patch b/queue-6.14/drm-amdgpu-gfx12-fix-num_mec.patch new file mode 100644 index 0000000000..569554e880 --- /dev/null +++ b/queue-6.14/drm-amdgpu-gfx12-fix-num_mec.patch @@ -0,0 +1,35 @@ +From 3b02fdc63ec2e62629c6aa61c5f0ae4daa0c1c64 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 20 Mar 2025 12:09:11 -0400 +Subject: drm/amdgpu/gfx12: fix num_mec + +From: Alex Deucher + +[ Upstream commit dce8bd9137b88735dd0efc4e2693213d98c15913 ] + +GC12 only has 1 mec. + +Fixes: 52cb80c12e8a ("drm/amdgpu: Add gfx v12_0 ip block support (v6)") +Reviewed-by: Sunil Khatri +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c +index 48ff00427882c..c21b168f75a75 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c +@@ -1337,7 +1337,7 @@ static int gfx_v12_0_sw_init(struct amdgpu_ip_block *ip_block) + adev->gfx.me.num_me = 1; + adev->gfx.me.num_pipe_per_me = 1; + adev->gfx.me.num_queue_per_pipe = 1; +- adev->gfx.mec.num_mec = 2; ++ adev->gfx.mec.num_mec = 1; + adev->gfx.mec.num_pipe_per_mec = 2; + adev->gfx.mec.num_queue_per_pipe = 4; + break; +-- +2.39.5 + diff --git a/queue-6.14/drm-xe-fix-unmet-direct-dependencies-warning.patch b/queue-6.14/drm-xe-fix-unmet-direct-dependencies-warning.patch new file mode 100644 index 0000000000..56a977e9aa --- /dev/null +++ b/queue-6.14/drm-xe-fix-unmet-direct-dependencies-warning.patch @@ -0,0 +1,46 @@ +From 9903759d580657f3ff75e76cc1969ad4ba27cc05 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 23 Mar 2025 19:41:03 +0800 +Subject: drm/xe: Fix unmet direct dependencies warning + +From: Yue Haibing + +[ Upstream commit 5e66cf6edddb5f6237e3afb07475ace57ecb56bc ] + +WARNING: unmet direct dependencies detected for FB_IOMEM_HELPERS + Depends on [n]: HAS_IOMEM [=y] && FB_CORE [=n] + Selected by [m]: + - DRM_XE_DISPLAY [=y] && HAS_IOMEM [=y] && DRM [=m] && DRM_XE [=m] && DRM_XE [=m]=m [=m] && HAS_IOPORT [=y] + +DRM_XE_DISPLAY requires FB_IOMEM_HELPERS, but the dependency FB_CORE is +missing, selecting FB_IOMEM_HELPERS if DRM_FBDEV_EMULATION is set as +other drm drivers. + +Fixes: 44e694958b95 ("drm/xe/display: Implement display support") +Signed-off-by: Yue Haibing +Reviewed-by: Lucas De Marchi +Link: https://patchwork.freedesktop.org/patch/msgid/20250323114103.1960511-1-yuehaibing@huawei.com +Signed-off-by: Lucas De Marchi +(cherry picked from commit 689582882802cd64986c1eb584c9f5184d67f0cf) +Signed-off-by: Lucas De Marchi +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/xe/Kconfig | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/xe/Kconfig b/drivers/gpu/drm/xe/Kconfig +index b51a2bde73e29..dcf6583a4c522 100644 +--- a/drivers/gpu/drm/xe/Kconfig ++++ b/drivers/gpu/drm/xe/Kconfig +@@ -52,7 +52,7 @@ config DRM_XE + config DRM_XE_DISPLAY + bool "Enable display support" + depends on DRM_XE && DRM_XE=m && HAS_IOPORT +- select FB_IOMEM_HELPERS ++ select FB_IOMEM_HELPERS if DRM_FBDEV_EMULATION + select I2C + select I2C_ALGOBIT + default y +-- +2.39.5 + diff --git a/queue-6.14/kbuild-deb-pkg-don-t-set-kbuild_build_version-uncond.patch b/queue-6.14/kbuild-deb-pkg-don-t-set-kbuild_build_version-uncond.patch new file mode 100644 index 0000000000..0952e791dd --- /dev/null +++ b/queue-6.14/kbuild-deb-pkg-don-t-set-kbuild_build_version-uncond.patch @@ -0,0 +1,64 @@ +From 05636f77a2703ac17ad04d77cd7816f428a80a9e Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 14 Mar 2025 13:10:53 +0000 +Subject: kbuild: deb-pkg: don't set KBUILD_BUILD_VERSION unconditionally + +From: Alexandru Gagniuc + +[ Upstream commit 62604063621fb075c7966286bdddcb057d883fa8 ] + +In ThinPro, we use the convention +hp for +the kernel package. This does not have a dash in the name or version. +This is built by editing ".version" before a build, and setting +EXTRAVERSION="+hp" and KDEB_PKGVERSION make variables: + + echo 68 > .version + make -j EXTRAVERSION="+hp" bindeb-pkg KDEB_PKGVERSION=6.12.2+hp69 + + .deb name: linux-image-6.12.2+hp_6.12.2+hp69_amd64.deb + +Since commit 7d4f07d5cb71 ("kbuild: deb-pkg: squash +scripts/package/deb-build-option to debian/rules"), this no longer +works. The deb build logic changed, even though, the commit message +implies that the logic should be unmodified. + +Before, KBUILD_BUILD_VERSION was not set if the KDEB_PKGVERSION did +not contain a dash. After the change KBUILD_BUILD_VERSION is always +set to KDEB_PKGVERSION. Since this determines UTS_VERSION, the uname +output to look off: + + (now) uname -a: version 6.12.2+hp ... #6.12.2+hp69 + (expected) uname -a: version 6.12.2+hp ... #69 + +Update the debian/rules logic to restore the original behavior. + +Fixes: 7d4f07d5cb71 ("kbuild: deb-pkg: squash scripts/package/deb-build-option to debian/rules") +Signed-off-by: Alexandru Gagniuc +Reviewed-by: Nicolas Schier +Signed-off-by: Masahiro Yamada +Signed-off-by: Sasha Levin +--- + scripts/package/debian/rules | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/scripts/package/debian/rules b/scripts/package/debian/rules +index ca07243bd5cdf..2b3f9a0bd6c40 100755 +--- a/scripts/package/debian/rules ++++ b/scripts/package/debian/rules +@@ -21,9 +21,11 @@ ifeq ($(origin KBUILD_VERBOSE),undefined) + endif + endif + +-revision = $(lastword $(subst -, ,$(shell dpkg-parsechangelog -S Version))) ++revision = $(shell dpkg-parsechangelog -S Version | sed -n 's/.*-//p') + CROSS_COMPILE ?= $(filter-out $(DEB_BUILD_GNU_TYPE)-, $(DEB_HOST_GNU_TYPE)-) +-make-opts = ARCH=$(ARCH) KERNELRELEASE=$(KERNELRELEASE) KBUILD_BUILD_VERSION=$(revision) $(addprefix CROSS_COMPILE=,$(CROSS_COMPILE)) ++make-opts = ARCH=$(ARCH) KERNELRELEASE=$(KERNELRELEASE) \ ++ $(addprefix KBUILD_BUILD_VERSION=,$(revision)) \ ++ $(addprefix CROSS_COMPILE=,$(CROSS_COMPILE)) + + binary-targets := $(addprefix binary-, image image-dbg headers libc-dev) + +-- +2.39.5 + diff --git a/queue-6.14/perf-core-fix-child_total_time_enabled-accounting-bu.patch b/queue-6.14/perf-core-fix-child_total_time_enabled-accounting-bu.patch new file mode 100644 index 0000000000..8d453808a6 --- /dev/null +++ b/queue-6.14/perf-core-fix-child_total_time_enabled-accounting-bu.patch @@ -0,0 +1,143 @@ +From b8221f7002df8db88e65f345d8ffaf4a1ee134d1 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 26 Mar 2025 08:20:03 +0000 +Subject: perf/core: Fix child_total_time_enabled accounting bug at task exit + +From: Yeoreum Yun + +[ Upstream commit a3c3c66670cee11eb13aa43905904bf29cb92d32 ] + +The perf events code fails to account for total_time_enabled of +inactive events. + +Here is a failure case for accounting total_time_enabled for +CPU PMU events: + + sudo ./perf stat -vvv -e armv8_pmuv3_0/event=0x08/ -e armv8_pmuv3_1/event=0x08/ -- stress-ng --pthread=2 -t 2s + ... + + armv8_pmuv3_0/event=0x08/: 1138698008 2289429840 2174835740 + armv8_pmuv3_1/event=0x08/: 1826791390 1950025700 847648440 + ` ` ` + ` ` > total_time_running with child + ` > total_time_enabled with child + > count with child + + Performance counter stats for 'stress-ng --pthread=2 -t 2s': + + 1,138,698,008 armv8_pmuv3_0/event=0x08/ (94.99%) + 1,826,791,390 armv8_pmuv3_1/event=0x08/ (43.47%) + +The two events above are opened on two different CPU PMUs, for example, +each event is opened for a cluster in an Arm big.LITTLE system, they +will never run on the same CPU. In theory, the total enabled time should +be same for both events, as two events are opened and closed together. + +As the result show, the two events' total enabled time including +child event is different (2289429840 vs 1950025700). + +This is because child events are not accounted properly +if a event is INACTIVE state when the task exits: + + perf_event_exit_event() + `> perf_remove_from_context() + `> __perf_remove_from_context() + `> perf_child_detach() -> Accumulate child_total_time_enabled + `> list_del_event() -> Update child event's time + +The problem is the time accumulation happens prior to child event's +time updating. Thus, it misses to account the last period's time when +the event exits. + +The perf core layer follows the rule that timekeeping is tied to state +change. To address the issue, make __perf_remove_from_context() +handle the task exit case by passing 'DETACH_EXIT' to it and +invoke perf_event_state() for state alongside with accounting the time. + +Then, perf_child_detach() populates the time into the parent's time metrics. + +After this patch, the bug is fixed: + + sudo ./perf stat -vvv -e armv8_pmuv3_0/event=0x08/ -e armv8_pmuv3_1/event=0x08/ -- stress-ng --pthread=2 -t 10s + ... + armv8_pmuv3_0/event=0x08/: 15396770398 32157963940 21898169000 + armv8_pmuv3_1/event=0x08/: 22428964974 32157963940 10259794940 + + Performance counter stats for 'stress-ng --pthread=2 -t 10s': + + 15,396,770,398 armv8_pmuv3_0/event=0x08/ (68.10%) + 22,428,964,974 armv8_pmuv3_1/event=0x08/ (31.90%) + +[ mingo: Clarified the changelog. ] + +Fixes: ef54c1a476aef ("perf: Rework perf_event_exit_event()") +Suggested-by: Peter Zijlstra +Signed-off-by: Yeoreum Yun +Signed-off-by: Ingo Molnar +Tested-by: Leo Yan +Link: https://lore.kernel.org/r/20250326082003.1630986-1-yeoreum.yun@arm.com +Signed-off-by: Sasha Levin +--- + kernel/events/core.c | 18 +++++++++--------- + 1 file changed, 9 insertions(+), 9 deletions(-) + +diff --git a/kernel/events/core.c b/kernel/events/core.c +index 03c27754aef8b..f6cf17929bb98 100644 +--- a/kernel/events/core.c ++++ b/kernel/events/core.c +@@ -2407,6 +2407,7 @@ ctx_time_update_event(struct perf_event_context *ctx, struct perf_event *event) + #define DETACH_GROUP 0x01UL + #define DETACH_CHILD 0x02UL + #define DETACH_DEAD 0x04UL ++#define DETACH_EXIT 0x08UL + + /* + * Cross CPU call to remove a performance event +@@ -2421,6 +2422,7 @@ __perf_remove_from_context(struct perf_event *event, + void *info) + { + struct perf_event_pmu_context *pmu_ctx = event->pmu_ctx; ++ enum perf_event_state state = PERF_EVENT_STATE_OFF; + unsigned long flags = (unsigned long)info; + + ctx_time_update(cpuctx, ctx); +@@ -2429,16 +2431,19 @@ __perf_remove_from_context(struct perf_event *event, + * Ensure event_sched_out() switches to OFF, at the very least + * this avoids raising perf_pending_task() at this time. + */ +- if (flags & DETACH_DEAD) ++ if (flags & DETACH_EXIT) ++ state = PERF_EVENT_STATE_EXIT; ++ if (flags & DETACH_DEAD) { + event->pending_disable = 1; ++ state = PERF_EVENT_STATE_DEAD; ++ } + event_sched_out(event, ctx); ++ perf_event_set_state(event, min(event->state, state)); + if (flags & DETACH_GROUP) + perf_group_detach(event); + if (flags & DETACH_CHILD) + perf_child_detach(event); + list_del_event(event, ctx); +- if (flags & DETACH_DEAD) +- event->state = PERF_EVENT_STATE_DEAD; + + if (!pmu_ctx->nr_events) { + pmu_ctx->rotate_necessary = 0; +@@ -13450,12 +13455,7 @@ perf_event_exit_event(struct perf_event *event, struct perf_event_context *ctx) + mutex_lock(&parent_event->child_mutex); + } + +- perf_remove_from_context(event, detach_flags); +- +- raw_spin_lock_irq(&ctx->lock); +- if (event->state > PERF_EVENT_STATE_EXIT) +- perf_event_set_state(event, PERF_EVENT_STATE_EXIT); +- raw_spin_unlock_irq(&ctx->lock); ++ perf_remove_from_context(event, detach_flags | DETACH_EXIT); + + /* + * Child events can be freed. +-- +2.39.5 + diff --git a/queue-6.14/series b/queue-6.14/series index f67715a7ba..6652f5690c 100644 --- a/queue-6.14/series +++ b/queue-6.14/series @@ -642,3 +642,18 @@ ipv6-do-not-consider-link-down-nexthops-in-path-sele.patch arcnet-add-null-check-in-com20020pci_probe.patch net-ibmveth-make-veth_pool_store-stop-hanging.patch netlink-specs-rt_route-pull-the-ifa-prefix-out-of-th.patch +tools-power-turbostat-allow-zero-return-value-for-so.patch +kbuild-deb-pkg-don-t-set-kbuild_build_version-uncond.patch +drm-xe-fix-unmet-direct-dependencies-warning.patch +drm-amdgpu-gfx11-fix-num_mec.patch +drm-amdgpu-gfx12-fix-num_mec.patch +perf-core-fix-child_total_time_enabled-accounting-bu.patch +tools-power-turbostat-report-corethr-per-measurement.patch +tools-power-turbostat-restore-gfx-sysfs-fflush-call.patch +staging-gpib-ni_usb-console-messaging-cleanup.patch +staging-gpib-fix-oops-after-disconnect-in-ni_usb.patch +staging-gpib-agilent-usb-console-messaging-cleanup.patch +staging-gpib-fix-oops-after-disconnect-in-agilent-us.patch +tty-serial-fsl_lpuart-use-u32-and-u8-for-register-va.patch +tty-serial-fsl_lpuart-use-port-struct-directly-to-si.patch +tty-serial-lpuart-only-disable-cts-instead-of-overwr.patch diff --git a/queue-6.14/staging-gpib-agilent-usb-console-messaging-cleanup.patch b/queue-6.14/staging-gpib-agilent-usb-console-messaging-cleanup.patch new file mode 100644 index 0000000000..df594772e0 --- /dev/null +++ b/queue-6.14/staging-gpib-agilent-usb-console-messaging-cleanup.patch @@ -0,0 +1,868 @@ +From fca1789d08c9d2e0cf42eafa09198e88433d94b5 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 14 Feb 2025 12:46:53 +0100 +Subject: staging: gpib: agilent usb console messaging cleanup + +From: Dave Penkler + +[ Upstream commit 50a6ed0494bc082227c38f427b40731bca9bdf15 ] + +Enable module name to be printed in pr_xxx and dev_xxx +Use DRV_NAME defined as KBUILD_MODNAME instead of hard coded +string in usb_driver struct. + +Remove __func__ parameter in dev_dbg messages as this can be +enabled with dynamic debug. + +Remove __func__ parameter in dev_err messages as they are not +needed. The module name is sufficient. + +Change pr_info to dev_dbg where needed and remove the rest +where possible. + +Remove test and error messages for buffer over run in write and +read_registers as these are just trying to catch bugs in the driver. + +Remove agilent_82357a string prefix in error messages. + +Return -EIO for too many reads in read_registers instead of +continuing after printing an error message. + +Change pr_warn to dev_warn. + +Remove warning on calls for unsupported functionality. + +Remove test and message for buffer overflow in agilent_82357_init +and agilent_82357a_go_idle which are just checking for a driver bug. +Use actual indeces in the array instead of i and then incrementing +i so that the code is clear and there is no need to check for +overflow or print a message. + +Signed-off-by: Dave Penkler +Link: https://lore.kernel.org/r/20250214114708.28947-3-dpenkler@gmail.com +Signed-off-by: Greg Kroah-Hartman +Stable-dep-of: 8491e73a5223 ("staging: gpib: Fix Oops after disconnect in agilent usb") +Signed-off-by: Sasha Levin +--- + .../gpib/agilent_82357a/agilent_82357a.c | 359 +++++++----------- + 1 file changed, 143 insertions(+), 216 deletions(-) + +diff --git a/drivers/staging/gpib/agilent_82357a/agilent_82357a.c b/drivers/staging/gpib/agilent_82357a/agilent_82357a.c +index 69f0e490d401d..7ebebe00dc489 100644 +--- a/drivers/staging/gpib/agilent_82357a/agilent_82357a.c ++++ b/drivers/staging/gpib/agilent_82357a/agilent_82357a.c +@@ -7,6 +7,10 @@ + + #define _GNU_SOURCE + ++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt ++#define dev_fmt pr_fmt ++#define DRV_NAME KBUILD_MODNAME ++ + #include + #include + #include +@@ -79,14 +83,12 @@ static int agilent_82357a_send_bulk_msg(struct agilent_82357a_priv *a_priv, void + + retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to submit bulk out urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", retval); + mutex_unlock(&a_priv->bulk_alloc_lock); + goto cleanup; + } + mutex_unlock(&a_priv->bulk_alloc_lock); + if (down_interruptible(&context->complete)) { +- dev_err(&usb_dev->dev, "%s: interrupted\n", __func__); + retval = -ERESTARTSYS; + goto cleanup; + } +@@ -149,14 +151,12 @@ static int agilent_82357a_receive_bulk_msg(struct agilent_82357a_priv *a_priv, v + + retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to submit bulk out urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval); + mutex_unlock(&a_priv->bulk_alloc_lock); + goto cleanup; + } + mutex_unlock(&a_priv->bulk_alloc_lock); + if (down_interruptible(&context->complete)) { +- dev_err(&usb_dev->dev, "%s: interrupted\n", __func__); + retval = -ERESTARTSYS; + goto cleanup; + } +@@ -205,7 +205,6 @@ static int agilent_82357a_receive_control_msg(struct agilent_82357a_priv *a_priv + + static void agilent_82357a_dump_raw_block(const u8 *raw_data, int length) + { +- pr_info("hex block dump\n"); + print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true); + } + +@@ -225,7 +224,7 @@ static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv, + static const int max_writes = 31; + + if (num_writes > max_writes) { +- dev_err(&usb_dev->dev, "%s: bug! num_writes=%i too large\n", __func__, num_writes); ++ dev_err(&usb_dev->dev, "bug! num_writes=%i too large\n", num_writes); + return -EIO; + } + out_data_length = num_writes * bytes_per_write + header_length; +@@ -239,8 +238,7 @@ static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv, + out_data[i++] = writes[j].address; + out_data[i++] = writes[j].value; + } +- if (i > out_data_length) +- dev_err(&usb_dev->dev, "%s: bug! buffer overrun\n", __func__); ++ + retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); + if (retval) { + kfree(out_data); +@@ -249,8 +247,8 @@ static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv, + retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000); + kfree(out_data); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + mutex_unlock(&a_priv->bulk_transfer_lock); + return retval; + } +@@ -265,20 +263,19 @@ static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv, + mutex_unlock(&a_priv->bulk_transfer_lock); + + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + agilent_82357a_dump_raw_block(in_data, bytes_read); + kfree(in_data); + return -EIO; + } + if (in_data[0] != (0xff & ~DATA_PIPE_CMD_WR_REGS)) { +- dev_err(&usb_dev->dev, "%s: error, bulk command=0x%x != ~DATA_PIPE_CMD_WR_REGS\n", +- __func__, in_data[0]); ++ dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_WR_REGS\n", in_data[0]); + return -EIO; + } + if (in_data[1]) { +- dev_err(&usb_dev->dev, "%s: nonzero error code 0x%x in DATA_PIPE_CMD_WR_REGS response\n", +- __func__, in_data[1]); ++ dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_WR_REGS response\n", ++ in_data[1]); + return -EIO; + } + kfree(in_data); +@@ -299,9 +296,10 @@ static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv, + static const int header_length = 2; + static const int max_reads = 62; + +- if (num_reads > max_reads) +- dev_err(&usb_dev->dev, "%s: bug! num_reads=%i too large\n", __func__, num_reads); +- ++ if (num_reads > max_reads) { ++ dev_err(&usb_dev->dev, "bug! num_reads=%i too large\n", num_reads); ++ return -EIO; ++ } + out_data_length = num_reads + header_length; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -311,8 +309,7 @@ static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv, + out_data[i++] = num_reads; + for (j = 0; j < num_reads; j++) + out_data[i++] = reads[j].address; +- if (i > out_data_length) +- dev_err(&usb_dev->dev, "%s: bug! buffer overrun\n", __func__); ++ + if (blocking) { + retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock); + if (retval) { +@@ -329,8 +326,8 @@ static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv, + retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000); + kfree(out_data); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + mutex_unlock(&a_priv->bulk_transfer_lock); + return retval; + } +@@ -345,21 +342,20 @@ static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv, + mutex_unlock(&a_priv->bulk_transfer_lock); + + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + agilent_82357a_dump_raw_block(in_data, bytes_read); + kfree(in_data); + return -EIO; + } + i = 0; + if (in_data[i++] != (0xff & ~DATA_PIPE_CMD_RD_REGS)) { +- dev_err(&usb_dev->dev, "%s: error, bulk command=0x%x != ~DATA_PIPE_CMD_RD_REGS\n", +- __func__, in_data[0]); ++ dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_RD_REGS\n", in_data[0]); + return -EIO; + } + if (in_data[i++]) { +- dev_err(&usb_dev->dev, "%s: nonzero error code 0x%x in DATA_PIPE_CMD_RD_REGS response\n", +- __func__, in_data[1]); ++ dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_RD_REGS response\n", ++ in_data[1]); + return -EIO; + } + for (j = 0; j < num_reads; j++) +@@ -390,14 +386,13 @@ static int agilent_82357a_abort(struct agilent_82357a_priv *a_priv, int flush) + wIndex, status_data, + status_data_len, 100); + if (receive_control_retval < 0) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_receive_control_msg() returned %i\n", +- __func__, receive_control_retval); ++ dev_err(&usb_dev->dev, "82357a_receive_control_msg() returned %i\n", ++ receive_control_retval); + retval = -EIO; + goto cleanup; + } + if (status_data[0] != (~XFER_ABORT & 0xff)) { +- dev_err(&usb_dev->dev, "%s: error, major code=0x%x != ~XFER_ABORT\n", +- __func__, status_data[0]); ++ dev_err(&usb_dev->dev, "major code=0x%x != ~XFER_ABORT\n", status_data[0]); + retval = -EIO; + goto cleanup; + } +@@ -413,8 +408,7 @@ static int agilent_82357a_abort(struct agilent_82357a_priv *a_priv, int flush) + fallthrough; + case UGP_ERR_FLUSHING_ALREADY: + default: +- dev_err(&usb_dev->dev, "%s: abort returned error code=0x%x\n", +- __func__, status_data[1]); ++ dev_err(&usb_dev->dev, "abort returned error code=0x%x\n", status_data[1]); + retval = -EIO; + break; + } +@@ -469,8 +463,8 @@ static int agilent_82357a_read(gpib_board_t *board, uint8_t *buffer, size_t leng + retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, msec_timeout); + kfree(out_data); + if (retval || bytes_written != i) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + mutex_unlock(&a_priv->bulk_transfer_lock); + if (retval < 0) + return retval; +@@ -501,19 +495,19 @@ static int agilent_82357a_read(gpib_board_t *board, uint8_t *buffer, size_t leng + &extra_bytes_read, 100); + bytes_read += extra_bytes_read; + if (extra_bytes_retval) { +- dev_err(&usb_dev->dev, "%s: extra_bytes_retval=%i, bytes_read=%i\n", +- __func__, extra_bytes_retval, bytes_read); ++ dev_err(&usb_dev->dev, "extra_bytes_retval=%i, bytes_read=%i\n", ++ extra_bytes_retval, bytes_read); + agilent_82357a_abort(a_priv, 0); + } + } else if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + agilent_82357a_abort(a_priv, 0); + } + mutex_unlock(&a_priv->bulk_transfer_lock); + if (bytes_read > length + 1) { + bytes_read = length + 1; +- pr_warn("%s: bytes_read > length? truncating", __func__); ++ dev_warn(&usb_dev->dev, "bytes_read > length? truncating"); + } + + if (bytes_read >= 1) { +@@ -584,8 +578,8 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + kfree(out_data); + if (retval || raw_bytes_written != i) { + agilent_82357a_abort(a_priv, 0); +- dev_err(&usb_dev->dev, "%s: agilent_82357a_send_bulk_msg returned %i, raw_bytes_written=%i, i=%i\n", +- __func__, retval, raw_bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, raw_bytes_written=%i, i=%i\n", ++ retval, raw_bytes_written, i); + mutex_unlock(&a_priv->bulk_transfer_lock); + if (retval < 0) + return retval; +@@ -597,7 +591,7 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + &a_priv->interrupt_flags) || + test_bit(TIMO_NUM, &board->status)); + if (retval) { +- dev_err(&usb_dev->dev, "%s: wait write complete interrupted\n", __func__); ++ dev_dbg(&usb_dev->dev, "wait write complete interrupted\n"); + agilent_82357a_abort(a_priv, 0); + mutex_unlock(&a_priv->bulk_transfer_lock); + return -ERESTARTSYS; +@@ -614,8 +608,7 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + read_reg.address = BSR; + retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return -ETIMEDOUT; + } + +@@ -632,8 +625,7 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + read_reg.address = ADSR; + retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return -ETIMEDOUT; + } + adsr = read_reg.value; +@@ -659,8 +651,7 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + 100); + mutex_unlock(&a_priv->bulk_transfer_lock); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_receive_control_msg() returned %i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "receive_control_msg() returned %i\n", retval); + kfree(status_data); + return -EIO; + } +@@ -699,8 +690,7 @@ int agilent_82357a_take_control_internal(gpib_board_t *board, int synchronous) + write.value = AUX_TCA; + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + + return retval; + } +@@ -741,8 +731,7 @@ static int agilent_82357a_go_to_standby(gpib_board_t *board) + write.value = AUX_GTS; + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return 0; + } + +@@ -771,8 +760,7 @@ static void agilent_82357a_request_system_control(gpib_board_t *board, int reque + ++i; + retval = agilent_82357a_write_registers(a_priv, writes, i); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return;// retval; + } + +@@ -791,8 +779,7 @@ static void agilent_82357a_interface_clear(gpib_board_t *board, int assert) + } + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + } + + static void agilent_82357a_remote_enable(gpib_board_t *board, int enable) +@@ -808,8 +795,7 @@ static void agilent_82357a_remote_enable(gpib_board_t *board, int enable) + write.value |= AUX_CS; + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + a_priv->ren_state = enable; + return;// 0; + } +@@ -818,10 +804,9 @@ static int agilent_82357a_enable_eos(gpib_board_t *board, uint8_t eos_byte, int + { + struct agilent_82357a_priv *a_priv = board->private_data; + +- if (compare_8_bits == 0) { +- pr_warn("%s: hardware only supports 8-bit EOS compare", __func__); ++ if (compare_8_bits == 0) + return -EOPNOTSUPP; +- } ++ + a_priv->eos_char = eos_byte; + a_priv->eos_mode = REOS | BIN; + return 0; +@@ -850,8 +835,7 @@ static unsigned int agilent_82357a_update_status(gpib_board_t *board, unsigned i + retval = agilent_82357a_read_registers(a_priv, &address_status, 1, 0); + if (retval) { + if (retval != -EAGAIN) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return board->status; + } + // check for remote/local +@@ -883,8 +867,7 @@ static unsigned int agilent_82357a_update_status(gpib_board_t *board, unsigned i + retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0); + if (retval) { + if (retval != -EAGAIN) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return board->status; + } + if (bus_status.value & BSR_SRQ_BIT) +@@ -907,8 +890,7 @@ static int agilent_82357a_primary_address(gpib_board_t *board, unsigned int addr + write.value = address & ADDRESS_MASK; + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return retval; + } + return retval; +@@ -917,8 +899,8 @@ static int agilent_82357a_primary_address(gpib_board_t *board, unsigned int addr + static int agilent_82357a_secondary_address(gpib_board_t *board, unsigned int address, int enable) + { + if (enable) +- pr_warn("%s: warning: assigning a secondary address not supported\n", __func__); +- return -EOPNOTSUPP; ++ return -EOPNOTSUPP; ++ return 0; + } + + static int agilent_82357a_parallel_poll(gpib_board_t *board, uint8_t *result) +@@ -936,16 +918,14 @@ static int agilent_82357a_parallel_poll(gpib_board_t *board, uint8_t *result) + writes[1].value = a_priv->hw_control_bits & ~NOT_PARALLEL_POLL; + retval = agilent_82357a_write_registers(a_priv, writes, 2); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return retval; + } + udelay(2); //silly, since usb write will take way longer + read.address = CPTR; + retval = agilent_82357a_read_registers(a_priv, &read, 1, 1); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return retval; + } + *result = read.value; +@@ -956,8 +936,7 @@ static int agilent_82357a_parallel_poll(gpib_board_t *board, uint8_t *result) + writes[1].value = AUX_RPP; + retval = agilent_82357a_write_registers(a_priv, writes, 2); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return retval; + } + return 0; +@@ -1005,8 +984,7 @@ static int agilent_82357a_line_status(const gpib_board_t *board) + retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0); + if (retval) { + if (retval != -EAGAIN) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return retval; + } + if (bus_status.value & BSR_REN_BIT) +@@ -1055,8 +1033,7 @@ static unsigned int agilent_82357a_t1_delay(gpib_board_t *board, unsigned int na + write.value = nanosec_to_fast_talker_bits(&nanosec); + retval = agilent_82357a_write_registers(a_priv, &write, 1); + if (retval) +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return nanosec; + } + +@@ -1081,7 +1058,7 @@ static void agilent_82357a_interrupt_complete(struct urb *urb) + default: /* other error, resubmit */ + retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC); + if (retval) +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb\n", __func__); ++ dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); + return; + } + +@@ -1097,7 +1074,7 @@ static void agilent_82357a_interrupt_complete(struct urb *urb) + + retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC); + if (retval) +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb\n", __func__); ++ dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); + } + + static int agilent_82357a_setup_urbs(gpib_board_t *board) +@@ -1133,8 +1110,7 @@ static int agilent_82357a_setup_urbs(gpib_board_t *board) + if (retval) { + usb_free_urb(a_priv->interrupt_urb); + a_priv->interrupt_urb = NULL; +- dev_err(&usb_dev->dev, "%s: failed to submit first interrupt urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval); + goto setup_exit; + } + mutex_unlock(&a_priv->interrupt_alloc_lock); +@@ -1184,108 +1160,78 @@ static void agilent_82357a_free_private(gpib_board_t *board) + { + kfree(board->private_data); + board->private_data = NULL; +- + } + ++#define INIT_NUM_REG_WRITES 18 + static int agilent_82357a_init(gpib_board_t *board) + { + struct agilent_82357a_priv *a_priv = board->private_data; + struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); + struct agilent_82357a_register_pairlet hw_control; +- struct agilent_82357a_register_pairlet writes[0x20]; ++ struct agilent_82357a_register_pairlet writes[INIT_NUM_REG_WRITES]; + int retval; +- int i; + unsigned int nanosec; + +- i = 0; +- writes[i].address = LED_CONTROL; +- writes[i].value = FAIL_LED_ON; +- ++i; +- writes[i].address = RESET_TO_POWERUP; +- writes[i].value = RESET_SPACEBALL; +- ++i; +- retval = agilent_82357a_write_registers(a_priv, writes, i); ++ writes[0].address = LED_CONTROL; ++ writes[0].value = FAIL_LED_ON; ++ writes[1].address = RESET_TO_POWERUP; ++ writes[1].value = RESET_SPACEBALL; ++ retval = agilent_82357a_write_registers(a_priv, writes, 2); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return -EIO; + } + set_current_state(TASK_INTERRUPTIBLE); + if (schedule_timeout(usec_to_jiffies(2000))) + return -ERESTARTSYS; +- i = 0; +- writes[i].address = AUXCR; +- writes[i].value = AUX_NBAF; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_HLDE; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_TON; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_LON; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_RSV2; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_INVAL; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_RPP; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_STDL; +- ++i; +- writes[i].address = AUXCR; +- writes[i].value = AUX_VSTDL; +- ++i; +- writes[i].address = FAST_TALKER_T1; ++ writes[0].address = AUXCR; ++ writes[0].value = AUX_NBAF; ++ writes[1].address = AUXCR; ++ writes[1].value = AUX_HLDE; ++ writes[2].address = AUXCR; ++ writes[2].value = AUX_TON; ++ writes[3].address = AUXCR; ++ writes[3].value = AUX_LON; ++ writes[4].address = AUXCR; ++ writes[4].value = AUX_RSV2; ++ writes[5].address = AUXCR; ++ writes[5].value = AUX_INVAL; ++ writes[6].address = AUXCR; ++ writes[6].value = AUX_RPP; ++ writes[7].address = AUXCR; ++ writes[7].value = AUX_STDL; ++ writes[8].address = AUXCR; ++ writes[8].value = AUX_VSTDL; ++ writes[9].address = FAST_TALKER_T1; + nanosec = board->t1_nano_sec; +- writes[i].value = nanosec_to_fast_talker_bits(&nanosec); ++ writes[9].value = nanosec_to_fast_talker_bits(&nanosec); + board->t1_nano_sec = nanosec; +- ++i; +- writes[i].address = ADR; +- writes[i].value = board->pad & ADDRESS_MASK; +- ++i; +- writes[i].address = PPR; +- writes[i].value = 0; +- ++i; +- writes[i].address = SPMR; +- writes[i].value = 0; +- ++i; +- writes[i].address = PROTOCOL_CONTROL; +- writes[i].value = WRITE_COMPLETE_INTERRUPT_EN; +- ++i; +- writes[i].address = IMR0; +- writes[i].value = HR_BOIE | HR_BIIE; +- ++i; +- writes[i].address = IMR1; +- writes[i].value = HR_SRQIE; +- ++i; ++ writes[10].address = ADR; ++ writes[10].value = board->pad & ADDRESS_MASK; ++ writes[11].address = PPR; ++ writes[11].value = 0; ++ writes[12].address = SPMR; ++ writes[12].value = 0; ++ writes[13].address = PROTOCOL_CONTROL; ++ writes[13].value = WRITE_COMPLETE_INTERRUPT_EN; ++ writes[14].address = IMR0; ++ writes[14].value = HR_BOIE | HR_BIIE; ++ writes[15].address = IMR1; ++ writes[15].value = HR_SRQIE; + // turn off reset state +- writes[i].address = AUXCR; +- writes[i].value = AUX_CHIP_RESET; +- ++i; +- writes[i].address = LED_CONTROL; +- writes[i].value = FIRMWARE_LED_CONTROL; +- ++i; +- if (i > ARRAY_SIZE(writes)) { +- dev_err(&usb_dev->dev, "%s: bug! writes[] overflow\n", __func__); +- return -EFAULT; +- } +- retval = agilent_82357a_write_registers(a_priv, writes, i); ++ writes[16].address = AUXCR; ++ writes[16].value = AUX_CHIP_RESET; ++ writes[17].address = LED_CONTROL; ++ writes[17].value = FIRMWARE_LED_CONTROL; ++ retval = agilent_82357a_write_registers(a_priv, writes, INIT_NUM_REG_WRITES); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return -EIO; + } + hw_control.address = HW_CONTROL; + retval = agilent_82357a_read_registers(a_priv, &hw_control, 1, 1); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_read_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "read_registers() returned error\n"); + return -EIO; + } + a_priv->hw_control_bits = (hw_control.value & ~0x7) | NOT_TI_RESET | NOT_PARALLEL_POLL; +@@ -1336,7 +1282,7 @@ static int agilent_82357a_attach(gpib_board_t *board, const gpib_board_config_t + } + if (i == MAX_NUM_82357A_INTERFACES) { + dev_err(board->gpib_dev, +- "No Agilent 82357 gpib adapters found, have you loaded its firmware?\n"); ++ "No supported adapters found, have you loaded its firmware?\n"); + retval = -ENODEV; + goto attach_fail; + } +@@ -1372,8 +1318,7 @@ static int agilent_82357a_attach(gpib_board_t *board, const gpib_board_config_t + goto attach_fail; + } + +- dev_info(&usb_dev->dev, +- "bus %d dev num %d attached to gpib minor %d, agilent usb interface %i\n", ++ dev_info(&usb_dev->dev, "bus %d dev num %d attached to gpib%d, interface %i\n", + usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); + mutex_unlock(&agilent_82357a_hotplug_lock); + return retval; +@@ -1390,37 +1335,24 @@ static int agilent_82357a_go_idle(gpib_board_t *board) + struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); + struct agilent_82357a_register_pairlet writes[0x20]; + int retval; +- int i; + +- i = 0; + // turn on tms9914 reset state +- writes[i].address = AUXCR; +- writes[i].value = AUX_CS | AUX_CHIP_RESET; +- ++i; ++ writes[0].address = AUXCR; ++ writes[0].value = AUX_CS | AUX_CHIP_RESET; + a_priv->hw_control_bits &= ~NOT_TI_RESET; +- writes[i].address = HW_CONTROL; +- writes[i].value = a_priv->hw_control_bits; +- ++i; +- writes[i].address = PROTOCOL_CONTROL; +- writes[i].value = 0; +- ++i; +- writes[i].address = IMR0; +- writes[i].value = 0; +- ++i; +- writes[i].address = IMR1; +- writes[i].value = 0; +- ++i; +- writes[i].address = LED_CONTROL; +- writes[i].value = 0; +- ++i; +- if (i > ARRAY_SIZE(writes)) { +- dev_err(&usb_dev->dev, "%s: bug! writes[] overflow\n", __func__); +- return -EFAULT; +- } +- retval = agilent_82357a_write_registers(a_priv, writes, i); ++ writes[1].address = HW_CONTROL; ++ writes[1].value = a_priv->hw_control_bits; ++ writes[2].address = PROTOCOL_CONTROL; ++ writes[2].value = 0; ++ writes[3].address = IMR0; ++ writes[3].value = 0; ++ writes[4].address = IMR1; ++ writes[4].value = 0; ++ writes[5].address = LED_CONTROL; ++ writes[5].value = 0; ++ retval = agilent_82357a_write_registers(a_priv, writes, 6); + if (retval) { +- dev_err(&usb_dev->dev, "%s: agilent_82357a_write_registers() returned error\n", +- __func__); ++ dev_err(&usb_dev->dev, "write_registers() returned error\n"); + return -EIO; + } + return 0; +@@ -1445,7 +1377,6 @@ static void agilent_82357a_detach(gpib_board_t *board) + agilent_82357a_release_urbs(a_priv); + agilent_82357a_free_private(board); + } +- dev_info(board->gpib_dev, "%s: detached\n", __func__); + mutex_unlock(&agilent_82357a_hotplug_lock); + } + +@@ -1510,8 +1441,7 @@ static int agilent_82357a_driver_probe(struct usb_interface *interface, + if (i == MAX_NUM_82357A_INTERFACES) { + usb_put_dev(usb_dev); + mutex_unlock(&agilent_82357a_hotplug_lock); +- dev_err(&usb_dev->dev, "%s: out of space in agilent_82357a_driver_interfaces[]\n", +- __func__); ++ dev_err(&usb_dev->dev, "out of space in agilent_82357a_driver_interfaces[]\n"); + return -1; + } + path = kmalloc(path_length, GFP_KERNEL); +@@ -1552,13 +1482,12 @@ static void agilent_82357a_driver_disconnect(struct usb_interface *interface) + mutex_unlock(&a_priv->control_alloc_lock); + } + } +- dev_dbg(&usb_dev->dev, "nulled agilent_82357a_driver_interfaces[%i]\n", i); + agilent_82357a_driver_interfaces[i] = NULL; + break; + } + } + if (i == MAX_NUM_82357A_INTERFACES) +- dev_err(&usb_dev->dev, "unable to find interface in agilent_82357a_driver_interfaces[]? bug?\n"); ++ dev_err(&usb_dev->dev, "unable to find interface - bug?\n"); + usb_put_dev(usb_dev); + + mutex_unlock(&agilent_82357a_hotplug_lock); +@@ -1583,18 +1512,18 @@ static int agilent_82357a_driver_suspend(struct usb_interface *interface, pm_mes + agilent_82357a_abort(a_priv, 0); + retval = agilent_82357a_go_idle(board); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to go idle, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to go idle, retval=%i\n", ++ retval); + mutex_unlock(&agilent_82357a_hotplug_lock); + return retval; + } + mutex_lock(&a_priv->interrupt_alloc_lock); + agilent_82357a_cleanup_urbs(a_priv); + mutex_unlock(&a_priv->interrupt_alloc_lock); +- dev_info(&usb_dev->dev, +- "bus %d dev num %d gpib minor %d, agilent usb interface %i suspended\n", +- usb_dev->bus->busnum, usb_dev->devnum, +- board->minor, i); ++ dev_dbg(&usb_dev->dev, ++ "bus %d dev num %d gpib %d, interface %i suspended\n", ++ usb_dev->bus->busnum, usb_dev->devnum, ++ board->minor, i); + } + } + break; +@@ -1631,8 +1560,8 @@ static int agilent_82357a_driver_resume(struct usb_interface *interface) + mutex_lock(&a_priv->interrupt_alloc_lock); + retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to resubmit interrupt urb in resume, retval=%i\n", ++ retval); + mutex_unlock(&a_priv->interrupt_alloc_lock); + mutex_unlock(&agilent_82357a_hotplug_lock); + return retval; +@@ -1655,9 +1584,9 @@ static int agilent_82357a_driver_resume(struct usb_interface *interface) + // assert/unassert REN + agilent_82357a_remote_enable(board, a_priv->ren_state); + +- dev_info(&usb_dev->dev, +- "bus %d dev num %d gpib minor %d, agilent usb interface %i resumed\n", +- usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); ++ dev_dbg(&usb_dev->dev, ++ "bus %d dev num %d gpib%d, interface %i resumed\n", ++ usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); + } + + resume_exit: +@@ -1667,7 +1596,7 @@ static int agilent_82357a_driver_resume(struct usb_interface *interface) + } + + static struct usb_driver agilent_82357a_bus_driver = { +- .name = "agilent_82357a_gpib", ++ .name = DRV_NAME, + .probe = agilent_82357a_driver_probe, + .disconnect = agilent_82357a_driver_disconnect, + .suspend = agilent_82357a_driver_suspend, +@@ -1680,19 +1609,18 @@ static int __init agilent_82357a_init_module(void) + int i; + int ret; + +- pr_info("agilent_82357a_gpib driver loading"); + for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) + agilent_82357a_driver_interfaces[i] = NULL; + + ret = usb_register(&agilent_82357a_bus_driver); + if (ret) { +- pr_err("agilent_82357a: usb_register failed: error = %d\n", ret); ++ pr_err("usb_register failed: error = %d\n", ret); + return ret; + } + + ret = gpib_register_driver(&agilent_82357a_gpib_interface, THIS_MODULE); + if (ret) { +- pr_err("agilent_82357a: gpib_register_driver failed: error = %d\n", ret); ++ pr_err("gpib_register_driver failed: error = %d\n", ret); + usb_deregister(&agilent_82357a_bus_driver); + return ret; + } +@@ -1702,7 +1630,6 @@ static int __init agilent_82357a_init_module(void) + + static void __exit agilent_82357a_exit_module(void) + { +- pr_info("agilent_82357a_gpib driver unloading"); + gpib_unregister_driver(&agilent_82357a_gpib_interface); + usb_deregister(&agilent_82357a_bus_driver); + } +-- +2.39.5 + diff --git a/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-agilent-us.patch b/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-agilent-us.patch new file mode 100644 index 0000000000..df60769a05 --- /dev/null +++ b/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-agilent-us.patch @@ -0,0 +1,239 @@ +From ad71978f2610eebad58d4de9242928c64e50d2ca Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 22 Feb 2025 21:45:15 +0100 +Subject: staging: gpib: Fix Oops after disconnect in agilent usb + +From: Dave Penkler + +[ Upstream commit 8491e73a5223acb0a4b4d78c3f8b96aa9c5e774d ] + +If the agilent usb dongle is disconnected subsequent calls to the +driver cause a NULL dereference Oops as the bus_interface +is set to NULL on disconnect. + +This problem was introduced by setting usb_dev from the bus_interface +for dev_xxx messages. + +Previously bus_interface was checked for NULL only in the functions +directly calling usb_fill_bulk_urb or usb_control_msg. + +Check for valid bus_interface on all interface entry points +and return -ENODEV if it is NULL. + +Fixes: fbae7090f30c ("staging: gpib: Update messaging and usb_device refs in agilent_usb") +Cc: stable +Signed-off-by: Dave Penkler +Link: https://lore.kernel.org/r/20250222204515.5104-1-dpenkler@gmail.com +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Sasha Levin +--- + .../gpib/agilent_82357a/agilent_82357a.c | 65 ++++++++++++++++--- + 1 file changed, 55 insertions(+), 10 deletions(-) + +diff --git a/drivers/staging/gpib/agilent_82357a/agilent_82357a.c b/drivers/staging/gpib/agilent_82357a/agilent_82357a.c +index 7ebebe00dc489..e0d36f0dff25e 100644 +--- a/drivers/staging/gpib/agilent_82357a/agilent_82357a.c ++++ b/drivers/staging/gpib/agilent_82357a/agilent_82357a.c +@@ -427,7 +427,7 @@ static int agilent_82357a_read(gpib_board_t *board, uint8_t *buffer, size_t leng + { + int retval; + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + int out_data_length, in_data_length; + int bytes_written, bytes_read; +@@ -438,6 +438,10 @@ static int agilent_82357a_read(gpib_board_t *board, uint8_t *buffer, size_t leng + + *nbytes = 0; + *end = 0; ++ ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + out_data_length = 0x9; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -534,7 +538,7 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + { + int retval; + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data = NULL; + u8 *status_data = NULL; + int out_data_length; +@@ -545,6 +549,10 @@ static ssize_t agilent_82357a_generic_write(gpib_board_t *board, uint8_t *buffer + struct agilent_82357a_register_pairlet read_reg; + + *bytes_written = 0; ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + out_data_length = length + 0x8; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -697,9 +705,13 @@ int agilent_82357a_take_control_internal(gpib_board_t *board, int synchronous) + + static int agilent_82357a_take_control(gpib_board_t *board, int synchronous) + { ++ struct agilent_82357a_priv *a_priv = board->private_data; + const int timeout = 10; + int i; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ + /* It looks like the 9914 does not handle tcs properly. + * See comment above tms9914_take_control_workaround() in + * drivers/gpib/tms9914/tms9914_aux.c +@@ -723,10 +735,14 @@ static int agilent_82357a_take_control(gpib_board_t *board, int synchronous) + static int agilent_82357a_go_to_standby(gpib_board_t *board) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet write; + int retval; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + write.address = AUXCR; + write.value = AUX_GTS; + retval = agilent_82357a_write_registers(a_priv, &write, 1); +@@ -739,11 +755,15 @@ static int agilent_82357a_go_to_standby(gpib_board_t *board) + static void agilent_82357a_request_system_control(gpib_board_t *board, int request_control) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet writes[2]; + int retval; + int i = 0; + ++ if (!a_priv->bus_interface) ++ return; // -ENODEV; ++ ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + /* 82357B needs bit to be set in 9914 AUXCR register */ + writes[i].address = AUXCR; + if (request_control) { +@@ -767,10 +787,14 @@ static void agilent_82357a_request_system_control(gpib_board_t *board, int reque + static void agilent_82357a_interface_clear(gpib_board_t *board, int assert) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet write; + int retval; + ++ if (!a_priv->bus_interface) ++ return; // -ENODEV; ++ ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + write.address = AUXCR; + write.value = AUX_SIC; + if (assert) { +@@ -785,10 +809,14 @@ static void agilent_82357a_interface_clear(gpib_board_t *board, int assert) + static void agilent_82357a_remote_enable(gpib_board_t *board, int enable) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet write; + int retval; + ++ if (!a_priv->bus_interface) ++ return; //-ENODEV; ++ ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + write.address = AUXCR; + write.value = AUX_SRE; + if (enable) +@@ -804,6 +832,8 @@ static int agilent_82357a_enable_eos(gpib_board_t *board, uint8_t eos_byte, int + { + struct agilent_82357a_priv *a_priv = board->private_data; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; + if (compare_8_bits == 0) + return -EOPNOTSUPP; + +@@ -822,10 +852,13 @@ static void agilent_82357a_disable_eos(gpib_board_t *board) + static unsigned int agilent_82357a_update_status(gpib_board_t *board, unsigned int clear_mask) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet address_status, bus_status; + int retval; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + board->status &= ~clear_mask; + if (a_priv->is_cic) + set_bit(CIC_NUM, &board->status); +@@ -885,6 +918,9 @@ static int agilent_82357a_primary_address(gpib_board_t *board, unsigned int addr + struct agilent_82357a_register_pairlet write; + int retval; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + // put primary address in address0 + write.address = ADR; + write.value = address & ADDRESS_MASK; +@@ -906,11 +942,14 @@ static int agilent_82357a_secondary_address(gpib_board_t *board, unsigned int ad + static int agilent_82357a_parallel_poll(gpib_board_t *board, uint8_t *result) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet writes[2]; + struct agilent_82357a_register_pairlet read; + int retval; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + // execute parallel poll + writes[0].address = AUXCR; + writes[0].value = AUX_CS | AUX_RPP; +@@ -975,11 +1014,14 @@ static void agilent_82357a_return_to_local(gpib_board_t *board) + static int agilent_82357a_line_status(const gpib_board_t *board) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet bus_status; + int retval; + int status = ValidALL; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + bus_status.address = BSR; + retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0); + if (retval) { +@@ -1025,10 +1067,13 @@ static unsigned short nanosec_to_fast_talker_bits(unsigned int *nanosec) + static unsigned int agilent_82357a_t1_delay(gpib_board_t *board, unsigned int nanosec) + { + struct agilent_82357a_priv *a_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface); ++ struct usb_device *usb_dev; + struct agilent_82357a_register_pairlet write; + int retval; + ++ if (!a_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(a_priv->bus_interface); + write.address = FAST_TALKER_T1; + write.value = nanosec_to_fast_talker_bits(&nanosec); + retval = agilent_82357a_write_registers(a_priv, &write, 1); +-- +2.39.5 + diff --git a/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-ni_usb.patch b/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-ni_usb.patch new file mode 100644 index 0000000000..4b02babbbd --- /dev/null +++ b/queue-6.14/staging-gpib-fix-oops-after-disconnect-in-ni_usb.patch @@ -0,0 +1,360 @@ +From 566276f9e0c243e3c3d63c2597475487416713ac Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 22 Feb 2025 17:58:17 +0100 +Subject: staging: gpib: Fix Oops after disconnect in ni_usb + +From: Dave Penkler + +[ Upstream commit a239c6e91b665f1837cf57b97fe638ef1baf2e78 ] + +If the usb dongle is disconnected subsequent calls to the +driver cause a NULL dereference Oops as the bus_interface +is set to NULL on disconnect. + +This problem was introduced by setting usb_dev from the bus_interface +for dev_xxx messages. + +Previously bus_interface was checked for NULL only in the the functions +directly calling usb_fill_bulk_urb or usb_control_msg. + +Check for valid bus_interface on all interface entry points +and return -ENODEV if it is NULL. + +Fixes: 4934b98bb243 ("staging: gpib: Update messaging and usb_device refs in ni_usb") +Cc: stable +Signed-off-by: Dave Penkler +Link: https://lore.kernel.org/r/20250222165817.12856-1-dpenkler@gmail.com +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Sasha Levin +--- + drivers/staging/gpib/ni_usb/ni_usb_gpib.c | 93 ++++++++++++++++++----- + 1 file changed, 73 insertions(+), 20 deletions(-) + +diff --git a/drivers/staging/gpib/ni_usb/ni_usb_gpib.c b/drivers/staging/gpib/ni_usb/ni_usb_gpib.c +index 52c7530f07bb1..1b976a28a7fe4 100644 +--- a/drivers/staging/gpib/ni_usb/ni_usb_gpib.c ++++ b/drivers/staging/gpib/ni_usb/ni_usb_gpib.c +@@ -592,7 +592,7 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + { + int retval, parse_retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x20; + int in_data_length; +@@ -605,8 +605,11 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + struct ni_usb_register reg; + + *bytes_read = 0; ++ if (!ni_priv->bus_interface) ++ return -ENODEV; + if (length > max_read_length) + return -EINVAL; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -719,7 +722,7 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + int out_data_length; + static const int in_data_length = 0x10; +@@ -729,9 +732,11 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + struct ni_usb_status_block status; + static const int max_write_length = 0xffff; + +- *bytes_written = 0; ++ if (!ni_priv->bus_interface) ++ return -ENODEV; + if (length > max_write_length) + return -EINVAL; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data_length = length + 0x10; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -820,7 +825,7 @@ static int ni_usb_command_chunk(gpib_board_t *board, uint8_t *buffer, size_t len + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + int out_data_length; + static const int in_data_length = 0x10; +@@ -832,8 +837,11 @@ static int ni_usb_command_chunk(gpib_board_t *board, uint8_t *buffer, size_t len + static const int max_command_length = 0x10; + + *command_bytes_written = 0; ++ if (!ni_priv->bus_interface) ++ return -ENODEV; + if (length > max_command_length) + length = max_command_length; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data_length = length + 0x10; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -926,7 +934,7 @@ static int ni_usb_take_control(gpib_board_t *board, int synchronous) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x10; + static const int in_data_length = 0x10; +@@ -934,6 +942,9 @@ static int ni_usb_take_control(gpib_board_t *board, int synchronous) + int i = 0; + struct ni_usb_status_block status; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -984,7 +995,7 @@ static int ni_usb_go_to_standby(gpib_board_t *board) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x10; + static const int in_data_length = 0x20; +@@ -992,6 +1003,9 @@ static int ni_usb_go_to_standby(gpib_board_t *board) + int i = 0; + struct ni_usb_status_block status; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -1040,11 +1054,14 @@ static void ni_usb_request_system_control(gpib_board_t *board, int request_contr + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[4]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + if (request_control) { + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = CMDR; +@@ -1088,7 +1105,7 @@ static void ni_usb_interface_clear(gpib_board_t *board, int assert) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x10; + static const int in_data_length = 0x10; +@@ -1096,7 +1113,10 @@ static void ni_usb_interface_clear(gpib_board_t *board, int assert) + int i = 0; + struct ni_usb_status_block status; + +- // FIXME: we are going to pulse when assert is true, and ignore otherwise ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++// FIXME: we are going to pulse when assert is true, and ignore otherwise + if (assert == 0) + return; + out_data = kmalloc(out_data_length, GFP_KERNEL); +@@ -1134,10 +1154,13 @@ static void ni_usb_remote_enable(gpib_board_t *board, int enable) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + struct ni_usb_register reg; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + reg.device = NIUSB_SUBDEV_TNT4882; + reg.address = nec7210_to_tnt4882_offset(AUXMR); + if (enable) +@@ -1181,11 +1204,14 @@ static unsigned int ni_usb_update_status(gpib_board_t *board, unsigned int clear + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + static const int buffer_length = 8; + u8 *buffer; + struct ni_usb_status_block status; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + buffer = kmalloc(buffer_length, GFP_KERNEL); + if (!buffer) + return board->status; +@@ -1233,11 +1259,14 @@ static int ni_usb_primary_address(gpib_board_t *board, unsigned int address) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[2]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = nec7210_to_tnt4882_offset(ADR); + writes[i].value = address; +@@ -1288,11 +1317,14 @@ static int ni_usb_secondary_address(gpib_board_t *board, unsigned int address, i + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[3]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + i += ni_usb_write_sad(writes, address, enable); + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +@@ -1307,7 +1339,7 @@ static int ni_usb_parallel_poll(gpib_board_t *board, uint8_t *result) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x10; + static const int in_data_length = 0x20; +@@ -1316,6 +1348,9 @@ static int ni_usb_parallel_poll(gpib_board_t *board, uint8_t *result) + int j = 0; + struct ni_usb_status_block status; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -1359,11 +1394,14 @@ static void ni_usb_parallel_poll_configure(gpib_board_t *board, uint8_t config) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[1]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = nec7210_to_tnt4882_offset(AUXMR); + writes[i].value = PPR | config; +@@ -1381,11 +1419,14 @@ static void ni_usb_parallel_poll_response(gpib_board_t *board, int ist) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[1]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = nec7210_to_tnt4882_offset(AUXMR); + if (ist) +@@ -1406,11 +1447,14 @@ static void ni_usb_serial_poll_response(gpib_board_t *board, u8 status) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[1]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = nec7210_to_tnt4882_offset(SPMR); + writes[i].value = status; +@@ -1433,11 +1477,14 @@ static void ni_usb_return_to_local(gpib_board_t *board) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + int i = 0; + struct ni_usb_register writes[1]; + unsigned int ibsta; + ++ if (!ni_priv->bus_interface) ++ return; // -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + writes[i].device = NIUSB_SUBDEV_TNT4882; + writes[i].address = nec7210_to_tnt4882_offset(AUXMR); + writes[i].value = AUX_RTL; +@@ -1455,7 +1502,7 @@ static int ni_usb_line_status(const gpib_board_t *board) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + u8 *out_data, *in_data; + static const int out_data_length = 0x20; + static const int in_data_length = 0x20; +@@ -1465,6 +1512,9 @@ static int ni_usb_line_status(const gpib_board_t *board) + int line_status = ValidALL; + // NI windows driver reads 0xd(HSSEL), 0xc (ARD0), 0x1f (BSR) + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -1571,12 +1621,15 @@ static unsigned int ni_usb_t1_delay(gpib_board_t *board, unsigned int nano_sec) + { + int retval; + struct ni_usb_priv *ni_priv = board->private_data; +- struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); ++ struct usb_device *usb_dev; + struct ni_usb_register writes[3]; + unsigned int ibsta; + unsigned int actual_ns; + int i; + ++ if (!ni_priv->bus_interface) ++ return -ENODEV; ++ usb_dev = interface_to_usbdev(ni_priv->bus_interface); + i = ni_usb_setup_t1_delay(writes, nano_sec, &actual_ns); + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +-- +2.39.5 + diff --git a/queue-6.14/staging-gpib-ni_usb-console-messaging-cleanup.patch b/queue-6.14/staging-gpib-ni_usb-console-messaging-cleanup.patch new file mode 100644 index 0000000000..e849402f81 --- /dev/null +++ b/queue-6.14/staging-gpib-ni_usb-console-messaging-cleanup.patch @@ -0,0 +1,1310 @@ +From aecb54b75fbaa223f71d2ae08c27ff6beb7ce449 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 14 Feb 2025 12:47:05 +0100 +Subject: staging: gpib: ni_usb console messaging cleanup + +From: Dave Penkler + +[ Upstream commit 18ce5b5d9167bffce02550a85c7c3316a05ea598 ] + +Enable module name to be printed in pr_xxx and dev_xxx +Use DRV_NAME defined as KBUILD_MODNAME instead of hard coded +string "ni_usb_gpib" in usb_driver struct. + +Remove __func__ parameter from pr_err and dev_err. + +Remove __func__ parameter from dev_dbg as this can be +enabled by dynamic debug. + +Remove commented printk's and dev_err's. + +Remove kmalloc failed messages. + +Remove buffer over run bug dev_err message as this just checks +for a bug in the driver which does not exist. + +Remove read/write length too long messages and return -EINVAL + +Change dev_info to dev_dbg where possible. + +Move attach message to the end of attach function. + +Remove buffer overrun message. Use actual array indeces +instead of i and i++ to make code clear and check redundnant. + +Remove module init and exit pr_info's. + +Signed-off-by: Dave Penkler +Link: https://lore.kernel.org/r/20250214114708.28947-15-dpenkler@gmail.com +Signed-off-by: Greg Kroah-Hartman +Stable-dep-of: a239c6e91b66 ("staging: gpib: Fix Oops after disconnect in ni_usb") +Signed-off-by: Sasha Levin +--- + drivers/staging/gpib/ni_usb/ni_usb_gpib.c | 425 ++++++++++------------ + 1 file changed, 189 insertions(+), 236 deletions(-) + +diff --git a/drivers/staging/gpib/ni_usb/ni_usb_gpib.c b/drivers/staging/gpib/ni_usb/ni_usb_gpib.c +index d0656dc520f50..52c7530f07bb1 100644 +--- a/drivers/staging/gpib/ni_usb/ni_usb_gpib.c ++++ b/drivers/staging/gpib/ni_usb/ni_usb_gpib.c +@@ -5,6 +5,10 @@ + * copyright : (C) 2004 by Frank Mori Hess + ***************************************************************************/ + ++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt ++#define dev_fmt pr_fmt ++#define DRV_NAME KBUILD_MODNAME ++ + #include + #include + #include +@@ -75,7 +79,7 @@ static unsigned short ni_usb_timeout_code(unsigned int usec) + */ + else if (usec <= 1000000000) + return 0x02; +- pr_err("%s: bug? usec is greater than 1e9\n", __func__); ++ pr_err("bug? usec is greater than 1e9\n"); + return 0xf0; + } + +@@ -83,8 +87,6 @@ static void ni_usb_bulk_complete(struct urb *urb) + { + struct ni_usb_urb_ctx *context = urb->context; + +-// printk("debug: %s: status=0x%x, error_count=%i, actual_length=%i\n", __func__, +-// urb->status, urb->error_count, urb->actual_length); + complete(&context->complete); + } + +@@ -137,8 +139,8 @@ static int ni_usb_nonblocking_send_bulk_msg(struct ni_usb_priv *ni_priv, void *d + del_timer_sync(&ni_priv->bulk_timer); + usb_free_urb(ni_priv->bulk_urb); + ni_priv->bulk_urb = NULL; +- dev_err(&usb_dev->dev, "%s: failed to submit bulk out urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", ++ retval); + mutex_unlock(&ni_priv->bulk_transfer_lock); + return retval; + } +@@ -146,7 +148,7 @@ static int ni_usb_nonblocking_send_bulk_msg(struct ni_usb_priv *ni_priv, void *d + wait_for_completion(&context->complete); // wait for ni_usb_bulk_complete + if (context->timed_out) { + usb_kill_urb(ni_priv->bulk_urb); +- dev_err(&usb_dev->dev, "%s: killed urb due to timeout\n", __func__); ++ dev_err(&usb_dev->dev, "killed urb due to timeout\n"); + retval = -ETIMEDOUT; + } else { + retval = ni_priv->bulk_urb->status; +@@ -218,14 +220,12 @@ static int ni_usb_nonblocking_receive_bulk_msg(struct ni_usb_priv *ni_priv, + if (timeout_msecs) + mod_timer(&ni_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs)); + +- //printk("%s: submitting urb\n", __func__); + retval = usb_submit_urb(ni_priv->bulk_urb, GFP_KERNEL); + if (retval) { + del_timer_sync(&ni_priv->bulk_timer); + usb_free_urb(ni_priv->bulk_urb); + ni_priv->bulk_urb = NULL; +- dev_err(&usb_dev->dev, "%s: failed to submit bulk out urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval); + mutex_unlock(&ni_priv->bulk_transfer_lock); + return retval; + } +@@ -250,7 +250,7 @@ static int ni_usb_nonblocking_receive_bulk_msg(struct ni_usb_priv *ni_priv, + } + if (context->timed_out) { + usb_kill_urb(ni_priv->bulk_urb); +- dev_err(&usb_dev->dev, "%s: killed urb due to timeout\n", __func__); ++ dev_err(&usb_dev->dev, "killed urb due to timeout\n"); + retval = -ETIMEDOUT; + } else { + if (ni_priv->bulk_urb->status) +@@ -330,14 +330,14 @@ static void ni_usb_soft_update_status(gpib_board_t *board, unsigned int ni_usb_i + ni_priv->monitored_ibsta_bits &= ~ni_usb_ibsta; + need_monitoring_bits &= ~ni_priv->monitored_ibsta_bits; /* mm - monitored set */ + spin_unlock_irqrestore(&board->spinlock, flags); +- dev_dbg(&usb_dev->dev, "%s: need_monitoring_bits=0x%x\n", __func__, need_monitoring_bits); ++ dev_dbg(&usb_dev->dev, "need_monitoring_bits=0x%x\n", need_monitoring_bits); + + if (need_monitoring_bits & ~ni_usb_ibsta) + ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask); + else if (need_monitoring_bits & ni_usb_ibsta) + wake_up_interruptible(&board->wait); + +- dev_dbg(&usb_dev->dev, "%s: ni_usb_ibsta=0x%x\n", __func__, ni_usb_ibsta); ++ dev_dbg(&usb_dev->dev, "ibsta=0x%x\n", ni_usb_ibsta); + } + + static int ni_usb_parse_status_block(const u8 *buffer, struct ni_usb_status_block *status) +@@ -371,7 +371,7 @@ static int ni_usb_parse_register_read_block(const u8 *raw_data, unsigned int *re + int k; + + if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_START_ID) { +- pr_err("%s: parse error: wrong start id\n", __func__); ++ pr_err("parse error: wrong start id\n"); + unexpected = 1; + } + for (k = 0; k < results_per_chunk && j < num_results; ++k) +@@ -380,18 +380,18 @@ static int ni_usb_parse_register_read_block(const u8 *raw_data, unsigned int *re + while (i % 4) + i++; + if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_END_ID) { +- pr_err("%s: parse error: wrong end id\n", __func__); ++ pr_err("parse error: wrong end id\n"); + unexpected = 1; + } + if (raw_data[i++] % results_per_chunk != num_results % results_per_chunk) { +- pr_err("%s: parse error: wrong count=%i for NIUSB_REGISTER_READ_DATA_END\n", +- __func__, (int)raw_data[i - 1]); ++ pr_err("parse error: wrong count=%i for NIUSB_REGISTER_READ_DATA_END\n", ++ (int)raw_data[i - 1]); + unexpected = 1; + } + while (i % 4) { + if (raw_data[i++] != 0) { +- pr_err("%s: unexpected data: raw_data[%i]=0x%x, expected 0\n", +- __func__, i - 1, (int)raw_data[i - 1]); ++ pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", ++ i - 1, (int)raw_data[i - 1]); + unexpected = 1; + } + } +@@ -408,9 +408,8 @@ static int ni_usb_parse_termination_block(const u8 *buffer) + buffer[i++] != 0x0 || + buffer[i++] != 0x0 || + buffer[i++] != 0x0) { +- pr_err("%s: received unexpected termination block\n", __func__); +- pr_err(" expected: 0x%x 0x%x 0x%x 0x%x\n", +- NIUSB_TERM_ID, 0x0, 0x0, 0x0); ++ pr_err("received unexpected termination block\n"); ++ pr_err(" expected: 0x%x 0x%x 0x%x 0x%x\n", NIUSB_TERM_ID, 0x0, 0x0, 0x0); + pr_err(" received: 0x%x 0x%x 0x%x 0x%x\n", + buffer[i - 4], buffer[i - 3], buffer[i - 2], buffer[i - 1]); + } +@@ -438,12 +437,12 @@ static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_bl + } else if (raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) { + data_block_length = ibrd_extended_data_block_length; + if (raw_data[++i] != 0) { +- pr_err("%s: unexpected data: raw_data[%i]=0x%x, expected 0\n", +- __func__, i, (int)raw_data[i]); ++ pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", ++ i, (int)raw_data[i]); + unexpected = 1; + } + } else { +- pr_err("%s: logic bug!\n", __func__); ++ pr_err("Unexpected NIUSB_IBRD ID\n"); + return -EINVAL; + } + ++i; +@@ -457,7 +456,7 @@ static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_bl + } + i += ni_usb_parse_status_block(&raw_data[i], status); + if (status->id != NIUSB_IBRD_STATUS_ID) { +- pr_err("%s: bug: status->id=%i, != ibrd_status_id\n", __func__, status->id); ++ pr_err("bug: status->id=%i, != ibrd_status_id\n", status->id); + return -EIO; + } + adr1_bits = raw_data[i++]; +@@ -468,29 +467,28 @@ static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_bl + *actual_bytes_read = 0; + } + if (*actual_bytes_read > j) +- pr_err("%s: bug: discarded data. actual_bytes_read=%i, j=%i\n", +- __func__, *actual_bytes_read, j); ++ pr_err("bug: discarded data. actual_bytes_read=%i, j=%i\n", *actual_bytes_read, j); + for (k = 0; k < 2; k++) + if (raw_data[i++] != 0) { +- pr_err("%s: unexpected data: raw_data[%i]=0x%x, expected 0\n", +- __func__, i - 1, (int)raw_data[i - 1]); ++ pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", ++ i - 1, (int)raw_data[i - 1]); + unexpected = 1; + } + i += ni_usb_parse_status_block(&raw_data[i], ®ister_write_status); + if (register_write_status.id != NIUSB_REG_WRITE_ID) { +- pr_err("%s: unexpected data: register write status id=0x%x, expected 0x%x\n", +- __func__, register_write_status.id, NIUSB_REG_WRITE_ID); ++ pr_err("unexpected data: register write status id=0x%x, expected 0x%x\n", ++ register_write_status.id, NIUSB_REG_WRITE_ID); + unexpected = 1; + } + if (raw_data[i++] != 2) { +- pr_err("%s: unexpected data: register write count=%i, expected 2\n", +- __func__, (int)raw_data[i - 1]); ++ pr_err("unexpected data: register write count=%i, expected 2\n", ++ (int)raw_data[i - 1]); + unexpected = 1; + } + for (k = 0; k < 3; k++) + if (raw_data[i++] != 0) { +- pr_err("%s: unexpected data: raw_data[%i]=0x%x, expected 0\n", +- __func__, i - 1, (int)raw_data[i - 1]); ++ pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n", ++ i - 1, (int)raw_data[i - 1]); + unexpected = 1; + } + i += ni_usb_parse_termination_block(&raw_data[i]); +@@ -530,18 +528,14 @@ static int ni_usb_write_registers(struct ni_usb_priv *ni_priv, + + out_data_length = num_writes * bytes_per_write + 0x10; + out_data = kmalloc(out_data_length, GFP_KERNEL); +- if (!out_data) { +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); ++ if (!out_data) + return -ENOMEM; +- } + i += ni_usb_bulk_register_write_header(&out_data[i], num_writes); + for (j = 0; j < num_writes; j++) + i += ni_usb_bulk_register_write(&out_data[i], writes[j]); + while (i % 4) + out_data[i++] = 0x00; + i += ni_usb_bulk_termination(&out_data[i]); +- if (i > out_data_length) +- dev_err(&usb_dev->dev, "%s: bug! buffer overrun\n", __func__); + + mutex_lock(&ni_priv->addressed_transfer_lock); + +@@ -549,22 +543,21 @@ static int ni_usb_write_registers(struct ni_usb_priv *ni_priv, + kfree(out_data); + if (retval) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + + in_data = kmalloc(in_data_length, GFP_KERNEL); + if (!in_data) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); + return -ENOMEM; + } + retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); + if (retval || bytes_read != 16) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + ni_usb_dump_raw_block(in_data, bytes_read); + kfree(in_data); + return retval; +@@ -576,18 +569,16 @@ static int ni_usb_write_registers(struct ni_usb_priv *ni_priv, + //FIXME parse extra 09 status bits and termination + kfree(in_data); + if (status.id != NIUSB_REG_WRITE_ID) { +- dev_err(&usb_dev->dev, "%s: parse error, id=0x%x != NIUSB_REG_WRITE_ID\n", +- __func__, status.id); ++ dev_err(&usb_dev->dev, "parse error, id=0x%x != NIUSB_REG_WRITE_ID\n", status.id); + return -EIO; + } + if (status.error_code) { +- dev_err(&usb_dev->dev, "%s: nonzero error code 0x%x\n", +- __func__, status.error_code); ++ dev_err(&usb_dev->dev, "nonzero error code 0x%x\n", status.error_code); + return -EIO; + } + if (reg_writes_completed != num_writes) { +- dev_err(&usb_dev->dev, "%s: reg_writes_completed=%i, num_writes=%i\n", +- __func__, reg_writes_completed, num_writes); ++ dev_err(&usb_dev->dev, "reg_writes_completed=%i, num_writes=%i\n", ++ reg_writes_completed, num_writes); + return -EIO; + } + if (ibsta) +@@ -614,10 +605,8 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + struct ni_usb_register reg; + + *bytes_read = 0; +- if (length > max_read_length) { +- length = max_read_length; +- dev_err(&usb_dev->dev, "%s: read length too long\n", __func__); +- } ++ if (length > max_read_length) ++ return -EINVAL; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) + return -ENOMEM; +@@ -649,8 +638,8 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + if (retval || usb_bytes_written != i) { + if (retval == 0) + retval = -EIO; +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", +- __func__, retval, usb_bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", ++ retval, usb_bytes_written, i); + mutex_unlock(&ni_priv->addressed_transfer_lock); + return retval; + } +@@ -668,8 +657,8 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + + if (retval == -ERESTARTSYS) { + } else if (retval) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, usb_bytes_read=%i\n", +- __func__, retval, usb_bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n", ++ retval, usb_bytes_read); + kfree(in_data); + return retval; + } +@@ -677,14 +666,14 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + if (parse_retval != usb_bytes_read) { + if (parse_retval >= 0) + parse_retval = -EIO; +- dev_err(&usb_dev->dev, "%s: retval=%i usb_bytes_read=%i\n", +- __func__, parse_retval, usb_bytes_read); ++ dev_err(&usb_dev->dev, "retval=%i usb_bytes_read=%i\n", ++ parse_retval, usb_bytes_read); + kfree(in_data); + return parse_retval; + } + if (actual_length != length - status.count) { +- dev_err(&usb_dev->dev, "%s: actual_length=%i expected=%li\n", +- __func__, actual_length, (long)(length - status.count)); ++ dev_err(&usb_dev->dev, "actual_length=%i expected=%li\n", ++ actual_length, (long)(length - status.count)); + ni_usb_dump_raw_block(in_data, usb_bytes_read); + } + kfree(in_data); +@@ -699,7 +688,7 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + break; + case NIUSB_ATN_STATE_ERROR: + retval = -EIO; +- dev_err(&usb_dev->dev, "%s: read when ATN set\n", __func__); ++ dev_err(&usb_dev->dev, "read when ATN set\n"); + break; + case NIUSB_ADDRESSING_ERROR: + retval = -EIO; +@@ -708,12 +697,11 @@ static int ni_usb_read(gpib_board_t *board, uint8_t *buffer, size_t length, + retval = -ETIMEDOUT; + break; + case NIUSB_EOSMODE_ERROR: +- dev_err(&usb_dev->dev, "%s: driver bug, we should have been able to avoid NIUSB_EOSMODE_ERROR.\n", +- __func__); ++ dev_err(&usb_dev->dev, "driver bug, we should have been able to avoid NIUSB_EOSMODE_ERROR.\n"); + retval = -EINVAL; + break; + default: +- dev_err(&usb_dev->dev, "%s: unknown error code=%i\n", __func__, status.error_code); ++ dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); + retval = -EIO; + break; + } +@@ -742,11 +730,8 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + static const int max_write_length = 0xffff; + + *bytes_written = 0; +- if (length > max_write_length) { +- length = max_write_length; +- send_eoi = 0; +- dev_err(&usb_dev->dev, "%s: write length too long\n", __func__); +- } ++ if (length > max_write_length) ++ return -EINVAL; + out_data_length = length + 0x10; + out_data = kmalloc(out_data_length, GFP_KERNEL); + if (!out_data) +@@ -777,8 +762,8 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + kfree(out_data); + if (retval || usb_bytes_written != i) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", +- __func__, retval, usb_bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n", ++ retval, usb_bytes_written, i); + return retval; + } + +@@ -793,8 +778,8 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + mutex_unlock(&ni_priv->addressed_transfer_lock); + + if ((retval && retval != -ERESTARTSYS) || usb_bytes_read != 12) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, usb_bytes_read=%i\n", +- __func__, retval, usb_bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n", ++ retval, usb_bytes_read); + kfree(in_data); + return retval; + } +@@ -810,8 +795,8 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + */ + break; + case NIUSB_ADDRESSING_ERROR: +- dev_err(&usb_dev->dev, "%s: Addressing error retval %d error code=%i\n", +- __func__, retval, status.error_code); ++ dev_err(&usb_dev->dev, "Addressing error retval %d error code=%i\n", ++ retval, status.error_code); + retval = -ENXIO; + break; + case NIUSB_NO_LISTENER_ERROR: +@@ -821,8 +806,7 @@ static int ni_usb_write(gpib_board_t *board, uint8_t *buffer, size_t length, + retval = -ETIMEDOUT; + break; + default: +- dev_err(&usb_dev->dev, "%s: unknown error code=%i\n", +- __func__, status.error_code); ++ dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); + retval = -EPIPE; + break; + } +@@ -873,8 +857,8 @@ static int ni_usb_command_chunk(gpib_board_t *board, uint8_t *buffer, size_t len + kfree(out_data); + if (retval || bytes_written != i) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + +@@ -890,8 +874,8 @@ static int ni_usb_command_chunk(gpib_board_t *board, uint8_t *buffer, size_t len + mutex_unlock(&ni_priv->addressed_transfer_lock); + + if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return retval; + } +@@ -909,12 +893,12 @@ static int ni_usb_command_chunk(gpib_board_t *board, uint8_t *buffer, size_t len + case NIUSB_NO_BUS_ERROR: + return -ENOTCONN; + case NIUSB_EOSMODE_ERROR: +- dev_err(&usb_dev->dev, "%s: got eosmode error. Driver bug?\n", __func__); ++ dev_err(&usb_dev->dev, "got eosmode error. Driver bug?\n"); + return -EIO; + case NIUSB_TIMEOUT_ERROR: + return -ETIMEDOUT; + default: +- dev_err(&usb_dev->dev, "%s: unknown error code=%i\n", __func__, status.error_code); ++ dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code); + return -EIO; + } + ni_usb_soft_update_status(board, status.ibsta, 0); +@@ -968,15 +952,14 @@ static int ni_usb_take_control(gpib_board_t *board, int synchronous) + kfree(out_data); + if (retval || bytes_written != i) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + + in_data = kmalloc(in_data_length, GFP_KERNEL); + if (!in_data) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); + return -ENOMEM; + } + retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 1); +@@ -986,8 +969,8 @@ static int ni_usb_take_control(gpib_board_t *board, int synchronous) + if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) { + if (retval == 0) + retval = -EIO; +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return retval; + } +@@ -1025,15 +1008,14 @@ static int ni_usb_go_to_standby(gpib_board_t *board) + kfree(out_data); + if (retval || bytes_written != i) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + + in_data = kmalloc(in_data_length, GFP_KERNEL); + if (!in_data) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); + return -ENOMEM; + } + retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); +@@ -1041,16 +1023,15 @@ static int ni_usb_go_to_standby(gpib_board_t *board) + mutex_unlock(&ni_priv->addressed_transfer_lock); + + if (retval || bytes_read != 12) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return retval; + } + ni_usb_parse_status_block(in_data, &status); + kfree(in_data); + if (status.id != NIUSB_IBGTS_ID) +- dev_err(&usb_dev->dev, "%s: bug: status.id 0x%x != INUSB_IBGTS_ID\n", +- __func__, status.id); ++ dev_err(&usb_dev->dev, "bug: status.id 0x%x != INUSB_IBGTS_ID\n", status.id); + ni_usb_soft_update_status(board, status.ibsta, 0); + return 0; + } +@@ -1093,7 +1074,7 @@ static void ni_usb_request_system_control(gpib_board_t *board, int request_contr + } + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return; // retval; + } + if (!request_control) +@@ -1119,10 +1100,8 @@ static void ni_usb_interface_clear(gpib_board_t *board, int assert) + if (assert == 0) + return; + out_data = kmalloc(out_data_length, GFP_KERNEL); +- if (!out_data) { +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); ++ if (!out_data) + return; +- } + out_data[i++] = NIUSB_IBSIC_ID; + out_data[i++] = 0x0; + out_data[i++] = 0x0; +@@ -1131,8 +1110,8 @@ static void ni_usb_interface_clear(gpib_board_t *board, int assert) + retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000); + kfree(out_data); + if (retval || bytes_written != i) { +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return; + } + in_data = kmalloc(in_data_length, GFP_KERNEL); +@@ -1141,8 +1120,8 @@ static void ni_usb_interface_clear(gpib_board_t *board, int assert) + + retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); + if (retval || bytes_read != 12) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return; + } +@@ -1167,7 +1146,7 @@ static void ni_usb_remote_enable(gpib_board_t *board, int enable) + reg.value = AUX_CREN; + retval = ni_usb_write_registers(ni_priv, ®, 1, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return; //retval; + } + ni_priv->ren_state = enable; +@@ -1207,7 +1186,6 @@ static unsigned int ni_usb_update_status(gpib_board_t *board, unsigned int clear + u8 *buffer; + struct ni_usb_status_block status; + +- //printk("%s: receive control pipe is %i\n", __func__, pipe); + buffer = kmalloc(buffer_length, GFP_KERNEL); + if (!buffer) + return board->status; +@@ -1216,7 +1194,7 @@ static unsigned int ni_usb_update_status(gpib_board_t *board, unsigned int clear + USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x200, 0x0, buffer, buffer_length, 1000); + if (retval != buffer_length) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg returned %i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); + kfree(buffer); + return board->status; + } +@@ -1235,7 +1213,6 @@ static void ni_usb_stop(struct ni_usb_priv *ni_priv) + u8 *buffer; + struct ni_usb_status_block status; + +- //printk("%s: receive control pipe is %i\n", __func__, pipe); + buffer = kmalloc(buffer_length, GFP_KERNEL); + if (!buffer) + return; +@@ -1244,7 +1221,7 @@ static void ni_usb_stop(struct ni_usb_priv *ni_priv) + USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x0, 0x0, buffer, buffer_length, 1000); + if (retval != buffer_length) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg returned %i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); + kfree(buffer); + return; + } +@@ -1271,7 +1248,7 @@ static int ni_usb_primary_address(gpib_board_t *board, unsigned int address) + i++; + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1319,7 +1296,7 @@ static int ni_usb_secondary_address(gpib_board_t *board, unsigned int address, i + i += ni_usb_write_sad(writes, address, enable); + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1353,8 +1330,8 @@ static int ni_usb_parallel_poll(gpib_board_t *board, uint8_t *result) + + kfree(out_data); + if (retval || bytes_written != i) { +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + in_data = kmalloc(in_data_length, GFP_KERNEL); +@@ -1366,8 +1343,8 @@ static int ni_usb_parallel_poll(gpib_board_t *board, uint8_t *result) + &bytes_read, 1000, 1); + + if (retval && retval != -ERESTARTSYS) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return retval; + } +@@ -1393,7 +1370,7 @@ static void ni_usb_parallel_poll_configure(gpib_board_t *board, uint8_t config) + i++; + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return;// retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1418,7 +1395,7 @@ static void ni_usb_parallel_poll_response(gpib_board_t *board, int ist) + i++; + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return;// retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1440,7 +1417,7 @@ static void ni_usb_serial_poll_response(gpib_board_t *board, u8 status) + i++; + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return;// retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1467,7 +1444,7 @@ static void ni_usb_return_to_local(gpib_board_t *board) + i++; + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return;// retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1509,15 +1486,14 @@ static int ni_usb_line_status(const gpib_board_t *board) + if (retval || bytes_written != i) { + mutex_unlock(&ni_priv->addressed_transfer_lock); + if (retval != -EAGAIN) +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%i\n", +- __func__, retval, bytes_written, i); ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n", ++ retval, bytes_written, i); + return retval; + } + + in_data = kmalloc(in_data_length, GFP_KERNEL); + if (!in_data) { + mutex_unlock(&ni_priv->addressed_transfer_lock); +- dev_err(&usb_dev->dev, "%s: kmalloc failed\n", __func__); + return -ENOMEM; + } + retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, in_data, in_data_length, +@@ -1527,8 +1503,8 @@ static int ni_usb_line_status(const gpib_board_t *board) + + if (retval) { + if (retval != -EAGAIN) +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + kfree(in_data); + return retval; + } +@@ -1604,7 +1580,7 @@ static unsigned int ni_usb_t1_delay(gpib_board_t *board, unsigned int nano_sec) + i = ni_usb_setup_t1_delay(writes, nano_sec, &actual_ns); + retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return -1; //FIXME should change return type to int for error reporting + } + board->t1_nano_sec = actual_ns; +@@ -1736,7 +1712,7 @@ static int ni_usb_setup_init(gpib_board_t *board, struct ni_usb_register *writes + writes[i].value = AUX_CPPF; + i++; + if (i > NUM_INIT_WRITES) { +- dev_err(&usb_dev->dev, "%s: bug!, buffer overrun, i=%i\n", __func__, i); ++ dev_err(&usb_dev->dev, "bug!, buffer overrun, i=%i\n", i); + return 0; + } + return i; +@@ -1762,7 +1738,7 @@ static int ni_usb_init(gpib_board_t *board) + return -EFAULT; + kfree(writes); + if (retval) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return retval; + } + ni_usb_soft_update_status(board, ibsta, 0); +@@ -1778,9 +1754,6 @@ static void ni_usb_interrupt_complete(struct urb *urb) + struct ni_usb_status_block status; + unsigned long flags; + +-// printk("debug: %s: status=0x%x, error_count=%i, actual_length=%i\n", __func__, +-// urb->status, urb->error_count, urb->actual_length); +- + switch (urb->status) { + /* success */ + case 0: +@@ -1793,23 +1766,21 @@ static void ni_usb_interrupt_complete(struct urb *urb) + default: /* other error, resubmit */ + retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC); + if (retval) +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb\n", __func__); ++ dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); + return; + } + + ni_usb_parse_status_block(urb->transfer_buffer, &status); +-// printk("debug: ibsta=0x%x\n", status.ibsta); + + spin_lock_irqsave(&board->spinlock, flags); + ni_priv->monitored_ibsta_bits &= ~status.ibsta; +-// printk("debug: monitored_ibsta_bits=0x%x\n", ni_priv->monitored_ibsta_bits); + spin_unlock_irqrestore(&board->spinlock, flags); + + wake_up_interruptible(&board->wait); + + retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC); + if (retval) +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb\n", __func__); ++ dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n"); + } + + static int ni_usb_set_interrupt_monitor(gpib_board_t *board, unsigned int monitored_bits) +@@ -1821,22 +1792,20 @@ static int ni_usb_set_interrupt_monitor(gpib_board_t *board, unsigned int monito + u8 *buffer; + struct ni_usb_status_block status; + unsigned long flags; +- //printk("%s: receive control pipe is %i\n", __func__, pipe); ++ + buffer = kmalloc(buffer_length, GFP_KERNEL); + if (!buffer) + return -ENOMEM; + + spin_lock_irqsave(&board->spinlock, flags); + ni_priv->monitored_ibsta_bits = ni_usb_ibsta_monitor_mask & monitored_bits; +-// dev_err(&usb_dev->dev, "debug: %s: monitored_ibsta_bits=0x%x\n", +-// __func__, ni_priv->monitored_ibsta_bits); + spin_unlock_irqrestore(&board->spinlock, flags); + retval = ni_usb_receive_control_msg(ni_priv, NI_USB_WAIT_REQUEST, USB_DIR_IN | + USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x300, ni_usb_ibsta_monitor_mask & monitored_bits, + buffer, buffer_length, 1000); + if (retval != buffer_length) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg returned %i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval); + kfree(buffer); + return -1; + } +@@ -1872,8 +1841,7 @@ static int ni_usb_setup_urbs(gpib_board_t *board) + retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL); + mutex_unlock(&ni_priv->interrupt_transfer_lock); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to submit first interrupt urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval); + return retval; + } + return 0; +@@ -1904,7 +1872,6 @@ static int ni_usb_b_read_serial_number(struct ni_usb_priv *ni_priv) + int j; + unsigned int serial_number; + +-// printk("%s: %s\n", __func__); + in_data = kmalloc(in_data_length, GFP_KERNEL); + if (!in_data) + return -ENOMEM; +@@ -1924,20 +1891,19 @@ static int ni_usb_b_read_serial_number(struct ni_usb_priv *ni_priv) + i += ni_usb_bulk_termination(&out_data[i]); + retval = ni_usb_send_bulk_msg(ni_priv, out_data, out_data_length, &bytes_written, 1000); + if (retval) { +- dev_err(&usb_dev->dev, "%s: ni_usb_send_bulk_msg returned %i, bytes_written=%i, i=%li\n", +- __func__, ++ dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%li\n", + retval, bytes_written, (long)out_data_length); + goto serial_out; + } + retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0); + if (retval) { +- dev_err(&usb_dev->dev, "%s: ni_usb_receive_bulk_msg returned %i, bytes_read=%i\n", +- __func__, retval, bytes_read); ++ dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n", ++ retval, bytes_read); + ni_usb_dump_raw_block(in_data, bytes_read); + goto serial_out; + } + if (ARRAY_SIZE(results) < num_reads) { +- dev_err(&usb_dev->dev, "Setup bug\n"); ++ dev_err(&usb_dev->dev, "serial number eetup bug\n"); + retval = -EINVAL; + goto serial_out; + } +@@ -1945,7 +1911,7 @@ static int ni_usb_b_read_serial_number(struct ni_usb_priv *ni_priv) + serial_number = 0; + for (j = 0; j < num_reads; ++j) + serial_number |= (results[j] & 0xff) << (8 * j); +- dev_info(&usb_dev->dev, "%s: board serial number is 0x%x\n", __func__, serial_number); ++ dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number); + retval = 0; + serial_out: + kfree(in_data); +@@ -1973,22 +1939,22 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x0, 0x0, buffer, buffer_size, 1000); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg request 0x%x returned %i\n", +- __func__, NI_USB_SERIAL_NUMBER_REQUEST, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", ++ NI_USB_SERIAL_NUMBER_REQUEST, retval); + goto ready_out; + } + j = 0; + if (buffer[j] != NI_USB_SERIAL_NUMBER_REQUEST) { +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x%x\n", +- __func__, j, (int)buffer[j], NI_USB_SERIAL_NUMBER_REQUEST); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", ++ j, (int)buffer[j], NI_USB_SERIAL_NUMBER_REQUEST); + unexpected = 1; + } + if (unexpected) + ni_usb_dump_raw_block(buffer, retval); + // NI-USB-HS+ pads the serial with 0x0 to make 16 bytes + if (retval != 5 && retval != 16) { +- dev_err(&usb_dev->dev, "%s: received unexpected number of bytes = %i, expected 5 or 16\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "received unexpected number of bytes = %i, expected 5 or 16\n", ++ retval); + ni_usb_dump_raw_block(buffer, retval); + } + serial_number = 0; +@@ -1996,7 +1962,7 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + serial_number |= (buffer[++j] << 8); + serial_number |= (buffer[++j] << 16); + serial_number |= (buffer[++j] << 24); +- dev_info(&usb_dev->dev, "%s: board serial number is 0x%x\n", __func__, serial_number); ++ dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number); + for (i = 0; i < timeout; ++i) { + int ready = 0; + +@@ -2004,26 +1970,26 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x0, 0x0, buffer, buffer_size, 100); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg request 0x%x returned %i\n", +- __func__, NI_USB_POLL_READY_REQUEST, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", ++ NI_USB_POLL_READY_REQUEST, retval); + goto ready_out; + } + j = 0; + unexpected = 0; + if (buffer[j] != NI_USB_POLL_READY_REQUEST) { // [0] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x%x\n", +- __func__, j, (int)buffer[j], NI_USB_POLL_READY_REQUEST); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", ++ j, (int)buffer[j], NI_USB_POLL_READY_REQUEST); + unexpected = 1; + } + ++j; + if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [1] HS+ sends 0x0 +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + if (buffer[++j] != 0x0) { // [2] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x%x\n", +- __func__, j, (int)buffer[j], 0x0); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n", ++ j, (int)buffer[j], 0x0); + unexpected = 1; + } + ++j; +@@ -2031,22 +1997,22 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + // NI-USB-HS+ sends 0x0 + if (buffer[j] != 0x1 && buffer[j] != 0x8 && buffer[j] != 0x7 && buffer[j] != 0x0) { + // [3] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x0, 0x1, 0x7 or 0x8\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x1, 0x7 or 0x8\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + ++j; + // NI-USB-HS+ sends 0 here + if (buffer[j] != 0x30 && buffer[j] != 0x0) { // [4] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x30\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x30\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + ++j; + // MC usb-488 (and sometimes NI-USB-HS?) and NI-USB-HS+ sends 0x0 here + if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [5] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + if (buffer[++j] != 0x0) { // [6] +@@ -2054,8 +2020,8 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + // NI-USB-HS+ sends 0xf here + if (buffer[j] != 0x2 && buffer[j] != 0xe && buffer[j] != 0xf && + buffer[j] != 0x16) { +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf or 0x16\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf or 0x16\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + } +@@ -2064,30 +2030,30 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + // MC usb-488 sends 0x5 here; MC usb-488A sends 0x6 here + if (buffer[j] != 0x3 && buffer[j] != 0x5 && buffer[j] != 0x6 && + buffer[j] != 0x8) { +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x3 or 0x5, 0x6 or 0x08\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x3 or 0x5, 0x6 or 0x08\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + } + ++j; + if (buffer[j] != 0x0 && buffer[j] != 0x2) { // [8] MC usb-488 sends 0x2 here +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x2\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, " unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x2\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + ++j; + // MC usb-488A and NI-USB-HS sends 0x3 here; NI-USB-HS+ sends 0x30 here + if (buffer[j] != 0x0 && buffer[j] != 0x3 && buffer[j] != 0x30) { // [9] +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x0, 0x3 or 0x30\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x3 or 0x30\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + if (buffer[++j] != 0x0) { + ready = 1; + if (buffer[j] != 0x96 && buffer[j] != 0x7 && buffer[j] != 0x6e) { + // [10] MC usb-488 sends 0x7 here +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07 or 0x6e\n", +- __func__, j, (int)buffer[j]); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07 or 0x6e\n", ++ j, (int)buffer[j]); + unexpected = 1; + } + } +@@ -2097,7 +2063,6 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + break; + retval = msleep_interruptible(msec_sleep_duration); + if (retval) { +- dev_err(&usb_dev->dev, "ni_usb_gpib: msleep interrupted\n"); + retval = -ERESTARTSYS; + goto ready_out; + } +@@ -2106,7 +2071,7 @@ static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv) + + ready_out: + kfree(buffer); +- dev_dbg(&usb_dev->dev, "%s: exit retval=%d\n", __func__, retval); ++ dev_dbg(&usb_dev->dev, "exit retval=%d\n", retval); + return retval; + } + +@@ -2134,14 +2099,14 @@ static int ni_usb_hs_plus_extra_init(struct ni_usb_priv *ni_priv) + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x0, 0x0, buffer, transfer_size, 1000); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg request 0x%x returned %i\n", +- __func__, NI_USB_HS_PLUS_0x48_REQUEST, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", ++ NI_USB_HS_PLUS_0x48_REQUEST, retval); + break; + } + // expected response data: 48 f3 30 00 00 00 00 00 00 00 00 00 00 00 00 00 + if (buffer[0] != NI_USB_HS_PLUS_0x48_REQUEST) +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[0]=0x%x, expected 0x%x\n", +- __func__, (int)buffer[0], NI_USB_HS_PLUS_0x48_REQUEST); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", ++ (int)buffer[0], NI_USB_HS_PLUS_0x48_REQUEST); + + transfer_size = 2; + +@@ -2149,14 +2114,14 @@ static int ni_usb_hs_plus_extra_init(struct ni_usb_priv *ni_priv) + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0x1, 0x0, buffer, transfer_size, 1000); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg request 0x%x returned %i\n", +- __func__, NI_USB_HS_PLUS_LED_REQUEST, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", ++ NI_USB_HS_PLUS_LED_REQUEST, retval); + break; + } + // expected response data: 4b 00 + if (buffer[0] != NI_USB_HS_PLUS_LED_REQUEST) +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[0]=0x%x, expected 0x%x\n", +- __func__, (int)buffer[0], NI_USB_HS_PLUS_LED_REQUEST); ++ dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", ++ (int)buffer[0], NI_USB_HS_PLUS_LED_REQUEST); + + transfer_size = 9; + +@@ -2165,15 +2130,14 @@ static int ni_usb_hs_plus_extra_init(struct ni_usb_priv *ni_priv) + USB_RECIP_INTERFACE, + 0x0, 0x1, buffer, transfer_size, 1000); + if (retval < 0) { +- dev_err(&usb_dev->dev, "%s: usb_control_msg request 0x%x returned %i\n", +- __func__, NI_USB_HS_PLUS_0xf8_REQUEST, retval); ++ dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n", ++ NI_USB_HS_PLUS_0xf8_REQUEST, retval); + break; + } + // expected response data: f8 01 00 00 00 01 00 00 00 + if (buffer[0] != NI_USB_HS_PLUS_0xf8_REQUEST) +- dev_err(&usb_dev->dev, "%s: unexpected data: buffer[0]=0x%x, expected 0x%x\n", +- __func__, (int)buffer[0], NI_USB_HS_PLUS_0xf8_REQUEST); +- ++ dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n", ++ (int)buffer[0], NI_USB_HS_PLUS_0xf8_REQUEST); + } while (0); + + // cleanup +@@ -2192,7 +2156,7 @@ static inline int ni_usb_device_match(struct usb_interface *interface, + static int ni_usb_attach(gpib_board_t *board, const gpib_board_config_t *config) + { + int retval; +- int i; ++ int i, index; + struct ni_usb_priv *ni_priv; + int product_id; + struct usb_device *usb_dev; +@@ -2211,19 +2175,17 @@ static int ni_usb_attach(gpib_board_t *board, const gpib_board_config_t *config) + ni_priv->bus_interface = ni_usb_driver_interfaces[i]; + usb_set_intfdata(ni_usb_driver_interfaces[i], board); + usb_dev = interface_to_usbdev(ni_priv->bus_interface); +- dev_info(&usb_dev->dev, +- "bus %d dev num %d attached to gpib minor %d, NI usb interface %i\n", +- usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); ++ index = i; + break; + } + } + if (i == MAX_NUM_NI_USB_INTERFACES) { + mutex_unlock(&ni_usb_hotplug_lock); +- pr_err("No supported NI usb gpib adapters found, have you loaded its firmware?\n"); ++ dev_err(board->gpib_dev, "No supported adapters found, have you loaded its firmware?\n"); + return -ENODEV; + } + if (usb_reset_configuration(interface_to_usbdev(ni_priv->bus_interface))) +- dev_err(&usb_dev->dev, "ni_usb_gpib: usb_reset_configuration() failed.\n"); ++ dev_err(&usb_dev->dev, "usb_reset_configuration() failed.\n"); + + product_id = le16_to_cpu(usb_dev->descriptor.idProduct); + ni_priv->product_id = product_id; +@@ -2296,7 +2258,9 @@ static int ni_usb_attach(gpib_board_t *board, const gpib_board_config_t *config) + } + + mutex_unlock(&ni_usb_hotplug_lock); +- dev_info(&usb_dev->dev, "%s: attached\n", __func__); ++ dev_info(&usb_dev->dev, ++ "bus %d dev num %d attached to gpib%d, intf %i\n", ++ usb_dev->bus->busnum, usb_dev->devnum, board->minor, index); + return retval; + } + +@@ -2304,27 +2268,19 @@ static int ni_usb_shutdown_hardware(struct ni_usb_priv *ni_priv) + { + struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface); + int retval; +- int i = 0; + struct ni_usb_register writes[2]; + static const int writes_length = ARRAY_SIZE(writes); + unsigned int ibsta; + +-// printk("%s: %s\n", __func__); +- writes[i].device = NIUSB_SUBDEV_TNT4882; +- writes[i].address = nec7210_to_tnt4882_offset(AUXMR); +- writes[i].value = AUX_CR; +- i++; +- writes[i].device = NIUSB_SUBDEV_UNKNOWN3; +- writes[i].address = 0x10; +- writes[i].value = 0x0; +- i++; +- if (i > writes_length) { +- dev_err(&usb_dev->dev, "%s: bug!, buffer overrun, i=%i\n", __func__, i); +- return -EINVAL; +- } +- retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta); ++ writes[0].device = NIUSB_SUBDEV_TNT4882; ++ writes[0].address = nec7210_to_tnt4882_offset(AUXMR); ++ writes[0].value = AUX_CR; ++ writes[1].device = NIUSB_SUBDEV_UNKNOWN3; ++ writes[1].address = 0x10; ++ writes[1].value = 0x0; ++ retval = ni_usb_write_registers(ni_priv, writes, writes_length, &ibsta); + if (retval) { +- dev_err(&usb_dev->dev, "%s: register write failed, retval=%i\n", __func__, retval); ++ dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval); + return retval; + } + return 0; +@@ -2413,7 +2369,7 @@ static int ni_usb_driver_probe(struct usb_interface *interface, const struct usb + if (i == MAX_NUM_NI_USB_INTERFACES) { + usb_put_dev(usb_dev); + mutex_unlock(&ni_usb_hotplug_lock); +- dev_err(&usb_dev->dev, "%s: ni_usb_driver_interfaces[] full\n", __func__); ++ dev_err(&usb_dev->dev, "ni_usb_driver_interfaces[] full\n"); + return -1; + } + path = kmalloc(path_length, GFP_KERNEL); +@@ -2423,7 +2379,7 @@ static int ni_usb_driver_probe(struct usb_interface *interface, const struct usb + return -ENOMEM; + } + usb_make_path(usb_dev, path, path_length); +- dev_info(&usb_dev->dev, "ni_usb_gpib: probe succeeded for path: %s\n", path); ++ dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path); + kfree(path); + mutex_unlock(&ni_usb_hotplug_lock); + return 0; +@@ -2458,8 +2414,7 @@ static void ni_usb_driver_disconnect(struct usb_interface *interface) + } + } + if (i == MAX_NUM_NI_USB_INTERFACES) +- dev_err(&usb_dev->dev, "%s: unable to find interface in ni_usb_driver_interfaces[]? bug?\n", +- __func__); ++ dev_err(&usb_dev->dev, "unable to find interface bug?\n"); + usb_put_dev(usb_dev); + mutex_unlock(&ni_usb_hotplug_lock); + } +@@ -2498,9 +2453,9 @@ static int ni_usb_driver_suspend(struct usb_interface *interface, pm_message_t m + ni_usb_cleanup_urbs(ni_priv); + mutex_unlock(&ni_priv->interrupt_transfer_lock); + } +- dev_info(&usb_dev->dev, +- "bus %d dev num %d gpib minor %d, ni usb interface %i suspended\n", +- usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); ++ dev_dbg(&usb_dev->dev, ++ "bus %d dev num %d gpib%d, interface %i suspended\n", ++ usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); + } + + mutex_unlock(&ni_usb_hotplug_lock); +@@ -2535,15 +2490,15 @@ static int ni_usb_driver_resume(struct usb_interface *interface) + mutex_lock(&ni_priv->interrupt_transfer_lock); + retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL); + if (retval) { +- dev_err(&usb_dev->dev, "%s: failed to resubmit interrupt urb, retval=%i\n", +- __func__, retval); ++ dev_err(&usb_dev->dev, "resume failed to resubmit interrupt urb, retval=%i\n", ++ retval); + mutex_unlock(&ni_priv->interrupt_transfer_lock); + mutex_unlock(&ni_usb_hotplug_lock); + return retval; + } + mutex_unlock(&ni_priv->interrupt_transfer_lock); + } else { +- dev_err(&usb_dev->dev, "%s: bug! int urb not set up\n", __func__); ++ dev_err(&usb_dev->dev, "bug! resume int urb not set up\n"); + mutex_unlock(&ni_usb_hotplug_lock); + return -EINVAL; + } +@@ -2600,9 +2555,9 @@ static int ni_usb_driver_resume(struct usb_interface *interface) + if (ni_priv->ren_state) + ni_usb_remote_enable(board, 1); + +- dev_info(&usb_dev->dev, +- "bus %d dev num %d gpib minor %d, ni usb interface %i resumed\n", +- usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); ++ dev_dbg(&usb_dev->dev, ++ "bus %d dev num %d gpib%d, interface %i resumed\n", ++ usb_dev->bus->busnum, usb_dev->devnum, board->minor, i); + } + + mutex_unlock(&ni_usb_hotplug_lock); +@@ -2610,7 +2565,7 @@ static int ni_usb_driver_resume(struct usb_interface *interface) + } + + static struct usb_driver ni_usb_bus_driver = { +- .name = "ni_usb_gpib", ++ .name = DRV_NAME, + .probe = ni_usb_driver_probe, + .disconnect = ni_usb_driver_disconnect, + .suspend = ni_usb_driver_suspend, +@@ -2623,19 +2578,18 @@ static int __init ni_usb_init_module(void) + int i; + int ret; + +- pr_info("ni_usb_gpib driver loading\n"); + for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) + ni_usb_driver_interfaces[i] = NULL; + + ret = usb_register(&ni_usb_bus_driver); + if (ret) { +- pr_err("ni_usb_gpib: usb_register failed: error = %d\n", ret); ++ pr_err("usb_register failed: error = %d\n", ret); + return ret; + } + + ret = gpib_register_driver(&ni_usb_gpib_interface, THIS_MODULE); + if (ret) { +- pr_err("ni_usb_gpib: gpib_register_driver failed: error = %d\n", ret); ++ pr_err("gpib_register_driver failed: error = %d\n", ret); + return ret; + } + +@@ -2644,7 +2598,6 @@ static int __init ni_usb_init_module(void) + + static void __exit ni_usb_exit_module(void) + { +- pr_info("ni_usb_gpib driver unloading\n"); + gpib_unregister_driver(&ni_usb_gpib_interface); + usb_deregister(&ni_usb_bus_driver); + } +-- +2.39.5 + diff --git a/queue-6.14/tools-power-turbostat-allow-zero-return-value-for-so.patch b/queue-6.14/tools-power-turbostat-allow-zero-return-value-for-so.patch new file mode 100644 index 0000000000..45f041ea10 --- /dev/null +++ b/queue-6.14/tools-power-turbostat-allow-zero-return-value-for-so.patch @@ -0,0 +1,108 @@ +From 41c7ba625a3f86f8f3d8b30024381ca0fe115aa0 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sat, 8 Feb 2025 10:44:26 +0800 +Subject: tools/power turbostat: Allow Zero return value for some RAPL + registers + +From: Zhang Rui + +[ Upstream commit b312d880fb462d4759396950865ec914de9d253c ] + +turbostat aborted with below messages on a dual-package system, + + turbostat: turbostat.c:3744: rapl_counter_accumulate: Assertion `dst->unit == src->unit' failed. + Aborted + +This is because +1. the MSR_DRAM_PERF_STATUS returns Zero for one package, and non-Zero + for another package +2. probe_msr() treats Zero return value as a failure so this feature is + enabled on one package, and disabled for another package. +3. turbostat aborts because the feature is invalid on some package + +Unlike the RAPL energy counter registers, MSR_DRAM_PERF_STATUS can +return Zero value, and this should not be treated as a failure. + +Fix the problem by allowing Zero return value for RAPL registers other +than the energy counters. + +Fixes: 7c6fee25bdf5 ("tools/power turbostat: Check for non-zero value when MSR probing") +Reported-by: Artem Bityutskiy +Signed-off-by: Zhang Rui +Signed-off-by: Len Brown +Signed-off-by: Sasha Levin +--- + tools/power/x86/turbostat/turbostat.c | 27 ++++++++++++++++++--------- + 1 file changed, 18 insertions(+), 9 deletions(-) + +diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c +index 8d5011a0bf60d..ff238798b7747 100644 +--- a/tools/power/x86/turbostat/turbostat.c ++++ b/tools/power/x86/turbostat/turbostat.c +@@ -2211,7 +2211,7 @@ int get_msr(int cpu, off_t offset, unsigned long long *msr) + return 0; + } + +-int probe_msr(int cpu, off_t offset) ++int probe_rapl_msr(int cpu, off_t offset, int index) + { + ssize_t retval; + unsigned long long value; +@@ -2220,13 +2220,22 @@ int probe_msr(int cpu, off_t offset) + + retval = pread(get_msr_fd(cpu), &value, sizeof(value), offset); + +- /* +- * Expect MSRs to accumulate some non-zero value since the system was powered on. +- * Treat zero as a read failure. +- */ +- if (retval != sizeof(value) || value == 0) ++ /* if the read failed, the probe fails */ ++ if (retval != sizeof(value)) + return 1; + ++ /* If an Energy Status Counter MSR returns 0, the probe fails */ ++ switch (index) { ++ case RAPL_RCI_INDEX_ENERGY_PKG: ++ case RAPL_RCI_INDEX_ENERGY_CORES: ++ case RAPL_RCI_INDEX_DRAM: ++ case RAPL_RCI_INDEX_GFX: ++ case RAPL_RCI_INDEX_ENERGY_PLATFORM: ++ if (value == 0) ++ return 1; ++ } ++ ++ /* PKG,DRAM_PERF_STATUS MSRs, can return any value */ + return 0; + } + +@@ -7896,7 +7905,7 @@ void rapl_perf_init(void) + rci->flags[cai->rci_index] = cai->flags; + + /* Use MSR for this counter */ +- } else if (!no_msr && cai->msr && probe_msr(cpu, cai->msr) == 0) { ++ } else if (!no_msr && cai->msr && probe_rapl_msr(cpu, cai->msr, cai->rci_index) == 0) { + rci->source[cai->rci_index] = COUNTER_SOURCE_MSR; + rci->msr[cai->rci_index] = cai->msr; + rci->msr_mask[cai->rci_index] = cai->msr_mask; +@@ -8034,7 +8043,7 @@ void msr_perf_init_(void) + cai->present = true; + + /* User MSR for this counter */ +- } else if (!no_msr && cai->msr && probe_msr(cpu, cai->msr) == 0) { ++ } else if (!no_msr && cai->msr && probe_rapl_msr(cpu, cai->msr, cai->rci_index) == 0) { + cci->source[cai->rci_index] = COUNTER_SOURCE_MSR; + cci->msr[cai->rci_index] = cai->msr; + cci->msr_mask[cai->rci_index] = cai->msr_mask; +@@ -8148,7 +8157,7 @@ void cstate_perf_init_(bool soft_c1) + + /* User MSR for this counter */ + } else if (!no_msr && cai->msr && pkg_cstate_limit >= cai->pkg_cstate_limit +- && probe_msr(cpu, cai->msr) == 0) { ++ && probe_rapl_msr(cpu, cai->msr, cai->rci_index) == 0) { + cci->source[cai->rci_index] = COUNTER_SOURCE_MSR; + cci->msr[cai->rci_index] = cai->msr; + } +-- +2.39.5 + diff --git a/queue-6.14/tools-power-turbostat-report-corethr-per-measurement.patch b/queue-6.14/tools-power-turbostat-report-corethr-per-measurement.patch new file mode 100644 index 0000000000..77c0b1725a --- /dev/null +++ b/queue-6.14/tools-power-turbostat-report-corethr-per-measurement.patch @@ -0,0 +1,59 @@ +From 07a8cc59f033c84dae138152cd8a9a20075ac859 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 6 Apr 2025 11:18:39 -0400 +Subject: tools/power turbostat: report CoreThr per measurement interval + +From: Len Brown + +[ Upstream commit f729775f79a9c942c6c82ed6b44bd030afe10423 ] + +The CoreThr column displays total thermal throttling events +since boot time. + +Change it to report events during the measurement interval. + +This is more useful for showing a user the current conditions. +Total events since boot time are still available to the user via +/sys/devices/system/cpu/cpu*/thermal_throttle/* + +Document CoreThr on turbostat.8 + +Fixes: eae97e053fe30 ("turbostat: Support thermal throttle count print") +Reported-by: Arjan van de Ven +Signed-off-by: Len Brown +Cc: Chen Yu +Signed-off-by: Sasha Levin +--- + tools/power/x86/turbostat/turbostat.8 | 2 ++ + tools/power/x86/turbostat/turbostat.c | 2 +- + 2 files changed, 3 insertions(+), 1 deletion(-) + +diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8 +index 99bf905ade812..e4f9f93c123a2 100644 +--- a/tools/power/x86/turbostat/turbostat.8 ++++ b/tools/power/x86/turbostat/turbostat.8 +@@ -168,6 +168,8 @@ The system configuration dump (if --quiet is not used) is followed by statistics + .PP + \fBPkgTmp\fP Degrees Celsius reported by the per-package Package Thermal Monitor. + .PP ++\fBCoreThr\fP Core Thermal Throttling events during the measurement interval. Note that events since boot can be find in /sys/devices/system/cpu/cpu*/thermal_throttle/* ++.PP + \fBGFX%rc6\fP The percentage of time the GPU is in the "render C6" state, rc6, during the measurement interval. From /sys/class/drm/card0/power/rc6_residency_ms or /sys/class/drm/card0/gt/gt0/rc6_residency_ms or /sys/class/drm/card0/device/tile0/gtN/gtidle/idle_residency_ms depending on the graphics driver being used. + .PP + \fBGFXMHz\fP Instantaneous snapshot of what sysfs presents at the end of the measurement interval. From /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz or /sys/class/drm/card0/gt_cur_freq_mhz or /sys/class/drm/card0/gt/gt0/rps_cur_freq_mhz or /sys/class/drm/card0/device/tile0/gtN/freq0/cur_freq depending on the graphics driver being used. +diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c +index ff238798b7747..5b36f1fd885c9 100644 +--- a/tools/power/x86/turbostat/turbostat.c ++++ b/tools/power/x86/turbostat/turbostat.c +@@ -3485,7 +3485,7 @@ void delta_core(struct core_data *new, struct core_data *old) + old->c6 = new->c6 - old->c6; + old->c7 = new->c7 - old->c7; + old->core_temp_c = new->core_temp_c; +- old->core_throt_cnt = new->core_throt_cnt; ++ old->core_throt_cnt = new->core_throt_cnt - old->core_throt_cnt; + old->mc6_us = new->mc6_us - old->mc6_us; + + DELTA_WRAP32(new->core_energy.raw_value, old->core_energy.raw_value); +-- +2.39.5 + diff --git a/queue-6.14/tools-power-turbostat-restore-gfx-sysfs-fflush-call.patch b/queue-6.14/tools-power-turbostat-restore-gfx-sysfs-fflush-call.patch new file mode 100644 index 0000000000..a70e126a77 --- /dev/null +++ b/queue-6.14/tools-power-turbostat-restore-gfx-sysfs-fflush-call.patch @@ -0,0 +1,35 @@ +From e2f44e07484094e489cc182f9881a5b041a34cb9 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 19 Mar 2025 08:53:07 +0800 +Subject: tools/power turbostat: Restore GFX sysfs fflush() call + +From: Zhang Rui + +[ Upstream commit f8b136ef2605c1bf62020462d10e35228760aa19 ] + +Do fflush() to discard the buffered data, before each read of the +graphics sysfs knobs. + +Fixes: ba99a4fc8c24 ("tools/power turbostat: Remove unnecessary fflush() call") +Signed-off-by: Zhang Rui +Signed-off-by: Len Brown +Signed-off-by: Sasha Levin +--- + tools/power/x86/turbostat/turbostat.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c +index 5b36f1fd885c9..4155d9bfcfc6d 100644 +--- a/tools/power/x86/turbostat/turbostat.c ++++ b/tools/power/x86/turbostat/turbostat.c +@@ -6039,6 +6039,7 @@ int snapshot_graphics(int idx) + int retval; + + rewind(gfx_info[idx].fp); ++ fflush(gfx_info[idx].fp); + + switch (idx) { + case GFX_rc6: +-- +2.39.5 + diff --git a/queue-6.14/tty-serial-fsl_lpuart-use-port-struct-directly-to-si.patch b/queue-6.14/tty-serial-fsl_lpuart-use-port-struct-directly-to-si.patch new file mode 100644 index 0000000000..ec8a01f124 --- /dev/null +++ b/queue-6.14/tty-serial-fsl_lpuart-use-port-struct-directly-to-si.patch @@ -0,0 +1,523 @@ +From 6373b01e018263f1f7f4c14b32163c12ec5dd4fd Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 12 Mar 2025 10:39:03 +0800 +Subject: tty: serial: fsl_lpuart: use port struct directly to simply code + +From: Sherry Sun + +[ Upstream commit 3cc16ae096f164ae0c6b98416c25a01db5f3a529 ] + +Most lpuart functions have the parameter struct uart_port *port, but +still use the &sport->port to get the uart_port instead of use it +directly, let's simply the code logic, directly use this struct instead +of covert it from struct sport. + +Signed-off-by: Sherry Sun +Link: https://lore.kernel.org/r/20250312023904.1343351-3-sherry.sun@nxp.com +Signed-off-by: Greg Kroah-Hartman +Stable-dep-of: e98ab45ec518 ("tty: serial: lpuart: only disable CTS instead of overwriting the whole UARTMODIR register") +Signed-off-by: Sasha Levin +--- + drivers/tty/serial/fsl_lpuart.c | 213 +++++++++++++++----------------- + 1 file changed, 102 insertions(+), 111 deletions(-) + +diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c +index 1be0bf3b2f50f..f26162d98db62 100644 +--- a/drivers/tty/serial/fsl_lpuart.c ++++ b/drivers/tty/serial/fsl_lpuart.c +@@ -581,7 +581,7 @@ static int lpuart_dma_tx_request(struct uart_port *port) + ret = dmaengine_slave_config(sport->dma_tx_chan, &dma_tx_sconfig); + + if (ret) { +- dev_err(sport->port.dev, ++ dev_err(port->dev, + "DMA slave config failed, err = %d\n", ret); + return ret; + } +@@ -611,13 +611,13 @@ static void lpuart_flush_buffer(struct uart_port *port) + } + + if (lpuart_is_32(sport)) { +- val = lpuart32_read(&sport->port, UARTFIFO); ++ val = lpuart32_read(port, UARTFIFO); + val |= UARTFIFO_TXFLUSH | UARTFIFO_RXFLUSH; +- lpuart32_write(&sport->port, val, UARTFIFO); ++ lpuart32_write(port, val, UARTFIFO); + } else { +- val = readb(sport->port.membase + UARTCFIFO); ++ val = readb(port->membase + UARTCFIFO); + val |= UARTCFIFO_TXFLUSH | UARTCFIFO_RXFLUSH; +- writeb(val, sport->port.membase + UARTCFIFO); ++ writeb(val, port->membase + UARTCFIFO); + } + } + +@@ -639,38 +639,36 @@ static void lpuart32_wait_bit_set(struct uart_port *port, unsigned int offset, + + static int lpuart_poll_init(struct uart_port *port) + { +- struct lpuart_port *sport = container_of(port, +- struct lpuart_port, port); + unsigned long flags; + u8 temp; + +- sport->port.fifosize = 0; ++ port->fifosize = 0; + +- uart_port_lock_irqsave(&sport->port, &flags); ++ uart_port_lock_irqsave(port, &flags); + /* Disable Rx & Tx */ +- writeb(0, sport->port.membase + UARTCR2); ++ writeb(0, port->membase + UARTCR2); + +- temp = readb(sport->port.membase + UARTPFIFO); ++ temp = readb(port->membase + UARTPFIFO); + /* Enable Rx and Tx FIFO */ + writeb(temp | UARTPFIFO_RXFE | UARTPFIFO_TXFE, +- sport->port.membase + UARTPFIFO); ++ port->membase + UARTPFIFO); + + /* flush Tx and Rx FIFO */ + writeb(UARTCFIFO_TXFLUSH | UARTCFIFO_RXFLUSH, +- sport->port.membase + UARTCFIFO); ++ port->membase + UARTCFIFO); + + /* explicitly clear RDRF */ +- if (readb(sport->port.membase + UARTSR1) & UARTSR1_RDRF) { +- readb(sport->port.membase + UARTDR); +- writeb(UARTSFIFO_RXUF, sport->port.membase + UARTSFIFO); ++ if (readb(port->membase + UARTSR1) & UARTSR1_RDRF) { ++ readb(port->membase + UARTDR); ++ writeb(UARTSFIFO_RXUF, port->membase + UARTSFIFO); + } + +- writeb(0, sport->port.membase + UARTTWFIFO); +- writeb(1, sport->port.membase + UARTRWFIFO); ++ writeb(0, port->membase + UARTTWFIFO); ++ writeb(1, port->membase + UARTRWFIFO); + + /* Enable Rx and Tx */ +- writeb(UARTCR2_RE | UARTCR2_TE, sport->port.membase + UARTCR2); +- uart_port_unlock_irqrestore(&sport->port, flags); ++ writeb(UARTCR2_RE | UARTCR2_TE, port->membase + UARTCR2); ++ uart_port_unlock_irqrestore(port, flags); + + return 0; + } +@@ -693,33 +691,32 @@ static int lpuart_poll_get_char(struct uart_port *port) + static int lpuart32_poll_init(struct uart_port *port) + { + unsigned long flags; +- struct lpuart_port *sport = container_of(port, struct lpuart_port, port); + u32 temp; + +- sport->port.fifosize = 0; ++ port->fifosize = 0; + +- uart_port_lock_irqsave(&sport->port, &flags); ++ uart_port_lock_irqsave(port, &flags); + + /* Disable Rx & Tx */ +- lpuart32_write(&sport->port, 0, UARTCTRL); ++ lpuart32_write(port, 0, UARTCTRL); + +- temp = lpuart32_read(&sport->port, UARTFIFO); ++ temp = lpuart32_read(port, UARTFIFO); + + /* Enable Rx and Tx FIFO */ +- lpuart32_write(&sport->port, temp | UARTFIFO_RXFE | UARTFIFO_TXFE, UARTFIFO); ++ lpuart32_write(port, temp | UARTFIFO_RXFE | UARTFIFO_TXFE, UARTFIFO); + + /* flush Tx and Rx FIFO */ +- lpuart32_write(&sport->port, UARTFIFO_TXFLUSH | UARTFIFO_RXFLUSH, UARTFIFO); ++ lpuart32_write(port, UARTFIFO_TXFLUSH | UARTFIFO_RXFLUSH, UARTFIFO); + + /* explicitly clear RDRF */ +- if (lpuart32_read(&sport->port, UARTSTAT) & UARTSTAT_RDRF) { +- lpuart32_read(&sport->port, UARTDATA); +- lpuart32_write(&sport->port, UARTFIFO_RXUF, UARTFIFO); ++ if (lpuart32_read(port, UARTSTAT) & UARTSTAT_RDRF) { ++ lpuart32_read(port, UARTDATA); ++ lpuart32_write(port, UARTFIFO_RXUF, UARTFIFO); + } + + /* Enable Rx and Tx */ +- lpuart32_write(&sport->port, UARTCTRL_RE | UARTCTRL_TE, UARTCTRL); +- uart_port_unlock_irqrestore(&sport->port, flags); ++ lpuart32_write(port, UARTCTRL_RE | UARTCTRL_TE, UARTCTRL); ++ uart_port_unlock_irqrestore(port, flags); + + return 0; + } +@@ -1449,12 +1446,9 @@ static void lpuart_dma_rx_free(struct uart_port *port) + static int lpuart_config_rs485(struct uart_port *port, struct ktermios *termios, + struct serial_rs485 *rs485) + { +- struct lpuart_port *sport = container_of(port, +- struct lpuart_port, port); +- +- u8 modem = readb(sport->port.membase + UARTMODEM) & ++ u8 modem = readb(port->membase + UARTMODEM) & + ~(UARTMODEM_TXRTSPOL | UARTMODEM_TXRTSE); +- writeb(modem, sport->port.membase + UARTMODEM); ++ writeb(modem, port->membase + UARTMODEM); + + if (rs485->flags & SER_RS485_ENABLED) { + /* Enable auto RS-485 RTS mode */ +@@ -1472,32 +1466,29 @@ static int lpuart_config_rs485(struct uart_port *port, struct ktermios *termios, + modem &= ~UARTMODEM_TXRTSPOL; + } + +- writeb(modem, sport->port.membase + UARTMODEM); ++ writeb(modem, port->membase + UARTMODEM); + return 0; + } + + static int lpuart32_config_rs485(struct uart_port *port, struct ktermios *termios, + struct serial_rs485 *rs485) + { +- struct lpuart_port *sport = container_of(port, +- struct lpuart_port, port); +- +- u32 modem = lpuart32_read(&sport->port, UARTMODIR) ++ u32 modem = lpuart32_read(port, UARTMODIR) + & ~(UARTMODIR_TXRTSPOL | UARTMODIR_TXRTSE); + u32 ctrl; + + /* TXRTSE and TXRTSPOL only can be changed when transmitter is disabled. */ +- ctrl = lpuart32_read(&sport->port, UARTCTRL); ++ ctrl = lpuart32_read(port, UARTCTRL); + if (ctrl & UARTCTRL_TE) { + /* wait for the transmit engine to complete */ +- lpuart32_wait_bit_set(&sport->port, UARTSTAT, UARTSTAT_TC); +- lpuart32_write(&sport->port, ctrl & ~UARTCTRL_TE, UARTCTRL); ++ lpuart32_wait_bit_set(port, UARTSTAT, UARTSTAT_TC); ++ lpuart32_write(port, ctrl & ~UARTCTRL_TE, UARTCTRL); + +- while (lpuart32_read(&sport->port, UARTCTRL) & UARTCTRL_TE) ++ while (lpuart32_read(port, UARTCTRL) & UARTCTRL_TE) + cpu_relax(); + } + +- lpuart32_write(&sport->port, modem, UARTMODIR); ++ lpuart32_write(port, modem, UARTMODIR); + + if (rs485->flags & SER_RS485_ENABLED) { + /* Enable auto RS-485 RTS mode */ +@@ -1515,10 +1506,10 @@ static int lpuart32_config_rs485(struct uart_port *port, struct ktermios *termio + modem &= ~UARTMODIR_TXRTSPOL; + } + +- lpuart32_write(&sport->port, modem, UARTMODIR); ++ lpuart32_write(port, modem, UARTMODIR); + + if (ctrl & UARTCTRL_TE) +- lpuart32_write(&sport->port, ctrl, UARTCTRL); ++ lpuart32_write(port, ctrl, UARTCTRL); + + return 0; + } +@@ -1829,11 +1820,11 @@ static int lpuart_startup(struct uart_port *port) + u8 temp; + + /* determine FIFO size and enable FIFO mode */ +- temp = readb(sport->port.membase + UARTPFIFO); ++ temp = readb(port->membase + UARTPFIFO); + + sport->txfifo_size = UARTFIFO_DEPTH((temp >> UARTPFIFO_TXSIZE_OFF) & + UARTPFIFO_FIFOSIZE_MASK); +- sport->port.fifosize = sport->txfifo_size; ++ port->fifosize = sport->txfifo_size; + + sport->rxfifo_size = UARTFIFO_DEPTH((temp >> UARTPFIFO_RXSIZE_OFF) & + UARTPFIFO_FIFOSIZE_MASK); +@@ -1889,11 +1880,11 @@ static int lpuart32_startup(struct uart_port *port) + u32 temp; + + /* determine FIFO size */ +- temp = lpuart32_read(&sport->port, UARTFIFO); ++ temp = lpuart32_read(port, UARTFIFO); + + sport->txfifo_size = UARTFIFO_DEPTH((temp >> UARTFIFO_TXSIZE_OFF) & + UARTFIFO_FIFOSIZE_MASK); +- sport->port.fifosize = sport->txfifo_size; ++ port->fifosize = sport->txfifo_size; + + sport->rxfifo_size = UARTFIFO_DEPTH((temp >> UARTFIFO_RXSIZE_OFF) & + UARTFIFO_FIFOSIZE_MASK); +@@ -1906,7 +1897,7 @@ static int lpuart32_startup(struct uart_port *port) + if (is_layerscape_lpuart(sport)) { + sport->rxfifo_size = 16; + sport->txfifo_size = 16; +- sport->port.fifosize = sport->txfifo_size; ++ port->fifosize = sport->txfifo_size; + } + + lpuart_request_dma(sport); +@@ -1966,8 +1957,8 @@ static void lpuart32_shutdown(struct uart_port *port) + uart_port_lock_irqsave(port, &flags); + + /* clear status */ +- temp = lpuart32_read(&sport->port, UARTSTAT); +- lpuart32_write(&sport->port, temp, UARTSTAT); ++ temp = lpuart32_read(port, UARTSTAT); ++ lpuart32_write(port, temp, UARTSTAT); + + /* disable Rx/Tx DMA */ + temp = lpuart32_read(port, UARTBAUD); +@@ -2001,12 +1992,12 @@ lpuart_set_termios(struct uart_port *port, struct ktermios *termios, + unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8; + unsigned int sbr, brfa; + +- cr1 = old_cr1 = readb(sport->port.membase + UARTCR1); +- old_cr2 = readb(sport->port.membase + UARTCR2); +- cr3 = readb(sport->port.membase + UARTCR3); +- cr4 = readb(sport->port.membase + UARTCR4); +- bdh = readb(sport->port.membase + UARTBDH); +- modem = readb(sport->port.membase + UARTMODEM); ++ cr1 = old_cr1 = readb(port->membase + UARTCR1); ++ old_cr2 = readb(port->membase + UARTCR2); ++ cr3 = readb(port->membase + UARTCR3); ++ cr4 = readb(port->membase + UARTCR4); ++ bdh = readb(port->membase + UARTBDH); ++ modem = readb(port->membase + UARTMODEM); + /* + * only support CS8 and CS7, and for CS7 must enable PE. + * supported mode: +@@ -2038,7 +2029,7 @@ lpuart_set_termios(struct uart_port *port, struct ktermios *termios, + * When auto RS-485 RTS mode is enabled, + * hardware flow control need to be disabled. + */ +- if (sport->port.rs485.flags & SER_RS485_ENABLED) ++ if (port->rs485.flags & SER_RS485_ENABLED) + termios->c_cflag &= ~CRTSCTS; + + if (termios->c_cflag & CRTSCTS) +@@ -2079,59 +2070,59 @@ lpuart_set_termios(struct uart_port *port, struct ktermios *termios, + * Need to update the Ring buffer length according to the selected + * baud rate and restart Rx DMA path. + * +- * Since timer function acqures sport->port.lock, need to stop before ++ * Since timer function acqures port->lock, need to stop before + * acquring same lock because otherwise del_timer_sync() can deadlock. + */ + if (old && sport->lpuart_dma_rx_use) +- lpuart_dma_rx_free(&sport->port); ++ lpuart_dma_rx_free(port); + +- uart_port_lock_irqsave(&sport->port, &flags); ++ uart_port_lock_irqsave(port, &flags); + +- sport->port.read_status_mask = 0; ++ port->read_status_mask = 0; + if (termios->c_iflag & INPCK) +- sport->port.read_status_mask |= UARTSR1_FE | UARTSR1_PE; ++ port->read_status_mask |= UARTSR1_FE | UARTSR1_PE; + if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK)) +- sport->port.read_status_mask |= UARTSR1_FE; ++ port->read_status_mask |= UARTSR1_FE; + + /* characters to ignore */ +- sport->port.ignore_status_mask = 0; ++ port->ignore_status_mask = 0; + if (termios->c_iflag & IGNPAR) +- sport->port.ignore_status_mask |= UARTSR1_PE; ++ port->ignore_status_mask |= UARTSR1_PE; + if (termios->c_iflag & IGNBRK) { +- sport->port.ignore_status_mask |= UARTSR1_FE; ++ port->ignore_status_mask |= UARTSR1_FE; + /* + * if we're ignoring parity and break indicators, + * ignore overruns too (for real raw support). + */ + if (termios->c_iflag & IGNPAR) +- sport->port.ignore_status_mask |= UARTSR1_OR; ++ port->ignore_status_mask |= UARTSR1_OR; + } + + /* update the per-port timeout */ + uart_update_timeout(port, termios->c_cflag, baud); + + /* wait transmit engin complete */ +- lpuart_wait_bit_set(&sport->port, UARTSR1, UARTSR1_TC); ++ lpuart_wait_bit_set(port, UARTSR1, UARTSR1_TC); + + /* disable transmit and receive */ + writeb(old_cr2 & ~(UARTCR2_TE | UARTCR2_RE), +- sport->port.membase + UARTCR2); ++ port->membase + UARTCR2); + +- sbr = sport->port.uartclk / (16 * baud); +- brfa = ((sport->port.uartclk - (16 * sbr * baud)) * 2) / baud; ++ sbr = port->uartclk / (16 * baud); ++ brfa = ((port->uartclk - (16 * sbr * baud)) * 2) / baud; + bdh &= ~UARTBDH_SBR_MASK; + bdh |= (sbr >> 8) & 0x1F; + cr4 &= ~UARTCR4_BRFA_MASK; + brfa &= UARTCR4_BRFA_MASK; +- writeb(cr4 | brfa, sport->port.membase + UARTCR4); +- writeb(bdh, sport->port.membase + UARTBDH); +- writeb(sbr & 0xFF, sport->port.membase + UARTBDL); +- writeb(cr3, sport->port.membase + UARTCR3); +- writeb(cr1, sport->port.membase + UARTCR1); +- writeb(modem, sport->port.membase + UARTMODEM); ++ writeb(cr4 | brfa, port->membase + UARTCR4); ++ writeb(bdh, port->membase + UARTBDH); ++ writeb(sbr & 0xFF, port->membase + UARTBDL); ++ writeb(cr3, port->membase + UARTCR3); ++ writeb(cr1, port->membase + UARTCR1); ++ writeb(modem, port->membase + UARTMODEM); + + /* restore control register */ +- writeb(old_cr2, sport->port.membase + UARTCR2); ++ writeb(old_cr2, port->membase + UARTCR2); + + if (old && sport->lpuart_dma_rx_use) { + if (!lpuart_start_rx_dma(sport)) +@@ -2140,7 +2131,7 @@ lpuart_set_termios(struct uart_port *port, struct ktermios *termios, + sport->lpuart_dma_rx_use = false; + } + +- uart_port_unlock_irqrestore(&sport->port, flags); ++ uart_port_unlock_irqrestore(port, flags); + } + + static void __lpuart32_serial_setbrg(struct uart_port *port, +@@ -2238,9 +2229,9 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + unsigned int baud; + unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8; + +- ctrl = old_ctrl = lpuart32_read(&sport->port, UARTCTRL); +- bd = lpuart32_read(&sport->port, UARTBAUD); +- modem = lpuart32_read(&sport->port, UARTMODIR); ++ ctrl = old_ctrl = lpuart32_read(port, UARTCTRL); ++ bd = lpuart32_read(port, UARTBAUD); ++ modem = lpuart32_read(port, UARTMODIR); + sport->is_cs7 = false; + /* + * only support CS8 and CS7 +@@ -2274,7 +2265,7 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + * When auto RS-485 RTS mode is enabled, + * hardware flow control need to be disabled. + */ +- if (sport->port.rs485.flags & SER_RS485_ENABLED) ++ if (port->rs485.flags & SER_RS485_ENABLED) + termios->c_cflag &= ~CRTSCTS; + + if (termios->c_cflag & CRTSCTS) +@@ -2324,32 +2315,32 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + * Need to update the Ring buffer length according to the selected + * baud rate and restart Rx DMA path. + * +- * Since timer function acqures sport->port.lock, need to stop before ++ * Since timer function acqures port->lock, need to stop before + * acquring same lock because otherwise del_timer_sync() can deadlock. + */ + if (old && sport->lpuart_dma_rx_use) +- lpuart_dma_rx_free(&sport->port); ++ lpuart_dma_rx_free(port); + +- uart_port_lock_irqsave(&sport->port, &flags); ++ uart_port_lock_irqsave(port, &flags); + +- sport->port.read_status_mask = 0; ++ port->read_status_mask = 0; + if (termios->c_iflag & INPCK) +- sport->port.read_status_mask |= UARTSTAT_FE | UARTSTAT_PE; ++ port->read_status_mask |= UARTSTAT_FE | UARTSTAT_PE; + if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK)) +- sport->port.read_status_mask |= UARTSTAT_FE; ++ port->read_status_mask |= UARTSTAT_FE; + + /* characters to ignore */ +- sport->port.ignore_status_mask = 0; ++ port->ignore_status_mask = 0; + if (termios->c_iflag & IGNPAR) +- sport->port.ignore_status_mask |= UARTSTAT_PE; ++ port->ignore_status_mask |= UARTSTAT_PE; + if (termios->c_iflag & IGNBRK) { +- sport->port.ignore_status_mask |= UARTSTAT_FE; ++ port->ignore_status_mask |= UARTSTAT_FE; + /* + * if we're ignoring parity and break indicators, + * ignore overruns too (for real raw support). + */ + if (termios->c_iflag & IGNPAR) +- sport->port.ignore_status_mask |= UARTSTAT_OR; ++ port->ignore_status_mask |= UARTSTAT_OR; + } + + /* update the per-port timeout */ +@@ -2361,22 +2352,22 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + * asserted. + */ + if (!(old_ctrl & UARTCTRL_SBK)) { +- lpuart32_write(&sport->port, 0, UARTMODIR); +- lpuart32_wait_bit_set(&sport->port, UARTSTAT, UARTSTAT_TC); ++ lpuart32_write(port, 0, UARTMODIR); ++ lpuart32_wait_bit_set(port, UARTSTAT, UARTSTAT_TC); + } + + /* disable transmit and receive */ +- lpuart32_write(&sport->port, old_ctrl & ~(UARTCTRL_TE | UARTCTRL_RE), ++ lpuart32_write(port, old_ctrl & ~(UARTCTRL_TE | UARTCTRL_RE), + UARTCTRL); + +- lpuart32_write(&sport->port, bd, UARTBAUD); ++ lpuart32_write(port, bd, UARTBAUD); + lpuart32_serial_setbrg(sport, baud); + /* disable CTS before enabling UARTCTRL_TE to avoid pending idle preamble */ +- lpuart32_write(&sport->port, modem & ~UARTMODIR_TXCTSE, UARTMODIR); ++ lpuart32_write(port, modem & ~UARTMODIR_TXCTSE, UARTMODIR); + /* restore control register */ +- lpuart32_write(&sport->port, ctrl, UARTCTRL); ++ lpuart32_write(port, ctrl, UARTCTRL); + /* re-enable the CTS if needed */ +- lpuart32_write(&sport->port, modem, UARTMODIR); ++ lpuart32_write(port, modem, UARTMODIR); + + if ((ctrl & (UARTCTRL_PE | UARTCTRL_M)) == UARTCTRL_PE) + sport->is_cs7 = true; +@@ -2388,7 +2379,7 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + sport->lpuart_dma_rx_use = false; + } + +- uart_port_unlock_irqrestore(&sport->port, flags); ++ uart_port_unlock_irqrestore(port, flags); + } + + static const char *lpuart_type(struct uart_port *port) +@@ -2826,7 +2817,7 @@ static int lpuart_global_reset(struct lpuart_port *sport) + + ret = clk_prepare_enable(sport->ipg_clk); + if (ret) { +- dev_err(sport->port.dev, "failed to enable uart ipg clk: %d\n", ret); ++ dev_err(port->dev, "failed to enable uart ipg clk: %d\n", ret); + return ret; + } + +@@ -2837,10 +2828,10 @@ static int lpuart_global_reset(struct lpuart_port *sport) + */ + ctrl = lpuart32_read(port, UARTCTRL); + if (ctrl & UARTCTRL_TE) { +- bd = lpuart32_read(&sport->port, UARTBAUD); ++ bd = lpuart32_read(port, UARTBAUD); + if (read_poll_timeout(lpuart32_tx_empty, val, val, 1, 100000, false, + port)) { +- dev_warn(sport->port.dev, ++ dev_warn(port->dev, + "timeout waiting for transmit engine to complete\n"); + clk_disable_unprepare(sport->ipg_clk); + return 0; +@@ -3192,7 +3183,7 @@ static void lpuart_console_fixup(struct lpuart_port *sport) + * in VLLS mode, or restore console setting here. + */ + if (is_imx7ulp_lpuart(sport) && lpuart_uport_is_active(sport) && +- console_suspend_enabled && uart_console(&sport->port)) { ++ console_suspend_enabled && uart_console(uport)) { + + mutex_lock(&port->mutex); + memset(&termios, 0, sizeof(struct ktermios)); +-- +2.39.5 + diff --git a/queue-6.14/tty-serial-fsl_lpuart-use-u32-and-u8-for-register-va.patch b/queue-6.14/tty-serial-fsl_lpuart-use-u32-and-u8-for-register-va.patch new file mode 100644 index 0000000000..5b6c696a99 --- /dev/null +++ b/queue-6.14/tty-serial-fsl_lpuart-use-u32-and-u8-for-register-va.patch @@ -0,0 +1,407 @@ +From f3c1094a7a5e45cae5ca42ee85524c31548cab34 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 12 Mar 2025 10:39:02 +0800 +Subject: tty: serial: fsl_lpuart: Use u32 and u8 for register variables + +From: Sherry Sun + +[ Upstream commit b6a8f6ab2c53e5ea3c7f2a3978db378a89bb7595 ] + +Use u32 and u8 rather than unsigned long or unsigned char for register +variables for clarity and consistency. + +Signed-off-by: Sherry Sun +Link: https://lore.kernel.org/r/20250312023904.1343351-2-sherry.sun@nxp.com +Signed-off-by: Greg Kroah-Hartman +Stable-dep-of: e98ab45ec518 ("tty: serial: lpuart: only disable CTS instead of overwriting the whole UARTMODIR register") +Signed-off-by: Sasha Levin +--- + drivers/tty/serial/fsl_lpuart.c | 93 ++++++++++++++++----------------- + 1 file changed, 46 insertions(+), 47 deletions(-) + +diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c +index 79623b2482a04..1be0bf3b2f50f 100644 +--- a/drivers/tty/serial/fsl_lpuart.c ++++ b/drivers/tty/serial/fsl_lpuart.c +@@ -441,7 +441,7 @@ static unsigned int lpuart_get_baud_clk_rate(struct lpuart_port *sport) + + static void lpuart_stop_tx(struct uart_port *port) + { +- unsigned char temp; ++ u8 temp; + + temp = readb(port->membase + UARTCR2); + temp &= ~(UARTCR2_TIE | UARTCR2_TCIE); +@@ -450,7 +450,7 @@ static void lpuart_stop_tx(struct uart_port *port) + + static void lpuart32_stop_tx(struct uart_port *port) + { +- unsigned long temp; ++ u32 temp; + + temp = lpuart32_read(port, UARTCTRL); + temp &= ~(UARTCTRL_TIE | UARTCTRL_TCIE); +@@ -459,7 +459,7 @@ static void lpuart32_stop_tx(struct uart_port *port) + + static void lpuart_stop_rx(struct uart_port *port) + { +- unsigned char temp; ++ u8 temp; + + temp = readb(port->membase + UARTCR2); + writeb(temp & ~UARTCR2_RE, port->membase + UARTCR2); +@@ -467,7 +467,7 @@ static void lpuart_stop_rx(struct uart_port *port) + + static void lpuart32_stop_rx(struct uart_port *port) + { +- unsigned long temp; ++ u32 temp; + + temp = lpuart32_read(port, UARTCTRL); + lpuart32_write(port, temp & ~UARTCTRL_RE, UARTCTRL); +@@ -642,7 +642,7 @@ static int lpuart_poll_init(struct uart_port *port) + struct lpuart_port *sport = container_of(port, + struct lpuart_port, port); + unsigned long flags; +- unsigned char temp; ++ u8 temp; + + sport->port.fifosize = 0; + +@@ -752,7 +752,7 @@ static inline void lpuart_transmit_buffer(struct lpuart_port *sport) + static inline void lpuart32_transmit_buffer(struct lpuart_port *sport) + { + struct tty_port *tport = &sport->port.state->port; +- unsigned long txcnt; ++ u32 txcnt; + unsigned char c; + + if (sport->port.x_char) { +@@ -789,7 +789,7 @@ static void lpuart_start_tx(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, + struct lpuart_port, port); +- unsigned char temp; ++ u8 temp; + + temp = readb(port->membase + UARTCR2); + writeb(temp | UARTCR2_TIE, port->membase + UARTCR2); +@@ -806,7 +806,7 @@ static void lpuart_start_tx(struct uart_port *port) + static void lpuart32_start_tx(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); +- unsigned long temp; ++ u32 temp; + + if (sport->lpuart_dma_tx_use) { + if (!lpuart_stopped_or_empty(port)) +@@ -839,8 +839,8 @@ static unsigned int lpuart_tx_empty(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, + struct lpuart_port, port); +- unsigned char sr1 = readb(port->membase + UARTSR1); +- unsigned char sfifo = readb(port->membase + UARTSFIFO); ++ u8 sr1 = readb(port->membase + UARTSR1); ++ u8 sfifo = readb(port->membase + UARTSFIFO); + + if (sport->dma_tx_in_progress) + return 0; +@@ -855,9 +855,9 @@ static unsigned int lpuart32_tx_empty(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, + struct lpuart_port, port); +- unsigned long stat = lpuart32_read(port, UARTSTAT); +- unsigned long sfifo = lpuart32_read(port, UARTFIFO); +- unsigned long ctrl = lpuart32_read(port, UARTCTRL); ++ u32 stat = lpuart32_read(port, UARTSTAT); ++ u32 sfifo = lpuart32_read(port, UARTFIFO); ++ u32 ctrl = lpuart32_read(port, UARTCTRL); + + if (sport->dma_tx_in_progress) + return 0; +@@ -884,7 +884,7 @@ static void lpuart_rxint(struct lpuart_port *sport) + { + unsigned int flg, ignored = 0, overrun = 0; + struct tty_port *port = &sport->port.state->port; +- unsigned char rx, sr; ++ u8 rx, sr; + + uart_port_lock(&sport->port); + +@@ -961,7 +961,7 @@ static void lpuart32_rxint(struct lpuart_port *sport) + { + unsigned int flg, ignored = 0; + struct tty_port *port = &sport->port.state->port; +- unsigned long rx, sr; ++ u32 rx, sr; + bool is_break; + + uart_port_lock(&sport->port); +@@ -1039,7 +1039,7 @@ static void lpuart32_rxint(struct lpuart_port *sport) + static irqreturn_t lpuart_int(int irq, void *dev_id) + { + struct lpuart_port *sport = dev_id; +- unsigned char sts; ++ u8 sts; + + sts = readb(sport->port.membase + UARTSR1); + +@@ -1113,7 +1113,7 @@ static void lpuart_copy_rx_to_tty(struct lpuart_port *sport) + int count, copied; + + if (lpuart_is_32(sport)) { +- unsigned long sr = lpuart32_read(&sport->port, UARTSTAT); ++ u32 sr = lpuart32_read(&sport->port, UARTSTAT); + + if (sr & (UARTSTAT_PE | UARTSTAT_FE)) { + /* Clear the error flags */ +@@ -1125,10 +1125,10 @@ static void lpuart_copy_rx_to_tty(struct lpuart_port *sport) + sport->port.icount.frame++; + } + } else { +- unsigned char sr = readb(sport->port.membase + UARTSR1); ++ u8 sr = readb(sport->port.membase + UARTSR1); + + if (sr & (UARTSR1_PE | UARTSR1_FE)) { +- unsigned char cr2; ++ u8 cr2; + + /* Disable receiver during this operation... */ + cr2 = readb(sport->port.membase + UARTCR2); +@@ -1279,7 +1279,7 @@ static void lpuart32_dma_idleint(struct lpuart_port *sport) + static irqreturn_t lpuart32_int(int irq, void *dev_id) + { + struct lpuart_port *sport = dev_id; +- unsigned long sts, rxcount; ++ u32 sts, rxcount; + + sts = lpuart32_read(&sport->port, UARTSTAT); + rxcount = lpuart32_read(&sport->port, UARTWATER); +@@ -1411,12 +1411,12 @@ static inline int lpuart_start_rx_dma(struct lpuart_port *sport) + dma_async_issue_pending(chan); + + if (lpuart_is_32(sport)) { +- unsigned long temp = lpuart32_read(&sport->port, UARTBAUD); ++ u32 temp = lpuart32_read(&sport->port, UARTBAUD); + + lpuart32_write(&sport->port, temp | UARTBAUD_RDMAE, UARTBAUD); + + if (sport->dma_idle_int) { +- unsigned long ctrl = lpuart32_read(&sport->port, UARTCTRL); ++ u32 ctrl = lpuart32_read(&sport->port, UARTCTRL); + + lpuart32_write(&sport->port, ctrl | UARTCTRL_ILIE, UARTCTRL); + } +@@ -1482,7 +1482,7 @@ static int lpuart32_config_rs485(struct uart_port *port, struct ktermios *termio + struct lpuart_port *sport = container_of(port, + struct lpuart_port, port); + +- unsigned long modem = lpuart32_read(&sport->port, UARTMODIR) ++ u32 modem = lpuart32_read(&sport->port, UARTMODIR) + & ~(UARTMODIR_TXRTSPOL | UARTMODIR_TXRTSE); + u32 ctrl; + +@@ -1577,7 +1577,7 @@ static void lpuart32_set_mctrl(struct uart_port *port, unsigned int mctrl) + + static void lpuart_break_ctl(struct uart_port *port, int break_state) + { +- unsigned char temp; ++ u8 temp; + + temp = readb(port->membase + UARTCR2) & ~UARTCR2_SBK; + +@@ -1589,7 +1589,7 @@ static void lpuart_break_ctl(struct uart_port *port, int break_state) + + static void lpuart32_break_ctl(struct uart_port *port, int break_state) + { +- unsigned long temp; ++ u32 temp; + + temp = lpuart32_read(port, UARTCTRL); + +@@ -1623,8 +1623,7 @@ static void lpuart32_break_ctl(struct uart_port *port, int break_state) + + static void lpuart_setup_watermark(struct lpuart_port *sport) + { +- unsigned char val, cr2; +- unsigned char cr2_saved; ++ u8 val, cr2, cr2_saved; + + cr2 = readb(sport->port.membase + UARTCR2); + cr2_saved = cr2; +@@ -1657,7 +1656,7 @@ static void lpuart_setup_watermark(struct lpuart_port *sport) + + static void lpuart_setup_watermark_enable(struct lpuart_port *sport) + { +- unsigned char cr2; ++ u8 cr2; + + lpuart_setup_watermark(sport); + +@@ -1668,8 +1667,7 @@ static void lpuart_setup_watermark_enable(struct lpuart_port *sport) + + static void lpuart32_setup_watermark(struct lpuart_port *sport) + { +- unsigned long val, ctrl; +- unsigned long ctrl_saved; ++ u32 val, ctrl, ctrl_saved; + + ctrl = lpuart32_read(&sport->port, UARTCTRL); + ctrl_saved = ctrl; +@@ -1778,7 +1776,7 @@ static void lpuart_tx_dma_startup(struct lpuart_port *sport) + static void lpuart_rx_dma_startup(struct lpuart_port *sport) + { + int ret; +- unsigned char cr3; ++ u8 cr3; + + if (uart_console(&sport->port)) + goto err; +@@ -1828,7 +1826,7 @@ static void lpuart_hw_setup(struct lpuart_port *sport) + static int lpuart_startup(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); +- unsigned char temp; ++ u8 temp; + + /* determine FIFO size and enable FIFO mode */ + temp = readb(sport->port.membase + UARTPFIFO); +@@ -1848,7 +1846,7 @@ static int lpuart_startup(struct uart_port *port) + + static void lpuart32_hw_disable(struct lpuart_port *sport) + { +- unsigned long temp; ++ u32 temp; + + temp = lpuart32_read(&sport->port, UARTCTRL); + temp &= ~(UARTCTRL_RIE | UARTCTRL_ILIE | UARTCTRL_RE | +@@ -1858,7 +1856,7 @@ static void lpuart32_hw_disable(struct lpuart_port *sport) + + static void lpuart32_configure(struct lpuart_port *sport) + { +- unsigned long temp; ++ u32 temp; + + temp = lpuart32_read(&sport->port, UARTCTRL); + if (!sport->lpuart_dma_rx_use) +@@ -1888,7 +1886,7 @@ static void lpuart32_hw_setup(struct lpuart_port *sport) + static int lpuart32_startup(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); +- unsigned long temp; ++ u32 temp; + + /* determine FIFO size */ + temp = lpuart32_read(&sport->port, UARTFIFO); +@@ -1942,7 +1940,7 @@ static void lpuart_dma_shutdown(struct lpuart_port *sport) + static void lpuart_shutdown(struct uart_port *port) + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); +- unsigned char temp; ++ u8 temp; + unsigned long flags; + + uart_port_lock_irqsave(port, &flags); +@@ -1962,7 +1960,7 @@ static void lpuart32_shutdown(struct uart_port *port) + { + struct lpuart_port *sport = + container_of(port, struct lpuart_port, port); +- unsigned long temp; ++ u32 temp; + unsigned long flags; + + uart_port_lock_irqsave(port, &flags); +@@ -1998,7 +1996,7 @@ lpuart_set_termios(struct uart_port *port, struct ktermios *termios, + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); + unsigned long flags; +- unsigned char cr1, old_cr1, old_cr2, cr3, cr4, bdh, modem; ++ u8 cr1, old_cr1, old_cr2, cr3, cr4, bdh, modem; + unsigned int baud; + unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8; + unsigned int sbr, brfa; +@@ -2236,7 +2234,7 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + { + struct lpuart_port *sport = container_of(port, struct lpuart_port, port); + unsigned long flags; +- unsigned long ctrl, old_ctrl, bd, modem; ++ u32 ctrl, old_ctrl, bd, modem; + unsigned int baud; + unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8; + +@@ -2503,7 +2501,7 @@ static void + lpuart_console_write(struct console *co, const char *s, unsigned int count) + { + struct lpuart_port *sport = lpuart_ports[co->index]; +- unsigned char old_cr2, cr2; ++ u8 old_cr2, cr2; + unsigned long flags; + int locked = 1; + +@@ -2533,7 +2531,7 @@ static void + lpuart32_console_write(struct console *co, const char *s, unsigned int count) + { + struct lpuart_port *sport = lpuart_ports[co->index]; +- unsigned long old_cr, cr; ++ u32 old_cr, cr; + unsigned long flags; + int locked = 1; + +@@ -2567,7 +2565,7 @@ static void __init + lpuart_console_get_options(struct lpuart_port *sport, int *baud, + int *parity, int *bits) + { +- unsigned char cr, bdh, bdl, brfa; ++ u8 cr, bdh, bdl, brfa; + unsigned int sbr, uartclk, baud_raw; + + cr = readb(sport->port.membase + UARTCR2); +@@ -2616,7 +2614,7 @@ static void __init + lpuart32_console_get_options(struct lpuart_port *sport, int *baud, + int *parity, int *bits) + { +- unsigned long cr, bd; ++ u32 cr, bd; + unsigned int sbr, uartclk, baud_raw; + + cr = lpuart32_read(&sport->port, UARTCTRL); +@@ -2822,7 +2820,7 @@ static int lpuart_global_reset(struct lpuart_port *sport) + { + struct uart_port *port = &sport->port; + void __iomem *global_addr; +- unsigned long ctrl, bd; ++ u32 ctrl, bd; + unsigned int val = 0; + int ret; + +@@ -3028,7 +3026,7 @@ static int lpuart_runtime_resume(struct device *dev) + + static void serial_lpuart_enable_wakeup(struct lpuart_port *sport, bool on) + { +- unsigned int val, baud; ++ u32 val, baud; + + if (lpuart_is_32(sport)) { + val = lpuart32_read(&sport->port, UARTCTRL); +@@ -3093,7 +3091,7 @@ static int lpuart_suspend_noirq(struct device *dev) + static int lpuart_resume_noirq(struct device *dev) + { + struct lpuart_port *sport = dev_get_drvdata(dev); +- unsigned int val; ++ u32 val; + + pinctrl_pm_select_default_state(dev); + +@@ -3113,7 +3111,8 @@ static int lpuart_resume_noirq(struct device *dev) + static int lpuart_suspend(struct device *dev) + { + struct lpuart_port *sport = dev_get_drvdata(dev); +- unsigned long temp, flags; ++ u32 temp; ++ unsigned long flags; + + uart_suspend_port(&lpuart_reg, &sport->port); + +-- +2.39.5 + diff --git a/queue-6.14/tty-serial-lpuart-only-disable-cts-instead-of-overwr.patch b/queue-6.14/tty-serial-lpuart-only-disable-cts-instead-of-overwr.patch new file mode 100644 index 0000000000..bdb5d02d2c --- /dev/null +++ b/queue-6.14/tty-serial-lpuart-only-disable-cts-instead-of-overwr.patch @@ -0,0 +1,65 @@ +From c86c84bfa8683fad1686fd9022ceb8257dc8dc9d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 7 Mar 2025 14:54:46 +0800 +Subject: tty: serial: lpuart: only disable CTS instead of overwriting the + whole UARTMODIR register + +From: Sherry Sun + +[ Upstream commit e98ab45ec5182605d2e00114cba3bbf46b0ea27f ] + +No need to overwrite the whole UARTMODIR register before waiting the +transmit engine complete, actually our target here is only to disable +CTS flow control to avoid the dirty data in TX FIFO may block the +transmit engine complete. +Also delete the following duplicate CTS disable configuration. + +Fixes: d5a2e0834364 ("tty: serial: lpuart: disable flow control while waiting for the transmit engine to complete") +Cc: stable +Signed-off-by: Sherry Sun +Link: https://lore.kernel.org/r/20250307065446.1122482-1-sherry.sun@nxp.com +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Sasha Levin +--- + drivers/tty/serial/fsl_lpuart.c | 12 +++++++----- + 1 file changed, 7 insertions(+), 5 deletions(-) + +diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c +index f26162d98db62..9fdb66f2fcb81 100644 +--- a/drivers/tty/serial/fsl_lpuart.c ++++ b/drivers/tty/serial/fsl_lpuart.c +@@ -2346,15 +2346,19 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + /* update the per-port timeout */ + uart_update_timeout(port, termios->c_cflag, baud); + ++ /* ++ * disable CTS to ensure the transmit engine is not blocked by the flow ++ * control when there is dirty data in TX FIFO ++ */ ++ lpuart32_write(port, modem & ~UARTMODIR_TXCTSE, UARTMODIR); ++ + /* + * LPUART Transmission Complete Flag may never be set while queuing a break + * character, so skip waiting for transmission complete when UARTCTRL_SBK is + * asserted. + */ +- if (!(old_ctrl & UARTCTRL_SBK)) { +- lpuart32_write(port, 0, UARTMODIR); ++ if (!(old_ctrl & UARTCTRL_SBK)) + lpuart32_wait_bit_set(port, UARTSTAT, UARTSTAT_TC); +- } + + /* disable transmit and receive */ + lpuart32_write(port, old_ctrl & ~(UARTCTRL_TE | UARTCTRL_RE), +@@ -2362,8 +2366,6 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios, + + lpuart32_write(port, bd, UARTBAUD); + lpuart32_serial_setbrg(sport, baud); +- /* disable CTS before enabling UARTCTRL_TE to avoid pending idle preamble */ +- lpuart32_write(port, modem & ~UARTMODIR_TXCTSE, UARTMODIR); + /* restore control register */ + lpuart32_write(port, ctrl, UARTCTRL); + /* re-enable the CTS if needed */ +-- +2.39.5 +