Linux patch 5.15.1085.15-113

Signed-off-by: Alice Ferrazzi <alicef@gentoo.org>

2 files changed, 8773 insertions, 0 deletions

diff --git a/0000_README b/0000_README
index 80647af5..02551f59 100644
--- a/0000_README
+++ b/0000_README
@@ -467,6 +467,14 @@ Patch:  1105_linux-5.15.106.patch
 From:   https://www.kernel.org
 Desc:   Linux 5.15.106
 
+Patch:  1106_linux-5.15.107.patch
+From:   https://www.kernel.org
+Desc:   Linux 5.15.107
+
+Patch:  1107_linux-5.15.108.patch
+From:   https://www.kernel.org
+Desc:   Linux 5.15.108
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.
diff --git a/1107_linux-5.15.108.patch b/1107_linux-5.15.108.patch
new file mode 100644
index 00000000..29cb3e65
--- /dev/null
+++ b/1107_linux-5.15.108.patch
@@ -0,0 +1,8765 @@
+diff --git a/Documentation/driver-api/generic-counter.rst b/Documentation/driver-api/generic-counter.rst
+index 64fe7db080e52..252aeb639bc40 100644
+--- a/Documentation/driver-api/generic-counter.rst
++++ b/Documentation/driver-api/generic-counter.rst
+@@ -247,7 +247,7 @@ for defining a counter device.
+ .. kernel-doc:: include/linux/counter.h
+    :internal:
+ 
+-.. kernel-doc:: drivers/counter/counter.c
++.. kernel-doc:: drivers/counter/counter-core.c
+    :export:
+ 
+ Implementation
+diff --git a/Documentation/networking/ip-sysctl.rst b/Documentation/networking/ip-sysctl.rst
+index ba0e8e6337c0a..7890b395e629b 100644
+--- a/Documentation/networking/ip-sysctl.rst
++++ b/Documentation/networking/ip-sysctl.rst
+@@ -322,6 +322,8 @@ tcp_app_win - INTEGER
+ 	Reserve max(window/2^tcp_app_win, mss) of window for application
+ 	buffer. Value 0 is special, it means that nothing is reserved.
+ 
++	Possible values are [0, 31], inclusive.
++
+ 	Default: 31
+ 
+ tcp_autocorking - BOOLEAN
+diff --git a/Documentation/sound/hd-audio/models.rst b/Documentation/sound/hd-audio/models.rst
+index 9b52f50a68542..1204304500147 100644
+--- a/Documentation/sound/hd-audio/models.rst
++++ b/Documentation/sound/hd-audio/models.rst
+@@ -704,7 +704,7 @@ ref
+ no-jd
+     BIOS setup but without jack-detection
+ intel
+-    Intel DG45* mobos
++    Intel D*45* mobos
+ dell-m6-amic
+     Dell desktops/laptops with analog mics
+ dell-m6-dmic
+diff --git a/MAINTAINERS b/MAINTAINERS
+index d0884a5d49b99..2d3d2155c744d 100644
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -4813,7 +4813,6 @@ F:	Documentation/ABI/testing/sysfs-bus-counter
+ F:	Documentation/driver-api/generic-counter.rst
+ F:	drivers/counter/
+ F:	include/linux/counter.h
+-F:	include/linux/counter_enum.h
+ 
+ CP2615 I2C DRIVER
+ M:	Bence Csókás <bence98@sch.bme.hu>
+diff --git a/Makefile b/Makefile
+index b06324521d280..49ae089784a66 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 5
+ PATCHLEVEL = 15
+-SUBLEVEL = 107
++SUBLEVEL = 108
+ EXTRAVERSION =
+ NAME = Trick or Treat
+ 
+diff --git a/arch/arm/lib/uaccess_with_memcpy.c b/arch/arm/lib/uaccess_with_memcpy.c
+index 106f83a5ea6d2..35e03f6a62127 100644
+--- a/arch/arm/lib/uaccess_with_memcpy.c
++++ b/arch/arm/lib/uaccess_with_memcpy.c
+@@ -121,7 +121,7 @@ __copy_to_user_memcpy(void __user *to, const void *from, unsigned long n)
+ 			tocopy = n;
+ 
+ 		ua_flags = uaccess_save_and_enable();
+-		memcpy((void *)to, from, tocopy);
++		__memcpy((void *)to, from, tocopy);
+ 		uaccess_restore(ua_flags);
+ 		to += tocopy;
+ 		from += tocopy;
+@@ -188,7 +188,7 @@ __clear_user_memset(void __user *addr, unsigned long n)
+ 			tocopy = n;
+ 
+ 		ua_flags = uaccess_save_and_enable();
+-		memset((void *)addr, 0, tocopy);
++		__memset((void *)addr, 0, tocopy);
+ 		uaccess_restore(ua_flags);
+ 		addr += tocopy;
+ 		n -= tocopy;
+diff --git a/arch/arm64/kvm/pmu-emul.c b/arch/arm64/kvm/pmu-emul.c
+index 2af3c37445e00..886048c083638 100644
+--- a/arch/arm64/kvm/pmu-emul.c
++++ b/arch/arm64/kvm/pmu-emul.c
+@@ -554,6 +554,7 @@ void kvm_pmu_software_increment(struct kvm_vcpu *vcpu, u64 val)
+ 			__vcpu_sys_reg(vcpu, PMOVSSET_EL0) |= BIT(i);
+ 		}
+ 	}
++	kvm_vcpu_pmu_restore_guest(vcpu);
+ }
+ 
+ /**
+diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
+index c11612db4a371..d00170d7ddf5e 100644
+--- a/arch/arm64/kvm/sys_regs.c
++++ b/arch/arm64/kvm/sys_regs.c
+@@ -702,7 +702,6 @@ static bool access_pmcr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
+ 			val |= ARMV8_PMU_PMCR_LC;
+ 		__vcpu_sys_reg(vcpu, PMCR_EL0) = val;
+ 		kvm_pmu_handle_pmcr(vcpu, val);
+-		kvm_vcpu_pmu_restore_guest(vcpu);
+ 	} else {
+ 		/* PMCR.P & PMCR.C are RAZ */
+ 		val = __vcpu_sys_reg(vcpu, PMCR_EL0)
+diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
+index 5fb829256b59d..9c038c8cebebc 100644
+--- a/arch/powerpc/mm/numa.c
++++ b/arch/powerpc/mm/numa.c
+@@ -367,6 +367,7 @@ void update_numa_distance(struct device_node *node)
+ 	WARN(numa_distance_table[nid][nid] == -1,
+ 	     "NUMA distance details for node %d not provided\n", nid);
+ }
++EXPORT_SYMBOL_GPL(update_numa_distance);
+ 
+ /*
+  * ibm,numa-lookup-index-table= {N, domainid1, domainid2, ..... domainidN}
+diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
+index f48e87ac89c9b..3cfcc748052e9 100644
+--- a/arch/powerpc/platforms/pseries/papr_scm.c
++++ b/arch/powerpc/platforms/pseries/papr_scm.c
+@@ -1159,6 +1159,13 @@ static int papr_scm_probe(struct platform_device *pdev)
+ 		return -ENODEV;
+ 	}
+ 
++	/*
++	 * open firmware platform device create won't update the NUMA 
++	 * distance table. For PAPR SCM devices we use numa_map_to_online_node()
++	 * to find the nearest online NUMA node and that requires correct
++	 * distance table information.
++	 */
++	update_numa_distance(dn);
+ 
+ 	p = kzalloc(sizeof(*p), GFP_KERNEL);
+ 	if (!p)
+diff --git a/arch/riscv/kernel/signal.c b/arch/riscv/kernel/signal.c
+index f8fb85dc94b7a..8892569aad23b 100644
+--- a/arch/riscv/kernel/signal.c
++++ b/arch/riscv/kernel/signal.c
+@@ -16,6 +16,7 @@
+ #include <asm/vdso.h>
+ #include <asm/switch_to.h>
+ #include <asm/csr.h>
++#include <asm/cacheflush.h>
+ 
+ extern u32 __user_rt_sigreturn[2];
+ 
+@@ -178,6 +179,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
+ {
+ 	struct rt_sigframe __user *frame;
+ 	long err = 0;
++	unsigned long __maybe_unused addr;
+ 
+ 	frame = get_sigframe(ksig, regs, sizeof(*frame));
+ 	if (!access_ok(frame, sizeof(*frame)))
+@@ -206,7 +208,12 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
+ 	if (copy_to_user(&frame->sigreturn_code, __user_rt_sigreturn,
+ 			 sizeof(frame->sigreturn_code)))
+ 		return -EFAULT;
+-	regs->ra = (unsigned long)&frame->sigreturn_code;
++
++	addr = (unsigned long)&frame->sigreturn_code;
++	/* Make sure the two instructions are pushed to icache. */
++	flush_icache_range(addr, addr + sizeof(frame->sigreturn_code));
++
++	regs->ra = addr;
+ #endif /* CONFIG_MMU */
+ 
+ 	/*
+diff --git a/arch/x86/kernel/x86_init.c b/arch/x86/kernel/x86_init.c
+index 8b395821cb8d0..d3e3b16ea9cf3 100644
+--- a/arch/x86/kernel/x86_init.c
++++ b/arch/x86/kernel/x86_init.c
+@@ -32,8 +32,8 @@ static int __init iommu_init_noop(void) { return 0; }
+ static void iommu_shutdown_noop(void) { }
+ bool __init bool_x86_init_noop(void) { return false; }
+ void x86_op_int_noop(int cpu) { }
+-static __init int set_rtc_noop(const struct timespec64 *now) { return -EINVAL; }
+-static __init void get_rtc_noop(struct timespec64 *now) { }
++static int set_rtc_noop(const struct timespec64 *now) { return -EINVAL; }
++static void get_rtc_noop(struct timespec64 *now) { }
+ 
+ static __initconst const struct of_device_id of_cmos_match[] = {
+ 	{ .compatible = "motorola,mc146818" },
+diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c
+index 615a76d700194..bf5161dcf89e7 100644
+--- a/arch/x86/pci/fixup.c
++++ b/arch/x86/pci/fixup.c
+@@ -7,6 +7,7 @@
+ #include <linux/dmi.h>
+ #include <linux/pci.h>
+ #include <linux/vgaarb.h>
++#include <asm/amd_nb.h>
+ #include <asm/hpet.h>
+ #include <asm/pci_x86.h>
+ 
+@@ -824,3 +825,23 @@ static void rs690_fix_64bit_dma(struct pci_dev *pdev)
+ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x7910, rs690_fix_64bit_dma);
+ 
+ #endif
++
++#ifdef CONFIG_AMD_NB
++
++#define AMD_15B8_RCC_DEV2_EPF0_STRAP2                                  0x10136008
++#define AMD_15B8_RCC_DEV2_EPF0_STRAP2_NO_SOFT_RESET_DEV2_F0_MASK       0x00000080L
++
++static void quirk_clear_strap_no_soft_reset_dev2_f0(struct pci_dev *dev)
++{
++	u32 data;
++
++	if (!amd_smn_read(0, AMD_15B8_RCC_DEV2_EPF0_STRAP2, &data)) {
++		data &= ~AMD_15B8_RCC_DEV2_EPF0_STRAP2_NO_SOFT_RESET_DEV2_F0_MASK;
++		if (amd_smn_write(0, AMD_15B8_RCC_DEV2_EPF0_STRAP2, data))
++			pci_err(dev, "Failed to write data 0x%x\n", data);
++	} else {
++		pci_err(dev, "Failed to read data\n");
++	}
++}
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, 0x15b8, quirk_clear_strap_no_soft_reset_dev2_f0);
++#endif
+diff --git a/crypto/asymmetric_keys/pkcs7_verify.c b/crypto/asymmetric_keys/pkcs7_verify.c
+index f94a1d1ad3a6c..df279538cead3 100644
+--- a/crypto/asymmetric_keys/pkcs7_verify.c
++++ b/crypto/asymmetric_keys/pkcs7_verify.c
+@@ -79,16 +79,16 @@ static int pkcs7_digest(struct pkcs7_message *pkcs7,
+ 		}
+ 
+ 		if (sinfo->msgdigest_len != sig->digest_size) {
+-			pr_debug("Sig %u: Invalid digest size (%u)\n",
+-				 sinfo->index, sinfo->msgdigest_len);
++			pr_warn("Sig %u: Invalid digest size (%u)\n",
++				sinfo->index, sinfo->msgdigest_len);
+ 			ret = -EBADMSG;
+ 			goto error;
+ 		}
+ 
+ 		if (memcmp(sig->digest, sinfo->msgdigest,
+ 			   sinfo->msgdigest_len) != 0) {
+-			pr_debug("Sig %u: Message digest doesn't match\n",
+-				 sinfo->index);
++			pr_warn("Sig %u: Message digest doesn't match\n",
++				sinfo->index);
+ 			ret = -EKEYREJECTED;
+ 			goto error;
+ 		}
+@@ -481,7 +481,7 @@ int pkcs7_supply_detached_data(struct pkcs7_message *pkcs7,
+ 			       const void *data, size_t datalen)
+ {
+ 	if (pkcs7->data) {
+-		pr_debug("Data already supplied\n");
++		pr_warn("Data already supplied\n");
+ 		return -EINVAL;
+ 	}
+ 	pkcs7->data = data;
+diff --git a/crypto/asymmetric_keys/verify_pefile.c b/crypto/asymmetric_keys/verify_pefile.c
+index 7553ab18db898..22beaf2213a22 100644
+--- a/crypto/asymmetric_keys/verify_pefile.c
++++ b/crypto/asymmetric_keys/verify_pefile.c
+@@ -74,7 +74,7 @@ static int pefile_parse_binary(const void *pebuf, unsigned int pelen,
+ 		break;
+ 
+ 	default:
+-		pr_debug("Unknown PEOPT magic = %04hx\n", pe32->magic);
++		pr_warn("Unknown PEOPT magic = %04hx\n", pe32->magic);
+ 		return -ELIBBAD;
+ 	}
+ 
+@@ -95,7 +95,7 @@ static int pefile_parse_binary(const void *pebuf, unsigned int pelen,
+ 	ctx->certs_size = ddir->certs.size;
+ 
+ 	if (!ddir->certs.virtual_address || !ddir->certs.size) {
+-		pr_debug("Unsigned PE binary\n");
++		pr_warn("Unsigned PE binary\n");
+ 		return -ENODATA;
+ 	}
+ 
+@@ -127,7 +127,7 @@ static int pefile_strip_sig_wrapper(const void *pebuf,
+ 	unsigned len;
+ 
+ 	if (ctx->sig_len < sizeof(wrapper)) {
+-		pr_debug("Signature wrapper too short\n");
++		pr_warn("Signature wrapper too short\n");
+ 		return -ELIBBAD;
+ 	}
+ 
+@@ -135,19 +135,23 @@ static int pefile_strip_sig_wrapper(const void *pebuf,
+ 	pr_debug("sig wrapper = { %x, %x, %x }\n",
+ 		 wrapper.length, wrapper.revision, wrapper.cert_type);
+ 
+-	/* Both pesign and sbsign round up the length of certificate table
+-	 * (in optional header data directories) to 8 byte alignment.
++	/* sbsign rounds up the length of certificate table (in optional
++	 * header data directories) to 8 byte alignment.  However, the PE
++	 * specification states that while entries are 8-byte aligned, this is
++	 * not included in their length, and as a result, pesign has not
++	 * rounded up since 0.110.
+ 	 */
+-	if (round_up(wrapper.length, 8) != ctx->sig_len) {
+-		pr_debug("Signature wrapper len wrong\n");
++	if (wrapper.length > ctx->sig_len) {
++		pr_warn("Signature wrapper bigger than sig len (%x > %x)\n",
++			ctx->sig_len, wrapper.length);
+ 		return -ELIBBAD;
+ 	}
+ 	if (wrapper.revision != WIN_CERT_REVISION_2_0) {
+-		pr_debug("Signature is not revision 2.0\n");
++		pr_warn("Signature is not revision 2.0\n");
+ 		return -ENOTSUPP;
+ 	}
+ 	if (wrapper.cert_type != WIN_CERT_TYPE_PKCS_SIGNED_DATA) {
+-		pr_debug("Signature certificate type is not PKCS\n");
++		pr_warn("Signature certificate type is not PKCS\n");
+ 		return -ENOTSUPP;
+ 	}
+ 
+@@ -160,7 +164,7 @@ static int pefile_strip_sig_wrapper(const void *pebuf,
+ 	ctx->sig_offset += sizeof(wrapper);
+ 	ctx->sig_len -= sizeof(wrapper);
+ 	if (ctx->sig_len < 4) {
+-		pr_debug("Signature data missing\n");
++		pr_warn("Signature data missing\n");
+ 		return -EKEYREJECTED;
+ 	}
+ 
+@@ -194,7 +198,7 @@ check_len:
+ 		return 0;
+ 	}
+ not_pkcs7:
+-	pr_debug("Signature data not PKCS#7\n");
++	pr_warn("Signature data not PKCS#7\n");
+ 	return -ELIBBAD;
+ }
+ 
+@@ -337,8 +341,8 @@ static int pefile_digest_pe(const void *pebuf, unsigned int pelen,
+ 	digest_size = crypto_shash_digestsize(tfm);
+ 
+ 	if (digest_size != ctx->digest_len) {
+-		pr_debug("Digest size mismatch (%zx != %x)\n",
+-			 digest_size, ctx->digest_len);
++		pr_warn("Digest size mismatch (%zx != %x)\n",
++			digest_size, ctx->digest_len);
+ 		ret = -EBADMSG;
+ 		goto error_no_desc;
+ 	}
+@@ -369,7 +373,7 @@ static int pefile_digest_pe(const void *pebuf, unsigned int pelen,
+ 	 * PKCS#7 certificate.
+ 	 */
+ 	if (memcmp(digest, ctx->digest, ctx->digest_len) != 0) {
+-		pr_debug("Digest mismatch\n");
++		pr_warn("Digest mismatch\n");
+ 		ret = -EKEYREJECTED;
+ 	} else {
+ 		pr_debug("The digests match!\n");
+diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
+index 3b9f894873365..803dc6afa6d69 100644
+--- a/drivers/acpi/resource.c
++++ b/drivers/acpi/resource.c
+@@ -396,6 +396,13 @@ static const struct dmi_system_id medion_laptop[] = {
+ 			DMI_MATCH(DMI_BOARD_NAME, "M17T"),
+ 		},
+ 	},
++	{
++		.ident = "MEDION S17413",
++		.matches = {
++			DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
++			DMI_MATCH(DMI_BOARD_NAME, "M1xA"),
++		},
++	},
+ 	{ }
+ };
+ 
+diff --git a/drivers/clk/sprd/common.c b/drivers/clk/sprd/common.c
+index ce81e4087a8fc..2bfbab8db94bf 100644
+--- a/drivers/clk/sprd/common.c
++++ b/drivers/clk/sprd/common.c
+@@ -17,7 +17,6 @@ static const struct regmap_config sprdclk_regmap_config = {
+ 	.reg_bits	= 32,
+ 	.reg_stride	= 4,
+ 	.val_bits	= 32,
+-	.max_register	= 0xffff,
+ 	.fast_io	= true,
+ };
+ 
+@@ -43,6 +42,8 @@ int sprd_clk_regmap_init(struct platform_device *pdev,
+ 	struct device *dev = &pdev->dev;
+ 	struct device_node *node = dev->of_node, *np;
+ 	struct regmap *regmap;
++	struct resource *res;
++	struct regmap_config reg_config = sprdclk_regmap_config;
+ 
+ 	if (of_find_property(node, "sprd,syscon", NULL)) {
+ 		regmap = syscon_regmap_lookup_by_phandle(node, "sprd,syscon");
+@@ -59,12 +60,14 @@ int sprd_clk_regmap_init(struct platform_device *pdev,
+ 			return PTR_ERR(regmap);
+ 		}
+ 	} else {
+-		base = devm_platform_ioremap_resource(pdev, 0);
++		base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
+ 		if (IS_ERR(base))
+ 			return PTR_ERR(base);
+ 
++		reg_config.max_register = resource_size(res) - reg_config.reg_stride;
++
+ 		regmap = devm_regmap_init_mmio(&pdev->dev, base,
+-					       &sprdclk_regmap_config);
++					       &reg_config);
+ 		if (IS_ERR(regmap)) {
+ 			pr_err("failed to init regmap\n");
+ 			return PTR_ERR(regmap);
+diff --git a/drivers/counter/104-quad-8.c b/drivers/counter/104-quad-8.c
+index 0caa60537b142..e00cf156c6e9a 100644
+--- a/drivers/counter/104-quad-8.c
++++ b/drivers/counter/104-quad-8.c
+@@ -117,7 +117,7 @@ static int quad8_signal_read(struct counter_device *counter,
+ }
+ 
+ static int quad8_count_read(struct counter_device *counter,
+-	struct counter_count *count, unsigned long *val)
++			    struct counter_count *count, u64 *val)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int base_offset = priv->base + 2 * count->id;
+@@ -148,7 +148,7 @@ static int quad8_count_read(struct counter_device *counter,
+ }
+ 
+ static int quad8_count_write(struct counter_device *counter,
+-	struct counter_count *count, unsigned long val)
++			     struct counter_count *count, u64 val)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int base_offset = priv->base + 2 * count->id;
+@@ -188,22 +188,16 @@ static int quad8_count_write(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-enum quad8_count_function {
+-	QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = 0,
+-	QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
+-	QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
+-	QUAD8_COUNT_FUNCTION_QUADRATURE_X4
+-};
+-
+ static const enum counter_function quad8_count_functions_list[] = {
+-	[QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_FUNCTION_PULSE_DIRECTION,
+-	[QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_FUNCTION_QUADRATURE_X1_A,
+-	[QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_FUNCTION_QUADRATURE_X2_A,
+-	[QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_FUNCTION_QUADRATURE_X4
++	COUNTER_FUNCTION_PULSE_DIRECTION,
++	COUNTER_FUNCTION_QUADRATURE_X1_A,
++	COUNTER_FUNCTION_QUADRATURE_X2_A,
++	COUNTER_FUNCTION_QUADRATURE_X4,
+ };
+ 
+-static int quad8_function_get(struct counter_device *counter,
+-	struct counter_count *count, size_t *function)
++static int quad8_function_read(struct counter_device *counter,
++			       struct counter_count *count,
++			       enum counter_function *function)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int id = count->id;
+@@ -213,25 +207,26 @@ static int quad8_function_get(struct counter_device *counter,
+ 	if (priv->quadrature_mode[id])
+ 		switch (priv->quadrature_scale[id]) {
+ 		case 0:
+-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X1;
++			*function = COUNTER_FUNCTION_QUADRATURE_X1_A;
+ 			break;
+ 		case 1:
+-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X2;
++			*function = COUNTER_FUNCTION_QUADRATURE_X2_A;
+ 			break;
+ 		case 2:
+-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X4;
++			*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 			break;
+ 		}
+ 	else
+-		*function = QUAD8_COUNT_FUNCTION_PULSE_DIRECTION;
++		*function = COUNTER_FUNCTION_PULSE_DIRECTION;
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+ 	return 0;
+ }
+ 
+-static int quad8_function_set(struct counter_device *counter,
+-	struct counter_count *count, size_t function)
++static int quad8_function_write(struct counter_device *counter,
++				struct counter_count *count,
++				enum counter_function function)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int id = count->id;
+@@ -247,7 +242,7 @@ static int quad8_function_set(struct counter_device *counter,
+ 	mode_cfg = priv->count_mode[id] << 1;
+ 	idr_cfg = priv->index_polarity[id] << 1;
+ 
+-	if (function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
++	if (function == COUNTER_FUNCTION_PULSE_DIRECTION) {
+ 		*quadrature_mode = 0;
+ 
+ 		/* Quadrature scaling only available in quadrature mode */
+@@ -263,15 +258,15 @@ static int quad8_function_set(struct counter_device *counter,
+ 		*quadrature_mode = 1;
+ 
+ 		switch (function) {
+-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
++		case COUNTER_FUNCTION_QUADRATURE_X1_A:
+ 			*scale = 0;
+ 			mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
+ 			break;
+-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
++		case COUNTER_FUNCTION_QUADRATURE_X2_A:
+ 			*scale = 1;
+ 			mode_cfg |= QUAD8_CMR_QUADRATURE_X2;
+ 			break;
+-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
++		case COUNTER_FUNCTION_QUADRATURE_X4:
+ 			*scale = 2;
+ 			mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
+ 			break;
+@@ -290,8 +285,9 @@ static int quad8_function_set(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static void quad8_direction_get(struct counter_device *counter,
+-	struct counter_count *count, enum counter_count_direction *direction)
++static int quad8_direction_read(struct counter_device *counter,
++				struct counter_count *count,
++				enum counter_count_direction *direction)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 	unsigned int ud_flag;
+@@ -302,76 +298,74 @@ static void quad8_direction_get(struct counter_device *counter,
+ 
+ 	*direction = (ud_flag) ? COUNTER_COUNT_DIRECTION_FORWARD :
+ 		COUNTER_COUNT_DIRECTION_BACKWARD;
+-}
+ 
+-enum quad8_synapse_action {
+-	QUAD8_SYNAPSE_ACTION_NONE = 0,
+-	QUAD8_SYNAPSE_ACTION_RISING_EDGE,
+-	QUAD8_SYNAPSE_ACTION_FALLING_EDGE,
+-	QUAD8_SYNAPSE_ACTION_BOTH_EDGES
+-};
++	return 0;
++}
+ 
+ static const enum counter_synapse_action quad8_index_actions_list[] = {
+-	[QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
+-	[QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE
++	COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+ };
+ 
+ static const enum counter_synapse_action quad8_synapse_actions_list[] = {
+-	[QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
+-	[QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+-	[QUAD8_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+-	[QUAD8_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
++	COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
++	COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+ };
+ 
+-static int quad8_action_get(struct counter_device *counter,
+-	struct counter_count *count, struct counter_synapse *synapse,
+-	size_t *action)
++static int quad8_action_read(struct counter_device *counter,
++			     struct counter_count *count,
++			     struct counter_synapse *synapse,
++			     enum counter_synapse_action *action)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	int err;
+-	size_t function = 0;
++	enum counter_function function;
+ 	const size_t signal_a_id = count->synapses[0].signal->id;
+ 	enum counter_count_direction direction;
+ 
+ 	/* Handle Index signals */
+ 	if (synapse->signal->id >= 16) {
+-		if (priv->preset_enable[count->id])
+-			*action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
++		if (!priv->preset_enable[count->id])
++			*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 		else
+-			*action = QUAD8_SYNAPSE_ACTION_NONE;
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 
+ 		return 0;
+ 	}
+ 
+-	err = quad8_function_get(counter, count, &function);
++	err = quad8_function_read(counter, count, &function);
+ 	if (err)
+ 		return err;
+ 
+ 	/* Default action mode */
+-	*action = QUAD8_SYNAPSE_ACTION_NONE;
++	*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 
+ 	/* Determine action mode based on current count function mode */
+ 	switch (function) {
+-	case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
++	case COUNTER_FUNCTION_PULSE_DIRECTION:
+ 		if (synapse->signal->id == signal_a_id)
+-			*action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
++			*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 		return 0;
+-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
++	case COUNTER_FUNCTION_QUADRATURE_X1_A:
+ 		if (synapse->signal->id == signal_a_id) {
+-			quad8_direction_get(counter, count, &direction);
++			err = quad8_direction_read(counter, count, &direction);
++			if (err)
++				return err;
+ 
+ 			if (direction == COUNTER_COUNT_DIRECTION_FORWARD)
+-				*action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
++				*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 			else
+-				*action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
++				*action = COUNTER_SYNAPSE_ACTION_FALLING_EDGE;
+ 		}
+ 		return 0;
+-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
++	case COUNTER_FUNCTION_QUADRATURE_X2_A:
+ 		if (synapse->signal->id == signal_a_id)
+-			*action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
++			*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		return 0;
+-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
+-		*action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
++	case COUNTER_FUNCTION_QUADRATURE_X4:
++		*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		return 0;
+ 	default:
+ 		/* should never reach this path */
+@@ -383,9 +377,9 @@ static const struct counter_ops quad8_ops = {
+ 	.signal_read = quad8_signal_read,
+ 	.count_read = quad8_count_read,
+ 	.count_write = quad8_count_write,
+-	.function_get = quad8_function_get,
+-	.function_set = quad8_function_set,
+-	.action_get = quad8_action_get
++	.function_read = quad8_function_read,
++	.function_write = quad8_function_write,
++	.action_read = quad8_action_read
+ };
+ 
+ static const char *const quad8_index_polarity_modes[] = {
+@@ -394,7 +388,8 @@ static const char *const quad8_index_polarity_modes[] = {
+ };
+ 
+ static int quad8_index_polarity_get(struct counter_device *counter,
+-	struct counter_signal *signal, size_t *index_polarity)
++				    struct counter_signal *signal,
++				    u32 *index_polarity)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id - 16;
+@@ -405,7 +400,8 @@ static int quad8_index_polarity_get(struct counter_device *counter,
+ }
+ 
+ static int quad8_index_polarity_set(struct counter_device *counter,
+-	struct counter_signal *signal, size_t index_polarity)
++				    struct counter_signal *signal,
++				    u32 index_polarity)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id - 16;
+@@ -426,20 +422,14 @@ static int quad8_index_polarity_set(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static struct counter_signal_enum_ext quad8_index_pol_enum = {
+-	.items = quad8_index_polarity_modes,
+-	.num_items = ARRAY_SIZE(quad8_index_polarity_modes),
+-	.get = quad8_index_polarity_get,
+-	.set = quad8_index_polarity_set
+-};
+-
+ static const char *const quad8_synchronous_modes[] = {
+ 	"non-synchronous",
+ 	"synchronous"
+ };
+ 
+ static int quad8_synchronous_mode_get(struct counter_device *counter,
+-	struct counter_signal *signal, size_t *synchronous_mode)
++				      struct counter_signal *signal,
++				      u32 *synchronous_mode)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id - 16;
+@@ -450,7 +440,8 @@ static int quad8_synchronous_mode_get(struct counter_device *counter,
+ }
+ 
+ static int quad8_synchronous_mode_set(struct counter_device *counter,
+-	struct counter_signal *signal, size_t synchronous_mode)
++				      struct counter_signal *signal,
++				      u32 synchronous_mode)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id - 16;
+@@ -477,22 +468,18 @@ static int quad8_synchronous_mode_set(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static struct counter_signal_enum_ext quad8_syn_mode_enum = {
+-	.items = quad8_synchronous_modes,
+-	.num_items = ARRAY_SIZE(quad8_synchronous_modes),
+-	.get = quad8_synchronous_mode_get,
+-	.set = quad8_synchronous_mode_set
+-};
+-
+-static ssize_t quad8_count_floor_read(struct counter_device *counter,
+-	struct counter_count *count, void *private, char *buf)
++static int quad8_count_floor_read(struct counter_device *counter,
++				  struct counter_count *count, u64 *floor)
+ {
+ 	/* Only a floor of 0 is supported */
+-	return sprintf(buf, "0\n");
++	*floor = 0;
++
++	return 0;
+ }
+ 
+-static int quad8_count_mode_get(struct counter_device *counter,
+-	struct counter_count *count, size_t *cnt_mode)
++static int quad8_count_mode_read(struct counter_device *counter,
++				 struct counter_count *count,
++				 enum counter_count_mode *cnt_mode)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 
+@@ -515,26 +502,28 @@ static int quad8_count_mode_get(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static int quad8_count_mode_set(struct counter_device *counter,
+-	struct counter_count *count, size_t cnt_mode)
++static int quad8_count_mode_write(struct counter_device *counter,
++				  struct counter_count *count,
++				  enum counter_count_mode cnt_mode)
+ {
+ 	struct quad8 *const priv = counter->priv;
++	unsigned int count_mode;
+ 	unsigned int mode_cfg;
+ 	const int base_offset = priv->base + 2 * count->id + 1;
+ 
+ 	/* Map Generic Counter count mode to 104-QUAD-8 count mode */
+ 	switch (cnt_mode) {
+ 	case COUNTER_COUNT_MODE_NORMAL:
+-		cnt_mode = 0;
++		count_mode = 0;
+ 		break;
+ 	case COUNTER_COUNT_MODE_RANGE_LIMIT:
+-		cnt_mode = 1;
++		count_mode = 1;
+ 		break;
+ 	case COUNTER_COUNT_MODE_NON_RECYCLE:
+-		cnt_mode = 2;
++		count_mode = 2;
+ 		break;
+ 	case COUNTER_COUNT_MODE_MODULO_N:
+-		cnt_mode = 3;
++		count_mode = 3;
+ 		break;
+ 	default:
+ 		/* should never reach this path */
+@@ -543,10 +532,10 @@ static int quad8_count_mode_set(struct counter_device *counter,
+ 
+ 	mutex_lock(&priv->lock);
+ 
+-	priv->count_mode[count->id] = cnt_mode;
++	priv->count_mode[count->id] = count_mode;
+ 
+ 	/* Set count mode configuration value */
+-	mode_cfg = cnt_mode << 1;
++	mode_cfg = count_mode << 1;
+ 
+ 	/* Add quadrature mode configuration */
+ 	if (priv->quadrature_mode[count->id])
+@@ -560,56 +549,35 @@ static int quad8_count_mode_set(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static struct counter_count_enum_ext quad8_cnt_mode_enum = {
+-	.items = counter_count_mode_str,
+-	.num_items = ARRAY_SIZE(counter_count_mode_str),
+-	.get = quad8_count_mode_get,
+-	.set = quad8_count_mode_set
+-};
+-
+-static ssize_t quad8_count_direction_read(struct counter_device *counter,
+-	struct counter_count *count, void *priv, char *buf)
+-{
+-	enum counter_count_direction dir;
+-
+-	quad8_direction_get(counter, count, &dir);
+-
+-	return sprintf(buf, "%s\n", counter_count_direction_str[dir]);
+-}
+-
+-static ssize_t quad8_count_enable_read(struct counter_device *counter,
+-	struct counter_count *count, void *private, char *buf)
++static int quad8_count_enable_read(struct counter_device *counter,
++				   struct counter_count *count, u8 *enable)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 
+-	return sprintf(buf, "%u\n", priv->ab_enable[count->id]);
++	*enable = priv->ab_enable[count->id];
++
++	return 0;
+ }
+ 
+-static ssize_t quad8_count_enable_write(struct counter_device *counter,
+-	struct counter_count *count, void *private, const char *buf, size_t len)
++static int quad8_count_enable_write(struct counter_device *counter,
++				    struct counter_count *count, u8 enable)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int base_offset = priv->base + 2 * count->id;
+-	int err;
+-	bool ab_enable;
+ 	unsigned int ior_cfg;
+ 
+-	err = kstrtobool(buf, &ab_enable);
+-	if (err)
+-		return err;
+-
+ 	mutex_lock(&priv->lock);
+ 
+-	priv->ab_enable[count->id] = ab_enable;
++	priv->ab_enable[count->id] = enable;
+ 
+-	ior_cfg = ab_enable | priv->preset_enable[count->id] << 1;
++	ior_cfg = enable | priv->preset_enable[count->id] << 1;
+ 
+ 	/* Load I/O control configuration */
+ 	outb(QUAD8_CTR_IOR | ior_cfg, base_offset + 1);
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	return len;
++	return 0;
+ }
+ 
+ static const char *const quad8_noise_error_states[] = {
+@@ -618,7 +586,7 @@ static const char *const quad8_noise_error_states[] = {
+ };
+ 
+ static int quad8_error_noise_get(struct counter_device *counter,
+-	struct counter_count *count, size_t *noise_error)
++				 struct counter_count *count, u32 *noise_error)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 	const int base_offset = priv->base + 2 * count->id + 1;
+@@ -628,18 +596,14 @@ static int quad8_error_noise_get(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static struct counter_count_enum_ext quad8_error_noise_enum = {
+-	.items = quad8_noise_error_states,
+-	.num_items = ARRAY_SIZE(quad8_noise_error_states),
+-	.get = quad8_error_noise_get
+-};
+-
+-static ssize_t quad8_count_preset_read(struct counter_device *counter,
+-	struct counter_count *count, void *private, char *buf)
++static int quad8_count_preset_read(struct counter_device *counter,
++				   struct counter_count *count, u64 *preset)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 
+-	return sprintf(buf, "%u\n", priv->preset[count->id]);
++	*preset = priv->preset[count->id];
++
++	return 0;
+ }
+ 
+ static void quad8_preset_register_set(struct quad8 *const priv, const int id,
+@@ -658,16 +622,10 @@ static void quad8_preset_register_set(struct quad8 *const priv, const int id,
+ 		outb(preset >> (8 * i), base_offset);
+ }
+ 
+-static ssize_t quad8_count_preset_write(struct counter_device *counter,
+-	struct counter_count *count, void *private, const char *buf, size_t len)
++static int quad8_count_preset_write(struct counter_device *counter,
++				    struct counter_count *count, u64 preset)
+ {
+ 	struct quad8 *const priv = counter->priv;
+-	unsigned int preset;
+-	int ret;
+-
+-	ret = kstrtouint(buf, 0, &preset);
+-	if (ret)
+-		return ret;
+ 
+ 	/* Only 24-bit values are supported */
+ 	if (preset > 0xFFFFFF)
+@@ -679,11 +637,11 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
+-	struct counter_count *count, void *private, char *buf)
++static int quad8_count_ceiling_read(struct counter_device *counter,
++				    struct counter_count *count, u64 *ceiling)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 
+@@ -693,26 +651,23 @@ static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
+ 	switch (priv->count_mode[count->id]) {
+ 	case 1:
+ 	case 3:
+-		mutex_unlock(&priv->lock);
+-		return sprintf(buf, "%u\n", priv->preset[count->id]);
++		*ceiling = priv->preset[count->id];
++		break;
++	default:
++		/* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
++		*ceiling = 0x1FFFFFF;
++		break;
+ 	}
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	/* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
+-	return sprintf(buf, "33554431\n");
++	return 0;
+ }
+ 
+-static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
+-	struct counter_count *count, void *private, const char *buf, size_t len)
++static int quad8_count_ceiling_write(struct counter_device *counter,
++				     struct counter_count *count, u64 ceiling)
+ {
+ 	struct quad8 *const priv = counter->priv;
+-	unsigned int ceiling;
+-	int ret;
+-
+-	ret = kstrtouint(buf, 0, &ceiling);
+-	if (ret)
+-		return ret;
+ 
+ 	/* Only 24-bit values are supported */
+ 	if (ceiling > 0xFFFFFF)
+@@ -726,7 +681,7 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
+ 	case 3:
+ 		quad8_preset_register_set(priv, count->id, ceiling);
+ 		mutex_unlock(&priv->lock);
+-		return len;
++		return 0;
+ 	}
+ 
+ 	mutex_unlock(&priv->lock);
+@@ -734,27 +689,25 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
+ 	return -EINVAL;
+ }
+ 
+-static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,
+-	struct counter_count *count, void *private, char *buf)
++static int quad8_count_preset_enable_read(struct counter_device *counter,
++					  struct counter_count *count,
++					  u8 *preset_enable)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 
+-	return sprintf(buf, "%u\n", !priv->preset_enable[count->id]);
++	*preset_enable = !priv->preset_enable[count->id];
++
++	return 0;
+ }
+ 
+-static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
+-	struct counter_count *count, void *private, const char *buf, size_t len)
++static int quad8_count_preset_enable_write(struct counter_device *counter,
++					   struct counter_count *count,
++					   u8 preset_enable)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const int base_offset = priv->base + 2 * count->id + 1;
+-	bool preset_enable;
+-	int ret;
+ 	unsigned int ior_cfg;
+ 
+-	ret = kstrtobool(buf, &preset_enable);
+-	if (ret)
+-		return ret;
+-
+ 	/* Preset enable is active low in Input/Output Control register */
+ 	preset_enable = !preset_enable;
+ 
+@@ -762,25 +715,24 @@ static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
+ 
+ 	priv->preset_enable[count->id] = preset_enable;
+ 
+-	ior_cfg = priv->ab_enable[count->id] | (unsigned int)preset_enable << 1;
++	ior_cfg = priv->ab_enable[count->id] | preset_enable << 1;
+ 
+ 	/* Load I/O control configuration to Input / Output Control Register */
+ 	outb(QUAD8_CTR_IOR | ior_cfg, base_offset);
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
+-					     struct counter_signal *signal,
+-					     void *private, char *buf)
++static int quad8_signal_cable_fault_read(struct counter_device *counter,
++					 struct counter_signal *signal,
++					 u8 *cable_fault)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id / 2;
+ 	bool disabled;
+ 	unsigned int status;
+-	unsigned int fault;
+ 
+ 	mutex_lock(&priv->lock);
+ 
+@@ -797,36 +749,31 @@ static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
+ 	mutex_unlock(&priv->lock);
+ 
+ 	/* Mask respective channel and invert logic */
+-	fault = !(status & BIT(channel_id));
++	*cable_fault = !(status & BIT(channel_id));
+ 
+-	return sprintf(buf, "%u\n", fault);
++	return 0;
+ }
+ 
+-static ssize_t quad8_signal_cable_fault_enable_read(
+-	struct counter_device *counter, struct counter_signal *signal,
+-	void *private, char *buf)
++static int quad8_signal_cable_fault_enable_read(struct counter_device *counter,
++						struct counter_signal *signal,
++						u8 *enable)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id / 2;
+-	const unsigned int enb = !!(priv->cable_fault_enable & BIT(channel_id));
+ 
+-	return sprintf(buf, "%u\n", enb);
++	*enable = !!(priv->cable_fault_enable & BIT(channel_id));
++
++	return 0;
+ }
+ 
+-static ssize_t quad8_signal_cable_fault_enable_write(
+-	struct counter_device *counter, struct counter_signal *signal,
+-	void *private, const char *buf, size_t len)
++static int quad8_signal_cable_fault_enable_write(struct counter_device *counter,
++						 struct counter_signal *signal,
++						 u8 enable)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id / 2;
+-	bool enable;
+-	int ret;
+ 	unsigned int cable_fault_enable;
+ 
+-	ret = kstrtobool(buf, &enable);
+-	if (ret)
+-		return ret;
+-
+ 	mutex_lock(&priv->lock);
+ 
+ 	if (enable)
+@@ -841,31 +788,27 @@ static ssize_t quad8_signal_cable_fault_enable_write(
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t quad8_signal_fck_prescaler_read(struct counter_device *counter,
+-	struct counter_signal *signal, void *private, char *buf)
++static int quad8_signal_fck_prescaler_read(struct counter_device *counter,
++					   struct counter_signal *signal,
++					   u8 *prescaler)
+ {
+ 	const struct quad8 *const priv = counter->priv;
+-	const size_t channel_id = signal->id / 2;
+ 
+-	return sprintf(buf, "%u\n", priv->fck_prescaler[channel_id]);
++	*prescaler = priv->fck_prescaler[signal->id / 2];
++
++	return 0;
+ }
+ 
+-static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
+-	struct counter_signal *signal, void *private, const char *buf,
+-	size_t len)
++static int quad8_signal_fck_prescaler_write(struct counter_device *counter,
++					    struct counter_signal *signal,
++					    u8 prescaler)
+ {
+ 	struct quad8 *const priv = counter->priv;
+ 	const size_t channel_id = signal->id / 2;
+ 	const int base_offset = priv->base + 2 * channel_id;
+-	u8 prescaler;
+-	int ret;
+-
+-	ret = kstrtou8(buf, 0, &prescaler);
+-	if (ret)
+-		return ret;
+ 
+ 	mutex_lock(&priv->lock);
+ 
+@@ -881,31 +824,30 @@ static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
+ 
+ 	mutex_unlock(&priv->lock);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static const struct counter_signal_ext quad8_signal_ext[] = {
+-	{
+-		.name = "cable_fault",
+-		.read = quad8_signal_cable_fault_read
+-	},
+-	{
+-		.name = "cable_fault_enable",
+-		.read = quad8_signal_cable_fault_enable_read,
+-		.write = quad8_signal_cable_fault_enable_write
+-	},
+-	{
+-		.name = "filter_clock_prescaler",
+-		.read = quad8_signal_fck_prescaler_read,
+-		.write = quad8_signal_fck_prescaler_write
+-	}
++static struct counter_comp quad8_signal_ext[] = {
++	COUNTER_COMP_SIGNAL_BOOL("cable_fault", quad8_signal_cable_fault_read,
++				 NULL),
++	COUNTER_COMP_SIGNAL_BOOL("cable_fault_enable",
++				 quad8_signal_cable_fault_enable_read,
++				 quad8_signal_cable_fault_enable_write),
++	COUNTER_COMP_SIGNAL_U8("filter_clock_prescaler",
++			       quad8_signal_fck_prescaler_read,
++			       quad8_signal_fck_prescaler_write)
+ };
+ 
+-static const struct counter_signal_ext quad8_index_ext[] = {
+-	COUNTER_SIGNAL_ENUM("index_polarity", &quad8_index_pol_enum),
+-	COUNTER_SIGNAL_ENUM_AVAILABLE("index_polarity",	&quad8_index_pol_enum),
+-	COUNTER_SIGNAL_ENUM("synchronous_mode", &quad8_syn_mode_enum),
+-	COUNTER_SIGNAL_ENUM_AVAILABLE("synchronous_mode", &quad8_syn_mode_enum)
++static DEFINE_COUNTER_ENUM(quad8_index_pol_enum, quad8_index_polarity_modes);
++static DEFINE_COUNTER_ENUM(quad8_synch_mode_enum, quad8_synchronous_modes);
++
++static struct counter_comp quad8_index_ext[] = {
++	COUNTER_COMP_SIGNAL_ENUM("index_polarity", quad8_index_polarity_get,
++				 quad8_index_polarity_set,
++				 quad8_index_pol_enum),
++	COUNTER_COMP_SIGNAL_ENUM("synchronous_mode", quad8_synchronous_mode_get,
++				 quad8_synchronous_mode_set,
++				 quad8_synch_mode_enum),
+ };
+ 
+ #define QUAD8_QUAD_SIGNAL(_id, _name) {		\
+@@ -974,39 +916,30 @@ static struct counter_synapse quad8_count_synapses[][3] = {
+ 	QUAD8_COUNT_SYNAPSES(6), QUAD8_COUNT_SYNAPSES(7)
+ };
+ 
+-static const struct counter_count_ext quad8_count_ext[] = {
+-	{
+-		.name = "ceiling",
+-		.read = quad8_count_ceiling_read,
+-		.write = quad8_count_ceiling_write
+-	},
+-	{
+-		.name = "floor",
+-		.read = quad8_count_floor_read
+-	},
+-	COUNTER_COUNT_ENUM("count_mode", &quad8_cnt_mode_enum),
+-	COUNTER_COUNT_ENUM_AVAILABLE("count_mode", &quad8_cnt_mode_enum),
+-	{
+-		.name = "direction",
+-		.read = quad8_count_direction_read
+-	},
+-	{
+-		.name = "enable",
+-		.read = quad8_count_enable_read,
+-		.write = quad8_count_enable_write
+-	},
+-	COUNTER_COUNT_ENUM("error_noise", &quad8_error_noise_enum),
+-	COUNTER_COUNT_ENUM_AVAILABLE("error_noise", &quad8_error_noise_enum),
+-	{
+-		.name = "preset",
+-		.read = quad8_count_preset_read,
+-		.write = quad8_count_preset_write
+-	},
+-	{
+-		.name = "preset_enable",
+-		.read = quad8_count_preset_enable_read,
+-		.write = quad8_count_preset_enable_write
+-	}
++static const enum counter_count_mode quad8_cnt_modes[] = {
++	COUNTER_COUNT_MODE_NORMAL,
++	COUNTER_COUNT_MODE_RANGE_LIMIT,
++	COUNTER_COUNT_MODE_NON_RECYCLE,
++	COUNTER_COUNT_MODE_MODULO_N,
++};
++
++static DEFINE_COUNTER_AVAILABLE(quad8_count_mode_available, quad8_cnt_modes);
++
++static DEFINE_COUNTER_ENUM(quad8_error_noise_enum, quad8_noise_error_states);
++
++static struct counter_comp quad8_count_ext[] = {
++	COUNTER_COMP_CEILING(quad8_count_ceiling_read,
++			     quad8_count_ceiling_write),
++	COUNTER_COMP_FLOOR(quad8_count_floor_read, NULL),
++	COUNTER_COMP_COUNT_MODE(quad8_count_mode_read, quad8_count_mode_write,
++				quad8_count_mode_available),
++	COUNTER_COMP_DIRECTION(quad8_direction_read),
++	COUNTER_COMP_ENABLE(quad8_count_enable_read, quad8_count_enable_write),
++	COUNTER_COMP_COUNT_ENUM("error_noise", quad8_error_noise_get, NULL,
++				quad8_error_noise_enum),
++	COUNTER_COMP_PRESET(quad8_count_preset_read, quad8_count_preset_write),
++	COUNTER_COMP_PRESET_ENABLE(quad8_count_preset_enable_read,
++				   quad8_count_preset_enable_write),
+ };
+ 
+ #define QUAD8_COUNT(_id, _cntname) {					\
+diff --git a/drivers/counter/Makefile b/drivers/counter/Makefile
+index 19742e6f5e3eb..1ab7e087fdc26 100644
+--- a/drivers/counter/Makefile
++++ b/drivers/counter/Makefile
+@@ -4,6 +4,7 @@
+ #
+ 
+ obj-$(CONFIG_COUNTER) += counter.o
++counter-y := counter-core.o counter-sysfs.o
+ 
+ obj-$(CONFIG_104_QUAD_8)	+= 104-quad-8.o
+ obj-$(CONFIG_INTERRUPT_CNT)		+= interrupt-cnt.o
+diff --git a/drivers/counter/counter-core.c b/drivers/counter/counter-core.c
+new file mode 100644
+index 0000000000000..c533a6ff12cf7
+--- /dev/null
++++ b/drivers/counter/counter-core.c
+@@ -0,0 +1,142 @@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * Generic Counter interface
++ * Copyright (C) 2020 William Breathitt Gray
++ */
++#include <linux/counter.h>
++#include <linux/device.h>
++#include <linux/export.h>
++#include <linux/gfp.h>
++#include <linux/idr.h>
++#include <linux/init.h>
++#include <linux/module.h>
++
++#include "counter-sysfs.h"
++
++/* Provides a unique ID for each counter device */
++static DEFINE_IDA(counter_ida);
++
++static void counter_device_release(struct device *dev)
++{
++	ida_free(&counter_ida, dev->id);
++}
++
++static struct device_type counter_device_type = {
++	.name = "counter_device",
++	.release = counter_device_release,
++};
++
++static struct bus_type counter_bus_type = {
++	.name = "counter",
++	.dev_name = "counter",
++};
++
++/**
++ * counter_register - register Counter to the system
++ * @counter:	pointer to Counter to register
++ *
++ * This function registers a Counter to the system. A sysfs "counter" directory
++ * will be created and populated with sysfs attributes correlating with the
++ * Counter Signals, Synapses, and Counts respectively.
++ */
++int counter_register(struct counter_device *const counter)
++{
++	struct device *const dev = &counter->dev;
++	int id;
++	int err;
++
++	/* Acquire unique ID */
++	id = ida_alloc(&counter_ida, GFP_KERNEL);
++	if (id < 0)
++		return id;
++
++	/* Configure device structure for Counter */
++	dev->id = id;
++	dev->type = &counter_device_type;
++	dev->bus = &counter_bus_type;
++	if (counter->parent) {
++		dev->parent = counter->parent;
++		dev->of_node = counter->parent->of_node;
++	}
++	device_initialize(dev);
++	dev_set_drvdata(dev, counter);
++
++	/* Add Counter sysfs attributes */
++	err = counter_sysfs_add(counter);
++	if (err < 0)
++		goto err_free_id;
++
++	/* Add device to system */
++	err = device_add(dev);
++	if (err < 0)
++		goto err_free_id;
++
++	return 0;
++
++err_free_id:
++	put_device(dev);
++	return err;
++}
++EXPORT_SYMBOL_GPL(counter_register);
++
++/**
++ * counter_unregister - unregister Counter from the system
++ * @counter:	pointer to Counter to unregister
++ *
++ * The Counter is unregistered from the system.
++ */
++void counter_unregister(struct counter_device *const counter)
++{
++	if (!counter)
++		return;
++
++	device_unregister(&counter->dev);
++}
++EXPORT_SYMBOL_GPL(counter_unregister);
++
++static void devm_counter_release(void *counter)
++{
++	counter_unregister(counter);
++}
++
++/**
++ * devm_counter_register - Resource-managed counter_register
++ * @dev:	device to allocate counter_device for
++ * @counter:	pointer to Counter to register
++ *
++ * Managed counter_register. The Counter registered with this function is
++ * automatically unregistered on driver detach. This function calls
++ * counter_register internally. Refer to that function for more information.
++ *
++ * RETURNS:
++ * 0 on success, negative error number on failure.
++ */
++int devm_counter_register(struct device *dev,
++			  struct counter_device *const counter)
++{
++	int err;
++
++	err = counter_register(counter);
++	if (err < 0)
++		return err;
++
++	return devm_add_action_or_reset(dev, devm_counter_release, counter);
++}
++EXPORT_SYMBOL_GPL(devm_counter_register);
++
++static int __init counter_init(void)
++{
++	return bus_register(&counter_bus_type);
++}
++
++static void __exit counter_exit(void)
++{
++	bus_unregister(&counter_bus_type);
++}
++
++subsys_initcall(counter_init);
++module_exit(counter_exit);
++
++MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
++MODULE_DESCRIPTION("Generic Counter interface");
++MODULE_LICENSE("GPL v2");
+diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysfs.c
+new file mode 100644
+index 0000000000000..108cbd838eb92
+--- /dev/null
++++ b/drivers/counter/counter-sysfs.c
+@@ -0,0 +1,849 @@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * Generic Counter sysfs interface
++ * Copyright (C) 2020 William Breathitt Gray
++ */
++#include <linux/counter.h>
++#include <linux/device.h>
++#include <linux/err.h>
++#include <linux/gfp.h>
++#include <linux/kernel.h>
++#include <linux/kstrtox.h>
++#include <linux/list.h>
++#include <linux/string.h>
++#include <linux/sysfs.h>
++#include <linux/types.h>
++
++#include "counter-sysfs.h"
++
++/**
++ * struct counter_attribute - Counter sysfs attribute
++ * @dev_attr:	device attribute for sysfs
++ * @l:		node to add Counter attribute to attribute group list
++ * @comp:	Counter component callbacks and data
++ * @scope:	Counter scope of the attribute
++ * @parent:	pointer to the parent component
++ */
++struct counter_attribute {
++	struct device_attribute dev_attr;
++	struct list_head l;
++
++	struct counter_comp comp;
++	enum counter_scope scope;
++	void *parent;
++};
++
++#define to_counter_attribute(_dev_attr) \
++	container_of(_dev_attr, struct counter_attribute, dev_attr)
++
++/**
++ * struct counter_attribute_group - container for attribute group
++ * @name:	name of the attribute group
++ * @attr_list:	list to keep track of created attributes
++ * @num_attr:	number of attributes
++ */
++struct counter_attribute_group {
++	const char *name;
++	struct list_head attr_list;
++	size_t num_attr;
++};
++
++static const char *const counter_function_str[] = {
++	[COUNTER_FUNCTION_INCREASE] = "increase",
++	[COUNTER_FUNCTION_DECREASE] = "decrease",
++	[COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
++	[COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
++	[COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
++	[COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
++	[COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
++	[COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"
++};
++
++static const char *const counter_signal_value_str[] = {
++	[COUNTER_SIGNAL_LEVEL_LOW] = "low",
++	[COUNTER_SIGNAL_LEVEL_HIGH] = "high"
++};
++
++static const char *const counter_synapse_action_str[] = {
++	[COUNTER_SYNAPSE_ACTION_NONE] = "none",
++	[COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
++	[COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
++	[COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
++};
++
++static const char *const counter_count_direction_str[] = {
++	[COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
++	[COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
++};
++
++static const char *const counter_count_mode_str[] = {
++	[COUNTER_COUNT_MODE_NORMAL] = "normal",
++	[COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
++	[COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
++	[COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
++};
++
++static ssize_t counter_comp_u8_show(struct device *dev,
++				    struct device_attribute *attr, char *buf)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	int err;
++	u8 data = 0;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u8_read(counter, &data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u8_read(counter, a->parent, &data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		err = a->comp.count_u8_read(counter, a->parent, &data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	if (a->comp.type == COUNTER_COMP_BOOL)
++		/* data should already be boolean but ensure just to be safe */
++		data = !!data;
++
++	return sprintf(buf, "%u\n", (unsigned int)data);
++}
++
++static ssize_t counter_comp_u8_store(struct device *dev,
++				     struct device_attribute *attr,
++				     const char *buf, size_t len)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	int err;
++	bool bool_data = 0;
++	u8 data = 0;
++
++	if (a->comp.type == COUNTER_COMP_BOOL) {
++		err = kstrtobool(buf, &bool_data);
++		data = bool_data;
++	} else
++		err = kstrtou8(buf, 0, &data);
++	if (err < 0)
++		return err;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u8_write(counter, data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u8_write(counter, a->parent, data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		err = a->comp.count_u8_write(counter, a->parent, data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	return len;
++}
++
++static ssize_t counter_comp_u32_show(struct device *dev,
++				     struct device_attribute *attr, char *buf)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	const struct counter_available *const avail = a->comp.priv;
++	int err;
++	u32 data = 0;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u32_read(counter, &data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u32_read(counter, a->parent, &data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
++			err = a->comp.action_read(counter, a->parent,
++						  a->comp.priv, &data);
++		else
++			err = a->comp.count_u32_read(counter, a->parent, &data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	switch (a->comp.type) {
++	case COUNTER_COMP_FUNCTION:
++		return sysfs_emit(buf, "%s\n", counter_function_str[data]);
++	case COUNTER_COMP_SIGNAL_LEVEL:
++		return sysfs_emit(buf, "%s\n", counter_signal_value_str[data]);
++	case COUNTER_COMP_SYNAPSE_ACTION:
++		return sysfs_emit(buf, "%s\n", counter_synapse_action_str[data]);
++	case COUNTER_COMP_ENUM:
++		return sysfs_emit(buf, "%s\n", avail->strs[data]);
++	case COUNTER_COMP_COUNT_DIRECTION:
++		return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]);
++	case COUNTER_COMP_COUNT_MODE:
++		return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]);
++	default:
++		return sprintf(buf, "%u\n", (unsigned int)data);
++	}
++}
++
++static int counter_find_enum(u32 *const enum_item, const u32 *const enums,
++			     const size_t num_enums, const char *const buf,
++			     const char *const string_array[])
++{
++	size_t index;
++
++	for (index = 0; index < num_enums; index++) {
++		*enum_item = enums[index];
++		if (sysfs_streq(buf, string_array[*enum_item]))
++			return 0;
++	}
++
++	return -EINVAL;
++}
++
++static ssize_t counter_comp_u32_store(struct device *dev,
++				      struct device_attribute *attr,
++				      const char *buf, size_t len)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	struct counter_count *const count = a->parent;
++	struct counter_synapse *const synapse = a->comp.priv;
++	const struct counter_available *const avail = a->comp.priv;
++	int err;
++	u32 data = 0;
++
++	switch (a->comp.type) {
++	case COUNTER_COMP_FUNCTION:
++		err = counter_find_enum(&data, count->functions_list,
++					count->num_functions, buf,
++					counter_function_str);
++		break;
++	case COUNTER_COMP_SYNAPSE_ACTION:
++		err = counter_find_enum(&data, synapse->actions_list,
++					synapse->num_actions, buf,
++					counter_synapse_action_str);
++		break;
++	case COUNTER_COMP_ENUM:
++		err = __sysfs_match_string(avail->strs, avail->num_items, buf);
++		data = err;
++		break;
++	case COUNTER_COMP_COUNT_MODE:
++		err = counter_find_enum(&data, avail->enums, avail->num_items,
++					buf, counter_count_mode_str);
++		break;
++	default:
++		err = kstrtou32(buf, 0, &data);
++		break;
++	}
++	if (err < 0)
++		return err;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u32_write(counter, data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u32_write(counter, a->parent, data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
++			err = a->comp.action_write(counter, count, synapse,
++						   data);
++		else
++			err = a->comp.count_u32_write(counter, count, data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	return len;
++}
++
++static ssize_t counter_comp_u64_show(struct device *dev,
++				     struct device_attribute *attr, char *buf)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	int err;
++	u64 data = 0;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u64_read(counter, &data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u64_read(counter, a->parent, &data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		err = a->comp.count_u64_read(counter, a->parent, &data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	return sprintf(buf, "%llu\n", (unsigned long long)data);
++}
++
++static ssize_t counter_comp_u64_store(struct device *dev,
++				      struct device_attribute *attr,
++				      const char *buf, size_t len)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	struct counter_device *const counter = dev_get_drvdata(dev);
++	int err;
++	u64 data = 0;
++
++	err = kstrtou64(buf, 0, &data);
++	if (err < 0)
++		return err;
++
++	switch (a->scope) {
++	case COUNTER_SCOPE_DEVICE:
++		err = a->comp.device_u64_write(counter, data);
++		break;
++	case COUNTER_SCOPE_SIGNAL:
++		err = a->comp.signal_u64_write(counter, a->parent, data);
++		break;
++	case COUNTER_SCOPE_COUNT:
++		err = a->comp.count_u64_write(counter, a->parent, data);
++		break;
++	default:
++		return -EINVAL;
++	}
++	if (err < 0)
++		return err;
++
++	return len;
++}
++
++static ssize_t enums_available_show(const u32 *const enums,
++				    const size_t num_enums,
++				    const char *const strs[], char *buf)
++{
++	size_t len = 0;
++	size_t index;
++
++	for (index = 0; index < num_enums; index++)
++		len += sysfs_emit_at(buf, len, "%s\n", strs[enums[index]]);
++
++	return len;
++}
++
++static ssize_t strs_available_show(const struct counter_available *const avail,
++				   char *buf)
++{
++	size_t len = 0;
++	size_t index;
++
++	for (index = 0; index < avail->num_items; index++)
++		len += sysfs_emit_at(buf, len, "%s\n", avail->strs[index]);
++
++	return len;
++}
++
++static ssize_t counter_comp_available_show(struct device *dev,
++					   struct device_attribute *attr,
++					   char *buf)
++{
++	const struct counter_attribute *const a = to_counter_attribute(attr);
++	const struct counter_count *const count = a->parent;
++	const struct counter_synapse *const synapse = a->comp.priv;
++	const struct counter_available *const avail = a->comp.priv;
++
++	switch (a->comp.type) {
++	case COUNTER_COMP_FUNCTION:
++		return enums_available_show(count->functions_list,
++					    count->num_functions,
++					    counter_function_str, buf);
++	case COUNTER_COMP_SYNAPSE_ACTION:
++		return enums_available_show(synapse->actions_list,
++					    synapse->num_actions,
++					    counter_synapse_action_str, buf);
++	case COUNTER_COMP_ENUM:
++		return strs_available_show(avail, buf);
++	case COUNTER_COMP_COUNT_MODE:
++		return enums_available_show(avail->enums, avail->num_items,
++					    counter_count_mode_str, buf);
++	default:
++		return -EINVAL;
++	}
++}
++
++static int counter_avail_attr_create(struct device *const dev,
++	struct counter_attribute_group *const group,
++	const struct counter_comp *const comp, void *const parent)
++{
++	struct counter_attribute *counter_attr;
++	struct device_attribute *dev_attr;
++
++	counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
++	if (!counter_attr)
++		return -ENOMEM;
++
++	/* Configure Counter attribute */
++	counter_attr->comp.type = comp->type;
++	counter_attr->comp.priv = comp->priv;
++	counter_attr->parent = parent;
++
++	/* Initialize sysfs attribute */
++	dev_attr = &counter_attr->dev_attr;
++	sysfs_attr_init(&dev_attr->attr);
++
++	/* Configure device attribute */
++	dev_attr->attr.name = devm_kasprintf(dev, GFP_KERNEL, "%s_available",
++					     comp->name);
++	if (!dev_attr->attr.name)
++		return -ENOMEM;
++	dev_attr->attr.mode = 0444;
++	dev_attr->show = counter_comp_available_show;
++
++	/* Store list node */
++	list_add(&counter_attr->l, &group->attr_list);
++	group->num_attr++;
++
++	return 0;
++}
++
++static int counter_attr_create(struct device *const dev,
++			       struct counter_attribute_group *const group,
++			       const struct counter_comp *const comp,
++			       const enum counter_scope scope,
++			       void *const parent)
++{
++	struct counter_attribute *counter_attr;
++	struct device_attribute *dev_attr;
++
++	counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
++	if (!counter_attr)
++		return -ENOMEM;
++
++	/* Configure Counter attribute */
++	counter_attr->comp = *comp;
++	counter_attr->scope = scope;
++	counter_attr->parent = parent;
++
++	/* Configure device attribute */
++	dev_attr = &counter_attr->dev_attr;
++	sysfs_attr_init(&dev_attr->attr);
++	dev_attr->attr.name = comp->name;
++	switch (comp->type) {
++	case COUNTER_COMP_U8:
++	case COUNTER_COMP_BOOL:
++		if (comp->device_u8_read) {
++			dev_attr->attr.mode |= 0444;
++			dev_attr->show = counter_comp_u8_show;
++		}
++		if (comp->device_u8_write) {
++			dev_attr->attr.mode |= 0200;
++			dev_attr->store = counter_comp_u8_store;
++		}
++		break;
++	case COUNTER_COMP_SIGNAL_LEVEL:
++	case COUNTER_COMP_FUNCTION:
++	case COUNTER_COMP_SYNAPSE_ACTION:
++	case COUNTER_COMP_ENUM:
++	case COUNTER_COMP_COUNT_DIRECTION:
++	case COUNTER_COMP_COUNT_MODE:
++		if (comp->device_u32_read) {
++			dev_attr->attr.mode |= 0444;
++			dev_attr->show = counter_comp_u32_show;
++		}
++		if (comp->device_u32_write) {
++			dev_attr->attr.mode |= 0200;
++			dev_attr->store = counter_comp_u32_store;
++		}
++		break;
++	case COUNTER_COMP_U64:
++		if (comp->device_u64_read) {
++			dev_attr->attr.mode |= 0444;
++			dev_attr->show = counter_comp_u64_show;
++		}
++		if (comp->device_u64_write) {
++			dev_attr->attr.mode |= 0200;
++			dev_attr->store = counter_comp_u64_store;
++		}
++		break;
++	default:
++		return -EINVAL;
++	}
++
++	/* Store list node */
++	list_add(&counter_attr->l, &group->attr_list);
++	group->num_attr++;
++
++	/* Create "*_available" attribute if needed */
++	switch (comp->type) {
++	case COUNTER_COMP_FUNCTION:
++	case COUNTER_COMP_SYNAPSE_ACTION:
++	case COUNTER_COMP_ENUM:
++	case COUNTER_COMP_COUNT_MODE:
++		return counter_avail_attr_create(dev, group, comp, parent);
++	default:
++		return 0;
++	}
++}
++
++static ssize_t counter_comp_name_show(struct device *dev,
++				      struct device_attribute *attr, char *buf)
++{
++	return sysfs_emit(buf, "%s\n", to_counter_attribute(attr)->comp.name);
++}
++
++static int counter_name_attr_create(struct device *const dev,
++				    struct counter_attribute_group *const group,
++				    const char *const name)
++{
++	struct counter_attribute *counter_attr;
++
++	counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
++	if (!counter_attr)
++		return -ENOMEM;
++
++	/* Configure Counter attribute */
++	counter_attr->comp.name = name;
++
++	/* Configure device attribute */
++	sysfs_attr_init(&counter_attr->dev_attr.attr);
++	counter_attr->dev_attr.attr.name = "name";
++	counter_attr->dev_attr.attr.mode = 0444;
++	counter_attr->dev_attr.show = counter_comp_name_show;
++
++	/* Store list node */
++	list_add(&counter_attr->l, &group->attr_list);
++	group->num_attr++;
++
++	return 0;
++}
++
++static struct counter_comp counter_signal_comp = {
++	.type = COUNTER_COMP_SIGNAL_LEVEL,
++	.name = "signal",
++};
++
++static int counter_signal_attrs_create(struct counter_device *const counter,
++	struct counter_attribute_group *const cattr_group,
++	struct counter_signal *const signal)
++{
++	const enum counter_scope scope = COUNTER_SCOPE_SIGNAL;
++	struct device *const dev = &counter->dev;
++	int err;
++	struct counter_comp comp;
++	size_t i;
++
++	/* Create main Signal attribute */
++	comp = counter_signal_comp;
++	comp.signal_u32_read = counter->ops->signal_read;
++	err = counter_attr_create(dev, cattr_group, &comp, scope, signal);
++	if (err < 0)
++		return err;
++
++	/* Create Signal name attribute */
++	err = counter_name_attr_create(dev, cattr_group, signal->name);
++	if (err < 0)
++		return err;
++
++	/* Create an attribute for each extension */
++	for (i = 0; i < signal->num_ext; i++) {
++		err = counter_attr_create(dev, cattr_group, signal->ext + i,
++					  scope, signal);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++static int counter_sysfs_signals_add(struct counter_device *const counter,
++	struct counter_attribute_group *const groups)
++{
++	size_t i;
++	int err;
++
++	/* Add each Signal */
++	for (i = 0; i < counter->num_signals; i++) {
++		/* Generate Signal attribute directory name */
++		groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
++						"signal%zu", i);
++		if (!groups[i].name)
++			return -ENOMEM;
++
++		/* Create all attributes associated with Signal */
++		err = counter_signal_attrs_create(counter, groups + i,
++						  counter->signals + i);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++static int counter_sysfs_synapses_add(struct counter_device *const counter,
++	struct counter_attribute_group *const group,
++	struct counter_count *const count)
++{
++	size_t i;
++
++	/* Add each Synapse */
++	for (i = 0; i < count->num_synapses; i++) {
++		struct device *const dev = &counter->dev;
++		struct counter_synapse *synapse;
++		size_t id;
++		struct counter_comp comp;
++		int err;
++
++		synapse = count->synapses + i;
++
++		/* Generate Synapse action name */
++		id = synapse->signal - counter->signals;
++		comp.name = devm_kasprintf(dev, GFP_KERNEL, "signal%zu_action",
++					   id);
++		if (!comp.name)
++			return -ENOMEM;
++
++		/* Create action attribute */
++		comp.type = COUNTER_COMP_SYNAPSE_ACTION;
++		comp.action_read = counter->ops->action_read;
++		comp.action_write = counter->ops->action_write;
++		comp.priv = synapse;
++		err = counter_attr_create(dev, group, &comp,
++					  COUNTER_SCOPE_COUNT, count);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++static struct counter_comp counter_count_comp =
++	COUNTER_COMP_COUNT_U64("count", NULL, NULL);
++
++static struct counter_comp counter_function_comp = {
++	.type = COUNTER_COMP_FUNCTION,
++	.name = "function",
++};
++
++static int counter_count_attrs_create(struct counter_device *const counter,
++	struct counter_attribute_group *const cattr_group,
++	struct counter_count *const count)
++{
++	const enum counter_scope scope = COUNTER_SCOPE_COUNT;
++	struct device *const dev = &counter->dev;
++	int err;
++	struct counter_comp comp;
++	size_t i;
++
++	/* Create main Count attribute */
++	comp = counter_count_comp;
++	comp.count_u64_read = counter->ops->count_read;
++	comp.count_u64_write = counter->ops->count_write;
++	err = counter_attr_create(dev, cattr_group, &comp, scope, count);
++	if (err < 0)
++		return err;
++
++	/* Create Count name attribute */
++	err = counter_name_attr_create(dev, cattr_group, count->name);
++	if (err < 0)
++		return err;
++
++	/* Create Count function attribute */
++	comp = counter_function_comp;
++	comp.count_u32_read = counter->ops->function_read;
++	comp.count_u32_write = counter->ops->function_write;
++	err = counter_attr_create(dev, cattr_group, &comp, scope, count);
++	if (err < 0)
++		return err;
++
++	/* Create an attribute for each extension */
++	for (i = 0; i < count->num_ext; i++) {
++		err = counter_attr_create(dev, cattr_group, count->ext + i,
++					  scope, count);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++static int counter_sysfs_counts_add(struct counter_device *const counter,
++	struct counter_attribute_group *const groups)
++{
++	size_t i;
++	struct counter_count *count;
++	int err;
++
++	/* Add each Count */
++	for (i = 0; i < counter->num_counts; i++) {
++		count = counter->counts + i;
++
++		/* Generate Count attribute directory name */
++		groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
++						"count%zu", i);
++		if (!groups[i].name)
++			return -ENOMEM;
++
++		/* Add sysfs attributes of the Synapses */
++		err = counter_sysfs_synapses_add(counter, groups + i, count);
++		if (err < 0)
++			return err;
++
++		/* Create all attributes associated with Count */
++		err = counter_count_attrs_create(counter, groups + i, count);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++static int counter_num_signals_read(struct counter_device *counter, u8 *val)
++{
++	*val = counter->num_signals;
++	return 0;
++}
++
++static int counter_num_counts_read(struct counter_device *counter, u8 *val)
++{
++	*val = counter->num_counts;
++	return 0;
++}
++
++static struct counter_comp counter_num_signals_comp =
++	COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL);
++
++static struct counter_comp counter_num_counts_comp =
++	COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL);
++
++static int counter_sysfs_attr_add(struct counter_device *const counter,
++				  struct counter_attribute_group *cattr_group)
++{
++	const enum counter_scope scope = COUNTER_SCOPE_DEVICE;
++	struct device *const dev = &counter->dev;
++	int err;
++	size_t i;
++
++	/* Add Signals sysfs attributes */
++	err = counter_sysfs_signals_add(counter, cattr_group);
++	if (err < 0)
++		return err;
++	cattr_group += counter->num_signals;
++
++	/* Add Counts sysfs attributes */
++	err = counter_sysfs_counts_add(counter, cattr_group);
++	if (err < 0)
++		return err;
++	cattr_group += counter->num_counts;
++
++	/* Create name attribute */
++	err = counter_name_attr_create(dev, cattr_group, counter->name);
++	if (err < 0)
++		return err;
++
++	/* Create num_signals attribute */
++	err = counter_attr_create(dev, cattr_group, &counter_num_signals_comp,
++				  scope, NULL);
++	if (err < 0)
++		return err;
++
++	/* Create num_counts attribute */
++	err = counter_attr_create(dev, cattr_group, &counter_num_counts_comp,
++				  scope, NULL);
++	if (err < 0)
++		return err;
++
++	/* Create an attribute for each extension */
++	for (i = 0; i < counter->num_ext; i++) {
++		err = counter_attr_create(dev, cattr_group, counter->ext + i,
++					  scope, NULL);
++		if (err < 0)
++			return err;
++	}
++
++	return 0;
++}
++
++/**
++ * counter_sysfs_add - Adds Counter sysfs attributes to the device structure
++ * @counter:	Pointer to the Counter device structure
++ *
++ * Counter sysfs attributes are created and added to the respective device
++ * structure for later registration to the system. Resource-managed memory
++ * allocation is performed by this function, and this memory should be freed
++ * when no longer needed (automatically by a device_unregister call, or
++ * manually by a devres_release_all call).
++ */
++int counter_sysfs_add(struct counter_device *const counter)
++{
++	struct device *const dev = &counter->dev;
++	const size_t num_groups = counter->num_signals + counter->num_counts + 1;
++	struct counter_attribute_group *cattr_groups;
++	size_t i, j;
++	int err;
++	struct attribute_group *groups;
++	struct counter_attribute *p;
++
++	/* Allocate space for attribute groups (signals, counts, and ext) */
++	cattr_groups = devm_kcalloc(dev, num_groups, sizeof(*cattr_groups),
++				    GFP_KERNEL);
++	if (!cattr_groups)
++		return -ENOMEM;
++
++	/* Initialize attribute lists */
++	for (i = 0; i < num_groups; i++)
++		INIT_LIST_HEAD(&cattr_groups[i].attr_list);
++
++	/* Add Counter device sysfs attributes */
++	err = counter_sysfs_attr_add(counter, cattr_groups);
++	if (err < 0)
++		return err;
++
++	/* Allocate attribute group pointers for association with device */
++	dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups),
++				   GFP_KERNEL);
++	if (!dev->groups)
++		return -ENOMEM;
++
++	/* Allocate space for attribute groups */
++	groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL);
++	if (!groups)
++		return -ENOMEM;
++
++	/* Prepare each group of attributes for association */
++	for (i = 0; i < num_groups; i++) {
++		groups[i].name = cattr_groups[i].name;
++
++		/* Allocate space for attribute pointers */
++		groups[i].attrs = devm_kcalloc(dev,
++					       cattr_groups[i].num_attr + 1,
++					       sizeof(*groups[i].attrs),
++					       GFP_KERNEL);
++		if (!groups[i].attrs)
++			return -ENOMEM;
++
++		/* Add attribute pointers to attribute group */
++		j = 0;
++		list_for_each_entry(p, &cattr_groups[i].attr_list, l)
++			groups[i].attrs[j++] = &p->dev_attr.attr;
++
++		/* Associate attribute group */
++		dev->groups[i] = &groups[i];
++	}
++
++	return 0;
++}
+diff --git a/drivers/counter/counter-sysfs.h b/drivers/counter/counter-sysfs.h
+new file mode 100644
+index 0000000000000..14fe566aca0e0
+--- /dev/null
++++ b/drivers/counter/counter-sysfs.h
+@@ -0,0 +1,13 @@
++/* SPDX-License-Identifier: GPL-2.0 */
++/*
++ * Counter sysfs interface
++ * Copyright (C) 2020 William Breathitt Gray
++ */
++#ifndef _COUNTER_SYSFS_H_
++#define _COUNTER_SYSFS_H_
++
++#include <linux/counter.h>
++
++int counter_sysfs_add(struct counter_device *const counter);
++
++#endif /* _COUNTER_SYSFS_H_ */
+diff --git a/drivers/counter/counter.c b/drivers/counter/counter.c
+deleted file mode 100644
+index de921e8a3f721..0000000000000
+--- a/drivers/counter/counter.c
++++ /dev/null
+@@ -1,1496 +0,0 @@
+-// SPDX-License-Identifier: GPL-2.0
+-/*
+- * Generic Counter interface
+- * Copyright (C) 2018 William Breathitt Gray
+- */
+-#include <linux/counter.h>
+-#include <linux/device.h>
+-#include <linux/err.h>
+-#include <linux/export.h>
+-#include <linux/fs.h>
+-#include <linux/gfp.h>
+-#include <linux/idr.h>
+-#include <linux/init.h>
+-#include <linux/kernel.h>
+-#include <linux/list.h>
+-#include <linux/module.h>
+-#include <linux/printk.h>
+-#include <linux/slab.h>
+-#include <linux/string.h>
+-#include <linux/sysfs.h>
+-#include <linux/types.h>
+-
+-const char *const counter_count_direction_str[2] = {
+-	[COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
+-	[COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
+-};
+-EXPORT_SYMBOL_GPL(counter_count_direction_str);
+-
+-const char *const counter_count_mode_str[4] = {
+-	[COUNTER_COUNT_MODE_NORMAL] = "normal",
+-	[COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
+-	[COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
+-	[COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
+-};
+-EXPORT_SYMBOL_GPL(counter_count_mode_str);
+-
+-ssize_t counter_signal_enum_read(struct counter_device *counter,
+-				 struct counter_signal *signal, void *priv,
+-				 char *buf)
+-{
+-	const struct counter_signal_enum_ext *const e = priv;
+-	int err;
+-	size_t index;
+-
+-	if (!e->get)
+-		return -EINVAL;
+-
+-	err = e->get(counter, signal, &index);
+-	if (err)
+-		return err;
+-
+-	if (index >= e->num_items)
+-		return -EINVAL;
+-
+-	return sprintf(buf, "%s\n", e->items[index]);
+-}
+-EXPORT_SYMBOL_GPL(counter_signal_enum_read);
+-
+-ssize_t counter_signal_enum_write(struct counter_device *counter,
+-				  struct counter_signal *signal, void *priv,
+-				  const char *buf, size_t len)
+-{
+-	const struct counter_signal_enum_ext *const e = priv;
+-	ssize_t index;
+-	int err;
+-
+-	if (!e->set)
+-		return -EINVAL;
+-
+-	index = __sysfs_match_string(e->items, e->num_items, buf);
+-	if (index < 0)
+-		return index;
+-
+-	err = e->set(counter, signal, index);
+-	if (err)
+-		return err;
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_signal_enum_write);
+-
+-ssize_t counter_signal_enum_available_read(struct counter_device *counter,
+-					   struct counter_signal *signal,
+-					   void *priv, char *buf)
+-{
+-	const struct counter_signal_enum_ext *const e = priv;
+-	size_t i;
+-	size_t len = 0;
+-
+-	if (!e->num_items)
+-		return 0;
+-
+-	for (i = 0; i < e->num_items; i++)
+-		len += sprintf(buf + len, "%s\n", e->items[i]);
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_signal_enum_available_read);
+-
+-ssize_t counter_count_enum_read(struct counter_device *counter,
+-				struct counter_count *count, void *priv,
+-				char *buf)
+-{
+-	const struct counter_count_enum_ext *const e = priv;
+-	int err;
+-	size_t index;
+-
+-	if (!e->get)
+-		return -EINVAL;
+-
+-	err = e->get(counter, count, &index);
+-	if (err)
+-		return err;
+-
+-	if (index >= e->num_items)
+-		return -EINVAL;
+-
+-	return sprintf(buf, "%s\n", e->items[index]);
+-}
+-EXPORT_SYMBOL_GPL(counter_count_enum_read);
+-
+-ssize_t counter_count_enum_write(struct counter_device *counter,
+-				 struct counter_count *count, void *priv,
+-				 const char *buf, size_t len)
+-{
+-	const struct counter_count_enum_ext *const e = priv;
+-	ssize_t index;
+-	int err;
+-
+-	if (!e->set)
+-		return -EINVAL;
+-
+-	index = __sysfs_match_string(e->items, e->num_items, buf);
+-	if (index < 0)
+-		return index;
+-
+-	err = e->set(counter, count, index);
+-	if (err)
+-		return err;
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_count_enum_write);
+-
+-ssize_t counter_count_enum_available_read(struct counter_device *counter,
+-					  struct counter_count *count,
+-					  void *priv, char *buf)
+-{
+-	const struct counter_count_enum_ext *const e = priv;
+-	size_t i;
+-	size_t len = 0;
+-
+-	if (!e->num_items)
+-		return 0;
+-
+-	for (i = 0; i < e->num_items; i++)
+-		len += sprintf(buf + len, "%s\n", e->items[i]);
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_count_enum_available_read);
+-
+-ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
+-				 char *buf)
+-{
+-	const struct counter_device_enum_ext *const e = priv;
+-	int err;
+-	size_t index;
+-
+-	if (!e->get)
+-		return -EINVAL;
+-
+-	err = e->get(counter, &index);
+-	if (err)
+-		return err;
+-
+-	if (index >= e->num_items)
+-		return -EINVAL;
+-
+-	return sprintf(buf, "%s\n", e->items[index]);
+-}
+-EXPORT_SYMBOL_GPL(counter_device_enum_read);
+-
+-ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
+-				  const char *buf, size_t len)
+-{
+-	const struct counter_device_enum_ext *const e = priv;
+-	ssize_t index;
+-	int err;
+-
+-	if (!e->set)
+-		return -EINVAL;
+-
+-	index = __sysfs_match_string(e->items, e->num_items, buf);
+-	if (index < 0)
+-		return index;
+-
+-	err = e->set(counter, index);
+-	if (err)
+-		return err;
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_device_enum_write);
+-
+-ssize_t counter_device_enum_available_read(struct counter_device *counter,
+-					   void *priv, char *buf)
+-{
+-	const struct counter_device_enum_ext *const e = priv;
+-	size_t i;
+-	size_t len = 0;
+-
+-	if (!e->num_items)
+-		return 0;
+-
+-	for (i = 0; i < e->num_items; i++)
+-		len += sprintf(buf + len, "%s\n", e->items[i]);
+-
+-	return len;
+-}
+-EXPORT_SYMBOL_GPL(counter_device_enum_available_read);
+-
+-struct counter_attr_parm {
+-	struct counter_device_attr_group *group;
+-	const char *prefix;
+-	const char *name;
+-	ssize_t (*show)(struct device *dev, struct device_attribute *attr,
+-			char *buf);
+-	ssize_t (*store)(struct device *dev, struct device_attribute *attr,
+-			 const char *buf, size_t len);
+-	void *component;
+-};
+-
+-struct counter_device_attr {
+-	struct device_attribute dev_attr;
+-	struct list_head l;
+-	void *component;
+-};
+-
+-static int counter_attribute_create(const struct counter_attr_parm *const parm)
+-{
+-	struct counter_device_attr *counter_attr;
+-	struct device_attribute *dev_attr;
+-	int err;
+-	struct list_head *const attr_list = &parm->group->attr_list;
+-
+-	/* Allocate a Counter device attribute */
+-	counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL);
+-	if (!counter_attr)
+-		return -ENOMEM;
+-	dev_attr = &counter_attr->dev_attr;
+-
+-	sysfs_attr_init(&dev_attr->attr);
+-
+-	/* Configure device attribute */
+-	dev_attr->attr.name = kasprintf(GFP_KERNEL, "%s%s", parm->prefix,
+-					parm->name);
+-	if (!dev_attr->attr.name) {
+-		err = -ENOMEM;
+-		goto err_free_counter_attr;
+-	}
+-	if (parm->show) {
+-		dev_attr->attr.mode |= 0444;
+-		dev_attr->show = parm->show;
+-	}
+-	if (parm->store) {
+-		dev_attr->attr.mode |= 0200;
+-		dev_attr->store = parm->store;
+-	}
+-
+-	/* Store associated Counter component with attribute */
+-	counter_attr->component = parm->component;
+-
+-	/* Keep track of the attribute for later cleanup */
+-	list_add(&counter_attr->l, attr_list);
+-	parm->group->num_attr++;
+-
+-	return 0;
+-
+-err_free_counter_attr:
+-	kfree(counter_attr);
+-	return err;
+-}
+-
+-#define to_counter_attr(_dev_attr) \
+-	container_of(_dev_attr, struct counter_device_attr, dev_attr)
+-
+-struct counter_signal_unit {
+-	struct counter_signal *signal;
+-};
+-
+-static const char *const counter_signal_level_str[] = {
+-	[COUNTER_SIGNAL_LEVEL_LOW] = "low",
+-	[COUNTER_SIGNAL_LEVEL_HIGH] = "high"
+-};
+-
+-static ssize_t counter_signal_show(struct device *dev,
+-				   struct device_attribute *attr, char *buf)
+-{
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_signal_unit *const component = devattr->component;
+-	struct counter_signal *const signal = component->signal;
+-	int err;
+-	enum counter_signal_level level;
+-
+-	err = counter->ops->signal_read(counter, signal, &level);
+-	if (err)
+-		return err;
+-
+-	return sprintf(buf, "%s\n", counter_signal_level_str[level]);
+-}
+-
+-struct counter_name_unit {
+-	const char *name;
+-};
+-
+-static ssize_t counter_device_attr_name_show(struct device *dev,
+-					     struct device_attribute *attr,
+-					     char *buf)
+-{
+-	const struct counter_name_unit *const comp = to_counter_attr(attr)->component;
+-
+-	return sprintf(buf, "%s\n", comp->name);
+-}
+-
+-static int counter_name_attribute_create(
+-	struct counter_device_attr_group *const group,
+-	const char *const name)
+-{
+-	struct counter_name_unit *name_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Skip if no name */
+-	if (!name)
+-		return 0;
+-
+-	/* Allocate name attribute component */
+-	name_comp = kmalloc(sizeof(*name_comp), GFP_KERNEL);
+-	if (!name_comp)
+-		return -ENOMEM;
+-	name_comp->name = name;
+-
+-	/* Allocate Signal name attribute */
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = "name";
+-	parm.show = counter_device_attr_name_show;
+-	parm.store = NULL;
+-	parm.component = name_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err)
+-		goto err_free_name_comp;
+-
+-	return 0;
+-
+-err_free_name_comp:
+-	kfree(name_comp);
+-	return err;
+-}
+-
+-struct counter_signal_ext_unit {
+-	struct counter_signal *signal;
+-	const struct counter_signal_ext *ext;
+-};
+-
+-static ssize_t counter_signal_ext_show(struct device *dev,
+-				       struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_signal_ext_unit *const comp = devattr->component;
+-	const struct counter_signal_ext *const ext = comp->ext;
+-
+-	return ext->read(dev_get_drvdata(dev), comp->signal, ext->priv, buf);
+-}
+-
+-static ssize_t counter_signal_ext_store(struct device *dev,
+-					struct device_attribute *attr,
+-					const char *buf, size_t len)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_signal_ext_unit *const comp = devattr->component;
+-	const struct counter_signal_ext *const ext = comp->ext;
+-
+-	return ext->write(dev_get_drvdata(dev), comp->signal, ext->priv, buf,
+-		len);
+-}
+-
+-static void counter_device_attr_list_free(struct list_head *attr_list)
+-{
+-	struct counter_device_attr *p, *n;
+-
+-	list_for_each_entry_safe(p, n, attr_list, l) {
+-		/* free attribute name and associated component memory */
+-		kfree(p->dev_attr.attr.name);
+-		kfree(p->component);
+-		list_del(&p->l);
+-		kfree(p);
+-	}
+-}
+-
+-static int counter_signal_ext_register(
+-	struct counter_device_attr_group *const group,
+-	struct counter_signal *const signal)
+-{
+-	const size_t num_ext = signal->num_ext;
+-	size_t i;
+-	const struct counter_signal_ext *ext;
+-	struct counter_signal_ext_unit *signal_ext_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Create an attribute for each extension */
+-	for (i = 0 ; i < num_ext; i++) {
+-		ext = signal->ext + i;
+-
+-		/* Allocate signal_ext attribute component */
+-		signal_ext_comp = kmalloc(sizeof(*signal_ext_comp), GFP_KERNEL);
+-		if (!signal_ext_comp) {
+-			err = -ENOMEM;
+-			goto err_free_attr_list;
+-		}
+-		signal_ext_comp->signal = signal;
+-		signal_ext_comp->ext = ext;
+-
+-		/* Allocate a Counter device attribute */
+-		parm.group = group;
+-		parm.prefix = "";
+-		parm.name = ext->name;
+-		parm.show = (ext->read) ? counter_signal_ext_show : NULL;
+-		parm.store = (ext->write) ? counter_signal_ext_store : NULL;
+-		parm.component = signal_ext_comp;
+-		err = counter_attribute_create(&parm);
+-		if (err) {
+-			kfree(signal_ext_comp);
+-			goto err_free_attr_list;
+-		}
+-	}
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-static int counter_signal_attributes_create(
+-	struct counter_device_attr_group *const group,
+-	const struct counter_device *const counter,
+-	struct counter_signal *const signal)
+-{
+-	struct counter_signal_unit *signal_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Allocate Signal attribute component */
+-	signal_comp = kmalloc(sizeof(*signal_comp), GFP_KERNEL);
+-	if (!signal_comp)
+-		return -ENOMEM;
+-	signal_comp->signal = signal;
+-
+-	/* Create main Signal attribute */
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = "signal";
+-	parm.show = (counter->ops->signal_read) ? counter_signal_show : NULL;
+-	parm.store = NULL;
+-	parm.component = signal_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err) {
+-		kfree(signal_comp);
+-		return err;
+-	}
+-
+-	/* Create Signal name attribute */
+-	err = counter_name_attribute_create(group, signal->name);
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	/* Register Signal extension attributes */
+-	err = counter_signal_ext_register(group, signal);
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-static int counter_signals_register(
+-	struct counter_device_attr_group *const groups_list,
+-	const struct counter_device *const counter)
+-{
+-	const size_t num_signals = counter->num_signals;
+-	size_t i;
+-	struct counter_signal *signal;
+-	const char *name;
+-	int err;
+-
+-	/* Register each Signal */
+-	for (i = 0; i < num_signals; i++) {
+-		signal = counter->signals + i;
+-
+-		/* Generate Signal attribute directory name */
+-		name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
+-		if (!name) {
+-			err = -ENOMEM;
+-			goto err_free_attr_groups;
+-		}
+-		groups_list[i].attr_group.name = name;
+-
+-		/* Create all attributes associated with Signal */
+-		err = counter_signal_attributes_create(groups_list + i, counter,
+-						       signal);
+-		if (err)
+-			goto err_free_attr_groups;
+-	}
+-
+-	return 0;
+-
+-err_free_attr_groups:
+-	do {
+-		kfree(groups_list[i].attr_group.name);
+-		counter_device_attr_list_free(&groups_list[i].attr_list);
+-	} while (i--);
+-	return err;
+-}
+-
+-static const char *const counter_synapse_action_str[] = {
+-	[COUNTER_SYNAPSE_ACTION_NONE] = "none",
+-	[COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
+-	[COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
+-	[COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
+-};
+-
+-struct counter_action_unit {
+-	struct counter_synapse *synapse;
+-	struct counter_count *count;
+-};
+-
+-static ssize_t counter_action_show(struct device *dev,
+-				   struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	int err;
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	const struct counter_action_unit *const component = devattr->component;
+-	struct counter_count *const count = component->count;
+-	struct counter_synapse *const synapse = component->synapse;
+-	size_t action_index;
+-	enum counter_synapse_action action;
+-
+-	err = counter->ops->action_get(counter, count, synapse, &action_index);
+-	if (err)
+-		return err;
+-
+-	synapse->action = action_index;
+-
+-	action = synapse->actions_list[action_index];
+-	return sprintf(buf, "%s\n", counter_synapse_action_str[action]);
+-}
+-
+-static ssize_t counter_action_store(struct device *dev,
+-				    struct device_attribute *attr,
+-				    const char *buf, size_t len)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_action_unit *const component = devattr->component;
+-	struct counter_synapse *const synapse = component->synapse;
+-	size_t action_index;
+-	const size_t num_actions = synapse->num_actions;
+-	enum counter_synapse_action action;
+-	int err;
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	struct counter_count *const count = component->count;
+-
+-	/* Find requested action mode */
+-	for (action_index = 0; action_index < num_actions; action_index++) {
+-		action = synapse->actions_list[action_index];
+-		if (sysfs_streq(buf, counter_synapse_action_str[action]))
+-			break;
+-	}
+-	/* If requested action mode not found */
+-	if (action_index >= num_actions)
+-		return -EINVAL;
+-
+-	err = counter->ops->action_set(counter, count, synapse, action_index);
+-	if (err)
+-		return err;
+-
+-	synapse->action = action_index;
+-
+-	return len;
+-}
+-
+-struct counter_action_avail_unit {
+-	const enum counter_synapse_action *actions_list;
+-	size_t num_actions;
+-};
+-
+-static ssize_t counter_synapse_action_available_show(struct device *dev,
+-	struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_action_avail_unit *const component = devattr->component;
+-	size_t i;
+-	enum counter_synapse_action action;
+-	ssize_t len = 0;
+-
+-	for (i = 0; i < component->num_actions; i++) {
+-		action = component->actions_list[i];
+-		len += sprintf(buf + len, "%s\n",
+-			       counter_synapse_action_str[action]);
+-	}
+-
+-	return len;
+-}
+-
+-static int counter_synapses_register(
+-	struct counter_device_attr_group *const group,
+-	const struct counter_device *const counter,
+-	struct counter_count *const count, const char *const count_attr_name)
+-{
+-	size_t i;
+-	struct counter_synapse *synapse;
+-	const char *prefix;
+-	struct counter_action_unit *action_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-	struct counter_action_avail_unit *avail_comp;
+-
+-	/* Register each Synapse */
+-	for (i = 0; i < count->num_synapses; i++) {
+-		synapse = count->synapses + i;
+-
+-		/* Generate attribute prefix */
+-		prefix = kasprintf(GFP_KERNEL, "signal%d_",
+-				   synapse->signal->id);
+-		if (!prefix) {
+-			err = -ENOMEM;
+-			goto err_free_attr_list;
+-		}
+-
+-		/* Allocate action attribute component */
+-		action_comp = kmalloc(sizeof(*action_comp), GFP_KERNEL);
+-		if (!action_comp) {
+-			err = -ENOMEM;
+-			goto err_free_prefix;
+-		}
+-		action_comp->synapse = synapse;
+-		action_comp->count = count;
+-
+-		/* Create action attribute */
+-		parm.group = group;
+-		parm.prefix = prefix;
+-		parm.name = "action";
+-		parm.show = (counter->ops->action_get) ? counter_action_show : NULL;
+-		parm.store = (counter->ops->action_set) ? counter_action_store : NULL;
+-		parm.component = action_comp;
+-		err = counter_attribute_create(&parm);
+-		if (err) {
+-			kfree(action_comp);
+-			goto err_free_prefix;
+-		}
+-
+-		/* Allocate action available attribute component */
+-		avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
+-		if (!avail_comp) {
+-			err = -ENOMEM;
+-			goto err_free_prefix;
+-		}
+-		avail_comp->actions_list = synapse->actions_list;
+-		avail_comp->num_actions = synapse->num_actions;
+-
+-		/* Create action_available attribute */
+-		parm.group = group;
+-		parm.prefix = prefix;
+-		parm.name = "action_available";
+-		parm.show = counter_synapse_action_available_show;
+-		parm.store = NULL;
+-		parm.component = avail_comp;
+-		err = counter_attribute_create(&parm);
+-		if (err) {
+-			kfree(avail_comp);
+-			goto err_free_prefix;
+-		}
+-
+-		kfree(prefix);
+-	}
+-
+-	return 0;
+-
+-err_free_prefix:
+-	kfree(prefix);
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-struct counter_count_unit {
+-	struct counter_count *count;
+-};
+-
+-static ssize_t counter_count_show(struct device *dev,
+-				  struct device_attribute *attr,
+-				  char *buf)
+-{
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_unit *const component = devattr->component;
+-	struct counter_count *const count = component->count;
+-	int err;
+-	unsigned long val;
+-
+-	err = counter->ops->count_read(counter, count, &val);
+-	if (err)
+-		return err;
+-
+-	return sprintf(buf, "%lu\n", val);
+-}
+-
+-static ssize_t counter_count_store(struct device *dev,
+-				   struct device_attribute *attr,
+-				   const char *buf, size_t len)
+-{
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_unit *const component = devattr->component;
+-	struct counter_count *const count = component->count;
+-	int err;
+-	unsigned long val;
+-
+-	err = kstrtoul(buf, 0, &val);
+-	if (err)
+-		return err;
+-
+-	err = counter->ops->count_write(counter, count, val);
+-	if (err)
+-		return err;
+-
+-	return len;
+-}
+-
+-static const char *const counter_function_str[] = {
+-	[COUNTER_FUNCTION_INCREASE] = "increase",
+-	[COUNTER_FUNCTION_DECREASE] = "decrease",
+-	[COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
+-	[COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
+-	[COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
+-	[COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
+-	[COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
+-	[COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"
+-};
+-
+-static ssize_t counter_function_show(struct device *dev,
+-				     struct device_attribute *attr, char *buf)
+-{
+-	int err;
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_unit *const component = devattr->component;
+-	struct counter_count *const count = component->count;
+-	size_t func_index;
+-	enum counter_function function;
+-
+-	err = counter->ops->function_get(counter, count, &func_index);
+-	if (err)
+-		return err;
+-
+-	count->function = func_index;
+-
+-	function = count->functions_list[func_index];
+-	return sprintf(buf, "%s\n", counter_function_str[function]);
+-}
+-
+-static ssize_t counter_function_store(struct device *dev,
+-				      struct device_attribute *attr,
+-				      const char *buf, size_t len)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_unit *const component = devattr->component;
+-	struct counter_count *const count = component->count;
+-	const size_t num_functions = count->num_functions;
+-	size_t func_index;
+-	enum counter_function function;
+-	int err;
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-
+-	/* Find requested Count function mode */
+-	for (func_index = 0; func_index < num_functions; func_index++) {
+-		function = count->functions_list[func_index];
+-		if (sysfs_streq(buf, counter_function_str[function]))
+-			break;
+-	}
+-	/* Return error if requested Count function mode not found */
+-	if (func_index >= num_functions)
+-		return -EINVAL;
+-
+-	err = counter->ops->function_set(counter, count, func_index);
+-	if (err)
+-		return err;
+-
+-	count->function = func_index;
+-
+-	return len;
+-}
+-
+-struct counter_count_ext_unit {
+-	struct counter_count *count;
+-	const struct counter_count_ext *ext;
+-};
+-
+-static ssize_t counter_count_ext_show(struct device *dev,
+-				      struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_ext_unit *const comp = devattr->component;
+-	const struct counter_count_ext *const ext = comp->ext;
+-
+-	return ext->read(dev_get_drvdata(dev), comp->count, ext->priv, buf);
+-}
+-
+-static ssize_t counter_count_ext_store(struct device *dev,
+-				       struct device_attribute *attr,
+-				       const char *buf, size_t len)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_count_ext_unit *const comp = devattr->component;
+-	const struct counter_count_ext *const ext = comp->ext;
+-
+-	return ext->write(dev_get_drvdata(dev), comp->count, ext->priv, buf,
+-		len);
+-}
+-
+-static int counter_count_ext_register(
+-	struct counter_device_attr_group *const group,
+-	struct counter_count *const count)
+-{
+-	size_t i;
+-	const struct counter_count_ext *ext;
+-	struct counter_count_ext_unit *count_ext_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Create an attribute for each extension */
+-	for (i = 0 ; i < count->num_ext; i++) {
+-		ext = count->ext + i;
+-
+-		/* Allocate count_ext attribute component */
+-		count_ext_comp = kmalloc(sizeof(*count_ext_comp), GFP_KERNEL);
+-		if (!count_ext_comp) {
+-			err = -ENOMEM;
+-			goto err_free_attr_list;
+-		}
+-		count_ext_comp->count = count;
+-		count_ext_comp->ext = ext;
+-
+-		/* Allocate count_ext attribute */
+-		parm.group = group;
+-		parm.prefix = "";
+-		parm.name = ext->name;
+-		parm.show = (ext->read) ? counter_count_ext_show : NULL;
+-		parm.store = (ext->write) ? counter_count_ext_store : NULL;
+-		parm.component = count_ext_comp;
+-		err = counter_attribute_create(&parm);
+-		if (err) {
+-			kfree(count_ext_comp);
+-			goto err_free_attr_list;
+-		}
+-	}
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-struct counter_func_avail_unit {
+-	const enum counter_function *functions_list;
+-	size_t num_functions;
+-};
+-
+-static ssize_t counter_function_available_show(struct device *dev,
+-	struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_func_avail_unit *const component = devattr->component;
+-	const enum counter_function *const func_list = component->functions_list;
+-	const size_t num_functions = component->num_functions;
+-	size_t i;
+-	enum counter_function function;
+-	ssize_t len = 0;
+-
+-	for (i = 0; i < num_functions; i++) {
+-		function = func_list[i];
+-		len += sprintf(buf + len, "%s\n",
+-			       counter_function_str[function]);
+-	}
+-
+-	return len;
+-}
+-
+-static int counter_count_attributes_create(
+-	struct counter_device_attr_group *const group,
+-	const struct counter_device *const counter,
+-	struct counter_count *const count)
+-{
+-	struct counter_count_unit *count_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-	struct counter_count_unit *func_comp;
+-	struct counter_func_avail_unit *avail_comp;
+-
+-	/* Allocate count attribute component */
+-	count_comp = kmalloc(sizeof(*count_comp), GFP_KERNEL);
+-	if (!count_comp)
+-		return -ENOMEM;
+-	count_comp->count = count;
+-
+-	/* Create main Count attribute */
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = "count";
+-	parm.show = (counter->ops->count_read) ? counter_count_show : NULL;
+-	parm.store = (counter->ops->count_write) ? counter_count_store : NULL;
+-	parm.component = count_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err) {
+-		kfree(count_comp);
+-		return err;
+-	}
+-
+-	/* Allocate function attribute component */
+-	func_comp = kmalloc(sizeof(*func_comp), GFP_KERNEL);
+-	if (!func_comp) {
+-		err = -ENOMEM;
+-		goto err_free_attr_list;
+-	}
+-	func_comp->count = count;
+-
+-	/* Create Count function attribute */
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = "function";
+-	parm.show = (counter->ops->function_get) ? counter_function_show : NULL;
+-	parm.store = (counter->ops->function_set) ? counter_function_store : NULL;
+-	parm.component = func_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err) {
+-		kfree(func_comp);
+-		goto err_free_attr_list;
+-	}
+-
+-	/* Allocate function available attribute component */
+-	avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
+-	if (!avail_comp) {
+-		err = -ENOMEM;
+-		goto err_free_attr_list;
+-	}
+-	avail_comp->functions_list = count->functions_list;
+-	avail_comp->num_functions = count->num_functions;
+-
+-	/* Create Count function_available attribute */
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = "function_available";
+-	parm.show = counter_function_available_show;
+-	parm.store = NULL;
+-	parm.component = avail_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err) {
+-		kfree(avail_comp);
+-		goto err_free_attr_list;
+-	}
+-
+-	/* Create Count name attribute */
+-	err = counter_name_attribute_create(group, count->name);
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	/* Register Count extension attributes */
+-	err = counter_count_ext_register(group, count);
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-static int counter_counts_register(
+-	struct counter_device_attr_group *const groups_list,
+-	const struct counter_device *const counter)
+-{
+-	size_t i;
+-	struct counter_count *count;
+-	const char *name;
+-	int err;
+-
+-	/* Register each Count */
+-	for (i = 0; i < counter->num_counts; i++) {
+-		count = counter->counts + i;
+-
+-		/* Generate Count attribute directory name */
+-		name = kasprintf(GFP_KERNEL, "count%d", count->id);
+-		if (!name) {
+-			err = -ENOMEM;
+-			goto err_free_attr_groups;
+-		}
+-		groups_list[i].attr_group.name = name;
+-
+-		/* Register the Synapses associated with each Count */
+-		err = counter_synapses_register(groups_list + i, counter, count,
+-						name);
+-		if (err)
+-			goto err_free_attr_groups;
+-
+-		/* Create all attributes associated with Count */
+-		err = counter_count_attributes_create(groups_list + i, counter,
+-						      count);
+-		if (err)
+-			goto err_free_attr_groups;
+-	}
+-
+-	return 0;
+-
+-err_free_attr_groups:
+-	do {
+-		kfree(groups_list[i].attr_group.name);
+-		counter_device_attr_list_free(&groups_list[i].attr_list);
+-	} while (i--);
+-	return err;
+-}
+-
+-struct counter_size_unit {
+-	size_t size;
+-};
+-
+-static ssize_t counter_device_attr_size_show(struct device *dev,
+-					     struct device_attribute *attr,
+-					     char *buf)
+-{
+-	const struct counter_size_unit *const comp = to_counter_attr(attr)->component;
+-
+-	return sprintf(buf, "%zu\n", comp->size);
+-}
+-
+-static int counter_size_attribute_create(
+-	struct counter_device_attr_group *const group,
+-	const size_t size, const char *const name)
+-{
+-	struct counter_size_unit *size_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Allocate size attribute component */
+-	size_comp = kmalloc(sizeof(*size_comp), GFP_KERNEL);
+-	if (!size_comp)
+-		return -ENOMEM;
+-	size_comp->size = size;
+-
+-	parm.group = group;
+-	parm.prefix = "";
+-	parm.name = name;
+-	parm.show = counter_device_attr_size_show;
+-	parm.store = NULL;
+-	parm.component = size_comp;
+-	err = counter_attribute_create(&parm);
+-	if (err)
+-		goto err_free_size_comp;
+-
+-	return 0;
+-
+-err_free_size_comp:
+-	kfree(size_comp);
+-	return err;
+-}
+-
+-struct counter_ext_unit {
+-	const struct counter_device_ext *ext;
+-};
+-
+-static ssize_t counter_device_ext_show(struct device *dev,
+-				       struct device_attribute *attr, char *buf)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_ext_unit *const component = devattr->component;
+-	const struct counter_device_ext *const ext = component->ext;
+-
+-	return ext->read(dev_get_drvdata(dev), ext->priv, buf);
+-}
+-
+-static ssize_t counter_device_ext_store(struct device *dev,
+-					struct device_attribute *attr,
+-					const char *buf, size_t len)
+-{
+-	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+-	const struct counter_ext_unit *const component = devattr->component;
+-	const struct counter_device_ext *const ext = component->ext;
+-
+-	return ext->write(dev_get_drvdata(dev), ext->priv, buf, len);
+-}
+-
+-static int counter_device_ext_register(
+-	struct counter_device_attr_group *const group,
+-	struct counter_device *const counter)
+-{
+-	size_t i;
+-	struct counter_ext_unit *ext_comp;
+-	struct counter_attr_parm parm;
+-	int err;
+-
+-	/* Create an attribute for each extension */
+-	for (i = 0 ; i < counter->num_ext; i++) {
+-		/* Allocate extension attribute component */
+-		ext_comp = kmalloc(sizeof(*ext_comp), GFP_KERNEL);
+-		if (!ext_comp) {
+-			err = -ENOMEM;
+-			goto err_free_attr_list;
+-		}
+-
+-		ext_comp->ext = counter->ext + i;
+-
+-		/* Allocate extension attribute */
+-		parm.group = group;
+-		parm.prefix = "";
+-		parm.name = counter->ext[i].name;
+-		parm.show = (counter->ext[i].read) ? counter_device_ext_show : NULL;
+-		parm.store = (counter->ext[i].write) ? counter_device_ext_store : NULL;
+-		parm.component = ext_comp;
+-		err = counter_attribute_create(&parm);
+-		if (err) {
+-			kfree(ext_comp);
+-			goto err_free_attr_list;
+-		}
+-	}
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-static int counter_global_attr_register(
+-	struct counter_device_attr_group *const group,
+-	struct counter_device *const counter)
+-{
+-	int err;
+-
+-	/* Create name attribute */
+-	err = counter_name_attribute_create(group, counter->name);
+-	if (err)
+-		return err;
+-
+-	/* Create num_counts attribute */
+-	err = counter_size_attribute_create(group, counter->num_counts,
+-					    "num_counts");
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	/* Create num_signals attribute */
+-	err = counter_size_attribute_create(group, counter->num_signals,
+-					    "num_signals");
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	/* Register Counter device extension attributes */
+-	err = counter_device_ext_register(group, counter);
+-	if (err)
+-		goto err_free_attr_list;
+-
+-	return 0;
+-
+-err_free_attr_list:
+-	counter_device_attr_list_free(&group->attr_list);
+-	return err;
+-}
+-
+-static void counter_device_groups_list_free(
+-	struct counter_device_attr_group *const groups_list,
+-	const size_t num_groups)
+-{
+-	struct counter_device_attr_group *group;
+-	size_t i;
+-
+-	/* loop through all attribute groups (signals, counts, global, etc.) */
+-	for (i = 0; i < num_groups; i++) {
+-		group = groups_list + i;
+-
+-		/* free all attribute group and associated attributes memory */
+-		kfree(group->attr_group.name);
+-		kfree(group->attr_group.attrs);
+-		counter_device_attr_list_free(&group->attr_list);
+-	}
+-
+-	kfree(groups_list);
+-}
+-
+-static int counter_device_groups_list_prepare(
+-	struct counter_device *const counter)
+-{
+-	const size_t total_num_groups =
+-		counter->num_signals + counter->num_counts + 1;
+-	struct counter_device_attr_group *groups_list;
+-	size_t i;
+-	int err;
+-	size_t num_groups = 0;
+-
+-	/* Allocate space for attribute groups (signals, counts, and ext) */
+-	groups_list = kcalloc(total_num_groups, sizeof(*groups_list),
+-			      GFP_KERNEL);
+-	if (!groups_list)
+-		return -ENOMEM;
+-
+-	/* Initialize attribute lists */
+-	for (i = 0; i < total_num_groups; i++)
+-		INIT_LIST_HEAD(&groups_list[i].attr_list);
+-
+-	/* Register Signals */
+-	err = counter_signals_register(groups_list, counter);
+-	if (err)
+-		goto err_free_groups_list;
+-	num_groups += counter->num_signals;
+-
+-	/* Register Counts and respective Synapses */
+-	err = counter_counts_register(groups_list + num_groups, counter);
+-	if (err)
+-		goto err_free_groups_list;
+-	num_groups += counter->num_counts;
+-
+-	/* Register Counter global attributes */
+-	err = counter_global_attr_register(groups_list + num_groups, counter);
+-	if (err)
+-		goto err_free_groups_list;
+-	num_groups++;
+-
+-	/* Store groups_list in device_state */
+-	counter->device_state->groups_list = groups_list;
+-	counter->device_state->num_groups = num_groups;
+-
+-	return 0;
+-
+-err_free_groups_list:
+-	counter_device_groups_list_free(groups_list, num_groups);
+-	return err;
+-}
+-
+-static int counter_device_groups_prepare(
+-	struct counter_device_state *const device_state)
+-{
+-	size_t i, j;
+-	struct counter_device_attr_group *group;
+-	int err;
+-	struct counter_device_attr *p;
+-
+-	/* Allocate attribute groups for association with device */
+-	device_state->groups = kcalloc(device_state->num_groups + 1,
+-				       sizeof(*device_state->groups),
+-				       GFP_KERNEL);
+-	if (!device_state->groups)
+-		return -ENOMEM;
+-
+-	/* Prepare each group of attributes for association */
+-	for (i = 0; i < device_state->num_groups; i++) {
+-		group = device_state->groups_list + i;
+-
+-		/* Allocate space for attribute pointers in attribute group */
+-		group->attr_group.attrs = kcalloc(group->num_attr + 1,
+-			sizeof(*group->attr_group.attrs), GFP_KERNEL);
+-		if (!group->attr_group.attrs) {
+-			err = -ENOMEM;
+-			goto err_free_groups;
+-		}
+-
+-		/* Add attribute pointers to attribute group */
+-		j = 0;
+-		list_for_each_entry(p, &group->attr_list, l)
+-			group->attr_group.attrs[j++] = &p->dev_attr.attr;
+-
+-		/* Group attributes in attribute group */
+-		device_state->groups[i] = &group->attr_group;
+-	}
+-	/* Associate attributes with device */
+-	device_state->dev.groups = device_state->groups;
+-
+-	return 0;
+-
+-err_free_groups:
+-	do {
+-		group = device_state->groups_list + i;
+-		kfree(group->attr_group.attrs);
+-		group->attr_group.attrs = NULL;
+-	} while (i--);
+-	kfree(device_state->groups);
+-	return err;
+-}
+-
+-/* Provides a unique ID for each counter device */
+-static DEFINE_IDA(counter_ida);
+-
+-static void counter_device_release(struct device *dev)
+-{
+-	struct counter_device *const counter = dev_get_drvdata(dev);
+-	struct counter_device_state *const device_state = counter->device_state;
+-
+-	kfree(device_state->groups);
+-	counter_device_groups_list_free(device_state->groups_list,
+-					device_state->num_groups);
+-	ida_simple_remove(&counter_ida, device_state->id);
+-	kfree(device_state);
+-}
+-
+-static struct device_type counter_device_type = {
+-	.name = "counter_device",
+-	.release = counter_device_release
+-};
+-
+-static struct bus_type counter_bus_type = {
+-	.name = "counter"
+-};
+-
+-/**
+- * counter_register - register Counter to the system
+- * @counter:	pointer to Counter to register
+- *
+- * This function registers a Counter to the system. A sysfs "counter" directory
+- * will be created and populated with sysfs attributes correlating with the
+- * Counter Signals, Synapses, and Counts respectively.
+- */
+-int counter_register(struct counter_device *const counter)
+-{
+-	struct counter_device_state *device_state;
+-	int err;
+-
+-	/* Allocate internal state container for Counter device */
+-	device_state = kzalloc(sizeof(*device_state), GFP_KERNEL);
+-	if (!device_state)
+-		return -ENOMEM;
+-	counter->device_state = device_state;
+-
+-	/* Acquire unique ID */
+-	device_state->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+-	if (device_state->id < 0) {
+-		err = device_state->id;
+-		goto err_free_device_state;
+-	}
+-
+-	/* Configure device structure for Counter */
+-	device_state->dev.type = &counter_device_type;
+-	device_state->dev.bus = &counter_bus_type;
+-	if (counter->parent) {
+-		device_state->dev.parent = counter->parent;
+-		device_state->dev.of_node = counter->parent->of_node;
+-	}
+-	dev_set_name(&device_state->dev, "counter%d", device_state->id);
+-	device_initialize(&device_state->dev);
+-	dev_set_drvdata(&device_state->dev, counter);
+-
+-	/* Prepare device attributes */
+-	err = counter_device_groups_list_prepare(counter);
+-	if (err)
+-		goto err_free_id;
+-
+-	/* Organize device attributes to groups and match to device */
+-	err = counter_device_groups_prepare(device_state);
+-	if (err)
+-		goto err_free_groups_list;
+-
+-	/* Add device to system */
+-	err = device_add(&device_state->dev);
+-	if (err)
+-		goto err_free_groups;
+-
+-	return 0;
+-
+-err_free_groups:
+-	kfree(device_state->groups);
+-err_free_groups_list:
+-	counter_device_groups_list_free(device_state->groups_list,
+-					device_state->num_groups);
+-err_free_id:
+-	ida_simple_remove(&counter_ida, device_state->id);
+-err_free_device_state:
+-	kfree(device_state);
+-	return err;
+-}
+-EXPORT_SYMBOL_GPL(counter_register);
+-
+-/**
+- * counter_unregister - unregister Counter from the system
+- * @counter:	pointer to Counter to unregister
+- *
+- * The Counter is unregistered from the system; all allocated memory is freed.
+- */
+-void counter_unregister(struct counter_device *const counter)
+-{
+-	if (counter)
+-		device_del(&counter->device_state->dev);
+-}
+-EXPORT_SYMBOL_GPL(counter_unregister);
+-
+-static void devm_counter_unreg(struct device *dev, void *res)
+-{
+-	counter_unregister(*(struct counter_device **)res);
+-}
+-
+-/**
+- * devm_counter_register - Resource-managed counter_register
+- * @dev:	device to allocate counter_device for
+- * @counter:	pointer to Counter to register
+- *
+- * Managed counter_register. The Counter registered with this function is
+- * automatically unregistered on driver detach. This function calls
+- * counter_register internally. Refer to that function for more information.
+- *
+- * If an Counter registered with this function needs to be unregistered
+- * separately, devm_counter_unregister must be used.
+- *
+- * RETURNS:
+- * 0 on success, negative error number on failure.
+- */
+-int devm_counter_register(struct device *dev,
+-			  struct counter_device *const counter)
+-{
+-	struct counter_device **ptr;
+-	int ret;
+-
+-	ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
+-	if (!ptr)
+-		return -ENOMEM;
+-
+-	ret = counter_register(counter);
+-	if (!ret) {
+-		*ptr = counter;
+-		devres_add(dev, ptr);
+-	} else {
+-		devres_free(ptr);
+-	}
+-
+-	return ret;
+-}
+-EXPORT_SYMBOL_GPL(devm_counter_register);
+-
+-static int devm_counter_match(struct device *dev, void *res, void *data)
+-{
+-	struct counter_device **r = res;
+-
+-	if (!r || !*r) {
+-		WARN_ON(!r || !*r);
+-		return 0;
+-	}
+-
+-	return *r == data;
+-}
+-
+-/**
+- * devm_counter_unregister - Resource-managed counter_unregister
+- * @dev:	device this counter_device belongs to
+- * @counter:	pointer to Counter associated with the device
+- *
+- * Unregister Counter registered with devm_counter_register.
+- */
+-void devm_counter_unregister(struct device *dev,
+-			     struct counter_device *const counter)
+-{
+-	int rc;
+-
+-	rc = devres_release(dev, devm_counter_unreg, devm_counter_match,
+-			    counter);
+-	WARN_ON(rc);
+-}
+-EXPORT_SYMBOL_GPL(devm_counter_unregister);
+-
+-static int __init counter_init(void)
+-{
+-	return bus_register(&counter_bus_type);
+-}
+-
+-static void __exit counter_exit(void)
+-{
+-	bus_unregister(&counter_bus_type);
+-}
+-
+-subsys_initcall(counter_init);
+-module_exit(counter_exit);
+-
+-MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
+-MODULE_DESCRIPTION("Generic Counter interface");
+-MODULE_LICENSE("GPL v2");
+diff --git a/drivers/counter/ftm-quaddec.c b/drivers/counter/ftm-quaddec.c
+index 53c15f84909b9..5ef0478709cd8 100644
+--- a/drivers/counter/ftm-quaddec.c
++++ b/drivers/counter/ftm-quaddec.c
+@@ -14,6 +14,7 @@
+ #include <linux/mutex.h>
+ #include <linux/counter.h>
+ #include <linux/bitfield.h>
++#include <linux/types.h>
+ 
+ #define FTM_FIELD_UPDATE(ftm, offset, mask, val)			\
+ 	({								\
+@@ -115,8 +116,7 @@ static void ftm_quaddec_disable(void *ftm)
+ }
+ 
+ static int ftm_quaddec_get_prescaler(struct counter_device *counter,
+-				     struct counter_count *count,
+-				     size_t *cnt_mode)
++				     struct counter_count *count, u32 *cnt_mode)
+ {
+ 	struct ftm_quaddec *ftm = counter->priv;
+ 	uint32_t scflags;
+@@ -129,8 +129,7 @@ static int ftm_quaddec_get_prescaler(struct counter_device *counter,
+ }
+ 
+ static int ftm_quaddec_set_prescaler(struct counter_device *counter,
+-				     struct counter_count *count,
+-				     size_t cnt_mode)
++				     struct counter_count *count, u32 cnt_mode)
+ {
+ 	struct ftm_quaddec *ftm = counter->priv;
+ 
+@@ -151,33 +150,17 @@ static const char * const ftm_quaddec_prescaler[] = {
+ 	"1", "2", "4", "8", "16", "32", "64", "128"
+ };
+ 
+-static struct counter_count_enum_ext ftm_quaddec_prescaler_enum = {
+-	.items = ftm_quaddec_prescaler,
+-	.num_items = ARRAY_SIZE(ftm_quaddec_prescaler),
+-	.get = ftm_quaddec_get_prescaler,
+-	.set = ftm_quaddec_set_prescaler
+-};
+-
+-enum ftm_quaddec_synapse_action {
+-	FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES,
+-};
+-
+ static const enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
+-	[FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES] =
+ 	COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+ };
+ 
+-enum ftm_quaddec_count_function {
+-	FTM_QUADDEC_COUNT_ENCODER_MODE_1,
+-};
+-
+ static const enum counter_function ftm_quaddec_count_functions[] = {
+-	[FTM_QUADDEC_COUNT_ENCODER_MODE_1] = COUNTER_FUNCTION_QUADRATURE_X4
++	COUNTER_FUNCTION_QUADRATURE_X4
+ };
+ 
+ static int ftm_quaddec_count_read(struct counter_device *counter,
+ 				  struct counter_count *count,
+-				  unsigned long *val)
++				  u64 *val)
+ {
+ 	struct ftm_quaddec *const ftm = counter->priv;
+ 	uint32_t cntval;
+@@ -191,7 +174,7 @@ static int ftm_quaddec_count_read(struct counter_device *counter,
+ 
+ static int ftm_quaddec_count_write(struct counter_device *counter,
+ 				   struct counter_count *count,
+-				   const unsigned long val)
++				   const u64 val)
+ {
+ 	struct ftm_quaddec *const ftm = counter->priv;
+ 
+@@ -205,21 +188,21 @@ static int ftm_quaddec_count_write(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static int ftm_quaddec_count_function_get(struct counter_device *counter,
+-					  struct counter_count *count,
+-					  size_t *function)
++static int ftm_quaddec_count_function_read(struct counter_device *counter,
++					   struct counter_count *count,
++					   enum counter_function *function)
+ {
+-	*function = FTM_QUADDEC_COUNT_ENCODER_MODE_1;
++	*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 
+ 	return 0;
+ }
+ 
+-static int ftm_quaddec_action_get(struct counter_device *counter,
+-				  struct counter_count *count,
+-				  struct counter_synapse *synapse,
+-				  size_t *action)
++static int ftm_quaddec_action_read(struct counter_device *counter,
++				   struct counter_count *count,
++				   struct counter_synapse *synapse,
++				   enum counter_synapse_action *action)
+ {
+-	*action = FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES;
++	*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 
+ 	return 0;
+ }
+@@ -227,8 +210,8 @@ static int ftm_quaddec_action_get(struct counter_device *counter,
+ static const struct counter_ops ftm_quaddec_cnt_ops = {
+ 	.count_read = ftm_quaddec_count_read,
+ 	.count_write = ftm_quaddec_count_write,
+-	.function_get = ftm_quaddec_count_function_get,
+-	.action_get = ftm_quaddec_action_get,
++	.function_read = ftm_quaddec_count_function_read,
++	.action_read = ftm_quaddec_action_read,
+ };
+ 
+ static struct counter_signal ftm_quaddec_signals[] = {
+@@ -255,9 +238,12 @@ static struct counter_synapse ftm_quaddec_count_synapses[] = {
+ 	}
+ };
+ 
+-static const struct counter_count_ext ftm_quaddec_count_ext[] = {
+-	COUNTER_COUNT_ENUM("prescaler", &ftm_quaddec_prescaler_enum),
+-	COUNTER_COUNT_ENUM_AVAILABLE("prescaler", &ftm_quaddec_prescaler_enum),
++static DEFINE_COUNTER_ENUM(ftm_quaddec_prescaler_enum, ftm_quaddec_prescaler);
++
++static struct counter_comp ftm_quaddec_count_ext[] = {
++	COUNTER_COMP_COUNT_ENUM("prescaler", ftm_quaddec_get_prescaler,
++				ftm_quaddec_set_prescaler,
++				ftm_quaddec_prescaler_enum),
+ };
+ 
+ static struct counter_count ftm_quaddec_counts = {
+diff --git a/drivers/counter/intel-qep.c b/drivers/counter/intel-qep.c
+index 8a6847d5fb2bd..0924d16de6e26 100644
+--- a/drivers/counter/intel-qep.c
++++ b/drivers/counter/intel-qep.c
+@@ -62,13 +62,6 @@
+ 
+ #define INTEL_QEP_CLK_PERIOD_NS		10
+ 
+-#define INTEL_QEP_COUNTER_EXT_RW(_name)				\
+-{								\
+-	.name = #_name,						\
+-	.read = _name##_read,					\
+-	.write = _name##_write,					\
+-}
+-
+ struct intel_qep {
+ 	struct counter_device counter;
+ 	struct mutex lock;
+@@ -114,8 +107,7 @@ static void intel_qep_init(struct intel_qep *qep)
+ }
+ 
+ static int intel_qep_count_read(struct counter_device *counter,
+-				struct counter_count *count,
+-				unsigned long *val)
++				struct counter_count *count, u64 *val)
+ {
+ 	struct intel_qep *const qep = counter->priv;
+ 
+@@ -130,11 +122,11 @@ static const enum counter_function intel_qep_count_functions[] = {
+ 	COUNTER_FUNCTION_QUADRATURE_X4,
+ };
+ 
+-static int intel_qep_function_get(struct counter_device *counter,
+-				  struct counter_count *count,
+-				  size_t *function)
++static int intel_qep_function_read(struct counter_device *counter,
++				   struct counter_count *count,
++				   enum counter_function *function)
+ {
+-	*function = 0;
++	*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 
+ 	return 0;
+ }
+@@ -143,19 +135,19 @@ static const enum counter_synapse_action intel_qep_synapse_actions[] = {
+ 	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+ };
+ 
+-static int intel_qep_action_get(struct counter_device *counter,
+-				struct counter_count *count,
+-				struct counter_synapse *synapse,
+-				size_t *action)
++static int intel_qep_action_read(struct counter_device *counter,
++				 struct counter_count *count,
++				 struct counter_synapse *synapse,
++				 enum counter_synapse_action *action)
+ {
+-	*action = 0;
++	*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 	return 0;
+ }
+ 
+ static const struct counter_ops intel_qep_counter_ops = {
+ 	.count_read = intel_qep_count_read,
+-	.function_get = intel_qep_function_get,
+-	.action_get = intel_qep_action_get,
++	.function_read = intel_qep_function_read,
++	.action_read = intel_qep_action_read,
+ };
+ 
+ #define INTEL_QEP_SIGNAL(_id, _name) {				\
+@@ -181,31 +173,27 @@ static struct counter_synapse intel_qep_count_synapses[] = {
+ 	INTEL_QEP_SYNAPSE(2),
+ };
+ 
+-static ssize_t ceiling_read(struct counter_device *counter,
+-			    struct counter_count *count,
+-			    void *priv, char *buf)
++static int intel_qep_ceiling_read(struct counter_device *counter,
++				  struct counter_count *count, u64 *ceiling)
+ {
+ 	struct intel_qep *qep = counter->priv;
+-	u32 reg;
+ 
+ 	pm_runtime_get_sync(qep->dev);
+-	reg = intel_qep_readl(qep, INTEL_QEPMAX);
++	*ceiling = intel_qep_readl(qep, INTEL_QEPMAX);
+ 	pm_runtime_put(qep->dev);
+ 
+-	return sysfs_emit(buf, "%u\n", reg);
++	return 0;
+ }
+ 
+-static ssize_t ceiling_write(struct counter_device *counter,
+-			     struct counter_count *count,
+-			     void *priv, const char *buf, size_t len)
++static int intel_qep_ceiling_write(struct counter_device *counter,
++				   struct counter_count *count, u64 max)
+ {
+ 	struct intel_qep *qep = counter->priv;
+-	u32 max;
+-	int ret;
++	int ret = 0;
+ 
+-	ret = kstrtou32(buf, 0, &max);
+-	if (ret < 0)
+-		return ret;
++	/* Intel QEP ceiling configuration only supports 32-bit values */
++	if (max != (u32)max)
++		return -ERANGE;
+ 
+ 	mutex_lock(&qep->lock);
+ 	if (qep->enabled) {
+@@ -216,34 +204,28 @@ static ssize_t ceiling_write(struct counter_device *counter,
+ 	pm_runtime_get_sync(qep->dev);
+ 	intel_qep_writel(qep, INTEL_QEPMAX, max);
+ 	pm_runtime_put(qep->dev);
+-	ret = len;
+ 
+ out:
+ 	mutex_unlock(&qep->lock);
+ 	return ret;
+ }
+ 
+-static ssize_t enable_read(struct counter_device *counter,
+-			   struct counter_count *count,
+-			   void *priv, char *buf)
++static int intel_qep_enable_read(struct counter_device *counter,
++				 struct counter_count *count, u8 *enable)
+ {
+ 	struct intel_qep *qep = counter->priv;
+ 
+-	return sysfs_emit(buf, "%u\n", qep->enabled);
++	*enable = qep->enabled;
++
++	return 0;
+ }
+ 
+-static ssize_t enable_write(struct counter_device *counter,
+-			    struct counter_count *count,
+-			    void *priv, const char *buf, size_t len)
++static int intel_qep_enable_write(struct counter_device *counter,
++				  struct counter_count *count, u8 val)
+ {
+ 	struct intel_qep *qep = counter->priv;
+ 	u32 reg;
+-	bool val, changed;
+-	int ret;
+-
+-	ret = kstrtobool(buf, &val);
+-	if (ret)
+-		return ret;
++	bool changed;
+ 
+ 	mutex_lock(&qep->lock);
+ 	changed = val ^ qep->enabled;
+@@ -267,12 +249,12 @@ static ssize_t enable_write(struct counter_device *counter,
+ 
+ out:
+ 	mutex_unlock(&qep->lock);
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t spike_filter_ns_read(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    void *priv, char *buf)
++static int intel_qep_spike_filter_ns_read(struct counter_device *counter,
++					  struct counter_count *count,
++					  u64 *length)
+ {
+ 	struct intel_qep *qep = counter->priv;
+ 	u32 reg;
+@@ -281,33 +263,31 @@ static ssize_t spike_filter_ns_read(struct counter_device *counter,
+ 	reg = intel_qep_readl(qep, INTEL_QEPCON);
+ 	if (!(reg & INTEL_QEPCON_FLT_EN)) {
+ 		pm_runtime_put(qep->dev);
+-		return sysfs_emit(buf, "0\n");
++		return 0;
+ 	}
+ 	reg = INTEL_QEPFLT_MAX_COUNT(intel_qep_readl(qep, INTEL_QEPFLT));
+ 	pm_runtime_put(qep->dev);
+ 
+-	return sysfs_emit(buf, "%u\n", (reg + 2) * INTEL_QEP_CLK_PERIOD_NS);
++	*length = (reg + 2) * INTEL_QEP_CLK_PERIOD_NS;
++
++	return 0;
+ }
+ 
+-static ssize_t spike_filter_ns_write(struct counter_device *counter,
+-				     struct counter_count *count,
+-				     void *priv, const char *buf, size_t len)
++static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
++					   struct counter_count *count,
++					   u64 length)
+ {
+ 	struct intel_qep *qep = counter->priv;
+-	u32 reg, length;
++	u32 reg;
+ 	bool enable;
+-	int ret;
+-
+-	ret = kstrtou32(buf, 0, &length);
+-	if (ret < 0)
+-		return ret;
++	int ret = 0;
+ 
+ 	/*
+ 	 * Spike filter length is (MAX_COUNT + 2) clock periods.
+ 	 * Disable filter when userspace writes 0, enable for valid
+ 	 * nanoseconds values and error out otherwise.
+ 	 */
+-	length /= INTEL_QEP_CLK_PERIOD_NS;
++	do_div(length, INTEL_QEP_CLK_PERIOD_NS);
+ 	if (length == 0) {
+ 		enable = false;
+ 		length = 0;
+@@ -336,16 +316,15 @@ static ssize_t spike_filter_ns_write(struct counter_device *counter,
+ 	intel_qep_writel(qep, INTEL_QEPFLT, length);
+ 	intel_qep_writel(qep, INTEL_QEPCON, reg);
+ 	pm_runtime_put(qep->dev);
+-	ret = len;
+ 
+ out:
+ 	mutex_unlock(&qep->lock);
+ 	return ret;
+ }
+ 
+-static ssize_t preset_enable_read(struct counter_device *counter,
+-				  struct counter_count *count,
+-				  void *priv, char *buf)
++static int intel_qep_preset_enable_read(struct counter_device *counter,
++					struct counter_count *count,
++					u8 *preset_enable)
+ {
+ 	struct intel_qep *qep = counter->priv;
+ 	u32 reg;
+@@ -353,21 +332,18 @@ static ssize_t preset_enable_read(struct counter_device *counter,
+ 	pm_runtime_get_sync(qep->dev);
+ 	reg = intel_qep_readl(qep, INTEL_QEPCON);
+ 	pm_runtime_put(qep->dev);
+-	return sysfs_emit(buf, "%u\n", !(reg & INTEL_QEPCON_COUNT_RST_MODE));
++
++	*preset_enable = !(reg & INTEL_QEPCON_COUNT_RST_MODE);
++
++	return 0;
+ }
+ 
+-static ssize_t preset_enable_write(struct counter_device *counter,
+-				   struct counter_count *count,
+-				   void *priv, const char *buf, size_t len)
++static int intel_qep_preset_enable_write(struct counter_device *counter,
++					 struct counter_count *count, u8 val)
+ {
+ 	struct intel_qep *qep = counter->priv;
+ 	u32 reg;
+-	bool val;
+-	int ret;
+-
+-	ret = kstrtobool(buf, &val);
+-	if (ret)
+-		return ret;
++	int ret = 0;
+ 
+ 	mutex_lock(&qep->lock);
+ 	if (qep->enabled) {
+@@ -384,7 +360,6 @@ static ssize_t preset_enable_write(struct counter_device *counter,
+ 
+ 	intel_qep_writel(qep, INTEL_QEPCON, reg);
+ 	pm_runtime_put(qep->dev);
+-	ret = len;
+ 
+ out:
+ 	mutex_unlock(&qep->lock);
+@@ -392,11 +367,14 @@ out:
+ 	return ret;
+ }
+ 
+-static const struct counter_count_ext intel_qep_count_ext[] = {
+-	INTEL_QEP_COUNTER_EXT_RW(ceiling),
+-	INTEL_QEP_COUNTER_EXT_RW(enable),
+-	INTEL_QEP_COUNTER_EXT_RW(spike_filter_ns),
+-	INTEL_QEP_COUNTER_EXT_RW(preset_enable)
++static struct counter_comp intel_qep_count_ext[] = {
++	COUNTER_COMP_ENABLE(intel_qep_enable_read, intel_qep_enable_write),
++	COUNTER_COMP_CEILING(intel_qep_ceiling_read, intel_qep_ceiling_write),
++	COUNTER_COMP_PRESET_ENABLE(intel_qep_preset_enable_read,
++				   intel_qep_preset_enable_write),
++	COUNTER_COMP_COUNT_U64("spike_filter_ns",
++			       intel_qep_spike_filter_ns_read,
++			       intel_qep_spike_filter_ns_write),
+ };
+ 
+ static struct counter_count intel_qep_counter_count[] = {
+diff --git a/drivers/counter/interrupt-cnt.c b/drivers/counter/interrupt-cnt.c
+index 1de4243db488c..8514a87fcbee0 100644
+--- a/drivers/counter/interrupt-cnt.c
++++ b/drivers/counter/interrupt-cnt.c
+@@ -10,6 +10,7 @@
+ #include <linux/mod_devicetable.h>
+ #include <linux/module.h>
+ #include <linux/platform_device.h>
++#include <linux/types.h>
+ 
+ #define INTERRUPT_CNT_NAME "interrupt-cnt"
+ 
+@@ -33,30 +34,23 @@ static irqreturn_t interrupt_cnt_isr(int irq, void *dev_id)
+ 	return IRQ_HANDLED;
+ }
+ 
+-static ssize_t interrupt_cnt_enable_read(struct counter_device *counter,
+-					 struct counter_count *count,
+-					 void *private, char *buf)
++static int interrupt_cnt_enable_read(struct counter_device *counter,
++				     struct counter_count *count, u8 *enable)
+ {
+ 	struct interrupt_cnt_priv *priv = counter->priv;
+ 
+-	return sysfs_emit(buf, "%d\n", priv->enabled);
++	*enable = priv->enabled;
++
++	return 0;
+ }
+ 
+-static ssize_t interrupt_cnt_enable_write(struct counter_device *counter,
+-					  struct counter_count *count,
+-					  void *private, const char *buf,
+-					  size_t len)
++static int interrupt_cnt_enable_write(struct counter_device *counter,
++				      struct counter_count *count, u8 enable)
+ {
+ 	struct interrupt_cnt_priv *priv = counter->priv;
+-	bool enable;
+-	ssize_t ret;
+-
+-	ret = kstrtobool(buf, &enable);
+-	if (ret)
+-		return ret;
+ 
+ 	if (priv->enabled == enable)
+-		return len;
++		return 0;
+ 
+ 	if (enable) {
+ 		priv->enabled = true;
+@@ -66,33 +60,30 @@ static ssize_t interrupt_cnt_enable_write(struct counter_device *counter,
+ 		priv->enabled = false;
+ 	}
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static const struct counter_count_ext interrupt_cnt_ext[] = {
+-	{
+-		.name = "enable",
+-		.read = interrupt_cnt_enable_read,
+-		.write = interrupt_cnt_enable_write,
+-	},
++static struct counter_comp interrupt_cnt_ext[] = {
++	COUNTER_COMP_ENABLE(interrupt_cnt_enable_read,
++			    interrupt_cnt_enable_write),
+ };
+ 
+ static const enum counter_synapse_action interrupt_cnt_synapse_actions[] = {
+ 	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+ };
+ 
+-static int interrupt_cnt_action_get(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    struct counter_synapse *synapse,
+-				    size_t *action)
++static int interrupt_cnt_action_read(struct counter_device *counter,
++				     struct counter_count *count,
++				     struct counter_synapse *synapse,
++				     enum counter_synapse_action *action)
+ {
+-	*action = 0;
++	*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 
+ 	return 0;
+ }
+ 
+ static int interrupt_cnt_read(struct counter_device *counter,
+-			      struct counter_count *count, unsigned long *val)
++			      struct counter_count *count, u64 *val)
+ {
+ 	struct interrupt_cnt_priv *priv = counter->priv;
+ 
+@@ -102,8 +93,7 @@ static int interrupt_cnt_read(struct counter_device *counter,
+ }
+ 
+ static int interrupt_cnt_write(struct counter_device *counter,
+-			       struct counter_count *count,
+-			       const unsigned long val)
++			       struct counter_count *count, const u64 val)
+ {
+ 	struct interrupt_cnt_priv *priv = counter->priv;
+ 
+@@ -119,11 +109,11 @@ static const enum counter_function interrupt_cnt_functions[] = {
+ 	COUNTER_FUNCTION_INCREASE,
+ };
+ 
+-static int interrupt_cnt_function_get(struct counter_device *counter,
+-				      struct counter_count *count,
+-				      size_t *function)
++static int interrupt_cnt_function_read(struct counter_device *counter,
++				       struct counter_count *count,
++				       enum counter_function *function)
+ {
+-	*function = 0;
++	*function = COUNTER_FUNCTION_INCREASE;
+ 
+ 	return 0;
+ }
+@@ -148,10 +138,10 @@ static int interrupt_cnt_signal_read(struct counter_device *counter,
+ }
+ 
+ static const struct counter_ops interrupt_cnt_ops = {
+-	.action_get = interrupt_cnt_action_get,
++	.action_read = interrupt_cnt_action_read,
+ 	.count_read = interrupt_cnt_read,
+ 	.count_write = interrupt_cnt_write,
+-	.function_get = interrupt_cnt_function_get,
++	.function_read = interrupt_cnt_function_read,
+ 	.signal_read  = interrupt_cnt_signal_read,
+ };
+ 
+diff --git a/drivers/counter/microchip-tcb-capture.c b/drivers/counter/microchip-tcb-capture.c
+index 22563dcded751..4edfe1f8fff7a 100644
+--- a/drivers/counter/microchip-tcb-capture.c
++++ b/drivers/counter/microchip-tcb-capture.c
+@@ -31,28 +31,16 @@ struct mchp_tc_data {
+ 	int channel[2];
+ };
+ 
+-enum mchp_tc_count_function {
+-	MCHP_TC_FUNCTION_INCREASE,
+-	MCHP_TC_FUNCTION_QUADRATURE,
+-};
+-
+ static const enum counter_function mchp_tc_count_functions[] = {
+-	[MCHP_TC_FUNCTION_INCREASE] = COUNTER_FUNCTION_INCREASE,
+-	[MCHP_TC_FUNCTION_QUADRATURE] = COUNTER_FUNCTION_QUADRATURE_X4,
+-};
+-
+-enum mchp_tc_synapse_action {
+-	MCHP_TC_SYNAPSE_ACTION_NONE = 0,
+-	MCHP_TC_SYNAPSE_ACTION_RISING_EDGE,
+-	MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE,
+-	MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE
++	COUNTER_FUNCTION_INCREASE,
++	COUNTER_FUNCTION_QUADRATURE_X4,
+ };
+ 
+ static const enum counter_synapse_action mchp_tc_synapse_actions[] = {
+-	[MCHP_TC_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
+-	[MCHP_TC_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+-	[MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+-	[MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
++	COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
++	COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+ };
+ 
+ static struct counter_signal mchp_tc_count_signals[] = {
+@@ -79,23 +67,23 @@ static struct counter_synapse mchp_tc_count_synapses[] = {
+ 	}
+ };
+ 
+-static int mchp_tc_count_function_get(struct counter_device *counter,
+-				      struct counter_count *count,
+-				      size_t *function)
++static int mchp_tc_count_function_read(struct counter_device *counter,
++				       struct counter_count *count,
++				       enum counter_function *function)
+ {
+ 	struct mchp_tc_data *const priv = counter->priv;
+ 
+ 	if (priv->qdec_mode)
+-		*function = MCHP_TC_FUNCTION_QUADRATURE;
++		*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 	else
+-		*function = MCHP_TC_FUNCTION_INCREASE;
++		*function = COUNTER_FUNCTION_INCREASE;
+ 
+ 	return 0;
+ }
+ 
+-static int mchp_tc_count_function_set(struct counter_device *counter,
+-				      struct counter_count *count,
+-				      size_t function)
++static int mchp_tc_count_function_write(struct counter_device *counter,
++					struct counter_count *count,
++					enum counter_function function)
+ {
+ 	struct mchp_tc_data *const priv = counter->priv;
+ 	u32 bmr, cmr;
+@@ -107,7 +95,7 @@ static int mchp_tc_count_function_set(struct counter_device *counter,
+ 	cmr &= ~ATMEL_TC_WAVE;
+ 
+ 	switch (function) {
+-	case MCHP_TC_FUNCTION_INCREASE:
++	case COUNTER_FUNCTION_INCREASE:
+ 		priv->qdec_mode = 0;
+ 		/* Set highest rate based on whether soc has gclk or not */
+ 		bmr &= ~(ATMEL_TC_QDEN | ATMEL_TC_POSEN);
+@@ -119,7 +107,7 @@ static int mchp_tc_count_function_set(struct counter_device *counter,
+ 		cmr |=  ATMEL_TC_CMR_MASK;
+ 		cmr &= ~(ATMEL_TC_ABETRG | ATMEL_TC_XC0);
+ 		break;
+-	case MCHP_TC_FUNCTION_QUADRATURE:
++	case COUNTER_FUNCTION_QUADRATURE_X4:
+ 		if (!priv->tc_cfg->has_qdec)
+ 			return -EINVAL;
+ 		/* In QDEC mode settings both channels 0 and 1 are required */
+@@ -175,10 +163,10 @@ static int mchp_tc_count_signal_read(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static int mchp_tc_count_action_get(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    struct counter_synapse *synapse,
+-				    size_t *action)
++static int mchp_tc_count_action_read(struct counter_device *counter,
++				     struct counter_count *count,
++				     struct counter_synapse *synapse,
++				     enum counter_synapse_action *action)
+ {
+ 	struct mchp_tc_data *const priv = counter->priv;
+ 	u32 cmr;
+@@ -198,26 +186,26 @@ static int mchp_tc_count_action_get(struct counter_device *counter,
+ 
+ 	switch (cmr & ATMEL_TC_ETRGEDG) {
+ 	default:
+-		*action = MCHP_TC_SYNAPSE_ACTION_NONE;
++		*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 		break;
+ 	case ATMEL_TC_ETRGEDG_RISING:
+-		*action = MCHP_TC_SYNAPSE_ACTION_RISING_EDGE;
++		*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 		break;
+ 	case ATMEL_TC_ETRGEDG_FALLING:
+-		*action = MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE;
++		*action = COUNTER_SYNAPSE_ACTION_FALLING_EDGE;
+ 		break;
+ 	case ATMEL_TC_ETRGEDG_BOTH:
+-		*action = MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE;
++		*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		break;
+ 	}
+ 
+ 	return 0;
+ }
+ 
+-static int mchp_tc_count_action_set(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    struct counter_synapse *synapse,
+-				    size_t action)
++static int mchp_tc_count_action_write(struct counter_device *counter,
++				      struct counter_count *count,
++				      struct counter_synapse *synapse,
++				      enum counter_synapse_action action)
+ {
+ 	struct mchp_tc_data *const priv = counter->priv;
+ 	u32 edge = ATMEL_TC_ETRGEDG_NONE;
+@@ -227,16 +215,16 @@ static int mchp_tc_count_action_set(struct counter_device *counter,
+ 		return -EINVAL;
+ 
+ 	switch (action) {
+-	case MCHP_TC_SYNAPSE_ACTION_NONE:
++	case COUNTER_SYNAPSE_ACTION_NONE:
+ 		edge = ATMEL_TC_ETRGEDG_NONE;
+ 		break;
+-	case MCHP_TC_SYNAPSE_ACTION_RISING_EDGE:
++	case COUNTER_SYNAPSE_ACTION_RISING_EDGE:
+ 		edge = ATMEL_TC_ETRGEDG_RISING;
+ 		break;
+-	case MCHP_TC_SYNAPSE_ACTION_FALLING_EDGE:
++	case COUNTER_SYNAPSE_ACTION_FALLING_EDGE:
+ 		edge = ATMEL_TC_ETRGEDG_FALLING;
+ 		break;
+-	case MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE:
++	case COUNTER_SYNAPSE_ACTION_BOTH_EDGES:
+ 		edge = ATMEL_TC_ETRGEDG_BOTH;
+ 		break;
+ 	default:
+@@ -250,8 +238,7 @@ static int mchp_tc_count_action_set(struct counter_device *counter,
+ }
+ 
+ static int mchp_tc_count_read(struct counter_device *counter,
+-			      struct counter_count *count,
+-			      unsigned long *val)
++			      struct counter_count *count, u64 *val)
+ {
+ 	struct mchp_tc_data *const priv = counter->priv;
+ 	u32 cnt;
+@@ -274,12 +261,12 @@ static struct counter_count mchp_tc_counts[] = {
+ };
+ 
+ static const struct counter_ops mchp_tc_ops = {
+-	.signal_read  = mchp_tc_count_signal_read,
+-	.count_read   = mchp_tc_count_read,
+-	.function_get = mchp_tc_count_function_get,
+-	.function_set = mchp_tc_count_function_set,
+-	.action_get   = mchp_tc_count_action_get,
+-	.action_set   = mchp_tc_count_action_set
++	.signal_read    = mchp_tc_count_signal_read,
++	.count_read     = mchp_tc_count_read,
++	.function_read  = mchp_tc_count_function_read,
++	.function_write = mchp_tc_count_function_write,
++	.action_read    = mchp_tc_count_action_read,
++	.action_write   = mchp_tc_count_action_write
+ };
+ 
+ static const struct atmel_tcb_config tcb_rm9200_config = {
+diff --git a/drivers/counter/stm32-lptimer-cnt.c b/drivers/counter/stm32-lptimer-cnt.c
+index fa7f86cf0ea32..637b3f0b4fa34 100644
+--- a/drivers/counter/stm32-lptimer-cnt.c
++++ b/drivers/counter/stm32-lptimer-cnt.c
+@@ -17,6 +17,7 @@
+ #include <linux/module.h>
+ #include <linux/pinctrl/consumer.h>
+ #include <linux/platform_device.h>
++#include <linux/types.h>
+ 
+ struct stm32_lptim_cnt {
+ 	struct counter_device counter;
+@@ -107,11 +108,7 @@ static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable)
+ 	return regmap_update_bits(priv->regmap, STM32_LPTIM_CFGR, mask, val);
+ }
+ 
+-/**
+- * enum stm32_lptim_cnt_function - enumerates LPTimer counter & encoder modes
+- * @STM32_LPTIM_COUNTER_INCREASE: up count on IN1 rising, falling or both edges
+- * @STM32_LPTIM_ENCODER_BOTH_EDGE: count on both edges (IN1 & IN2 quadrature)
+- *
++/*
+  * In non-quadrature mode, device counts up on active edge.
+  * In quadrature mode, encoder counting scenarios are as follows:
+  * +---------+----------+--------------------+--------------------+
+@@ -129,33 +126,20 @@ static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable)
+  * | edges   | Low  ->  |   Up     |   Down  |   Down   |   Up    |
+  * +---------+----------+----------+---------+----------+---------+
+  */
+-enum stm32_lptim_cnt_function {
+-	STM32_LPTIM_COUNTER_INCREASE,
+-	STM32_LPTIM_ENCODER_BOTH_EDGE,
+-};
+-
+ static const enum counter_function stm32_lptim_cnt_functions[] = {
+-	[STM32_LPTIM_COUNTER_INCREASE] = COUNTER_FUNCTION_INCREASE,
+-	[STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_FUNCTION_QUADRATURE_X4,
+-};
+-
+-enum stm32_lptim_synapse_action {
+-	STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE,
+-	STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE,
+-	STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES,
+-	STM32_LPTIM_SYNAPSE_ACTION_NONE,
++	COUNTER_FUNCTION_INCREASE,
++	COUNTER_FUNCTION_QUADRATURE_X4,
+ };
+ 
+ static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
+-	/* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
+-	[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+-	[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+-	[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+-	[STM32_LPTIM_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
++	COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
++	COUNTER_SYNAPSE_ACTION_NONE,
+ };
+ 
+ static int stm32_lptim_cnt_read(struct counter_device *counter,
+-				struct counter_count *count, unsigned long *val)
++				struct counter_count *count, u64 *val)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+ 	u32 cnt;
+@@ -170,28 +154,28 @@ static int stm32_lptim_cnt_read(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static int stm32_lptim_cnt_function_get(struct counter_device *counter,
+-					struct counter_count *count,
+-					size_t *function)
++static int stm32_lptim_cnt_function_read(struct counter_device *counter,
++					 struct counter_count *count,
++					 enum counter_function *function)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+ 
+ 	if (!priv->quadrature_mode) {
+-		*function = STM32_LPTIM_COUNTER_INCREASE;
++		*function = COUNTER_FUNCTION_INCREASE;
+ 		return 0;
+ 	}
+ 
+-	if (priv->polarity == STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES) {
+-		*function = STM32_LPTIM_ENCODER_BOTH_EDGE;
++	if (priv->polarity == STM32_LPTIM_CKPOL_BOTH_EDGES) {
++		*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 		return 0;
+ 	}
+ 
+ 	return -EINVAL;
+ }
+ 
+-static int stm32_lptim_cnt_function_set(struct counter_device *counter,
+-					struct counter_count *count,
+-					size_t function)
++static int stm32_lptim_cnt_function_write(struct counter_device *counter,
++					  struct counter_count *count,
++					  enum counter_function function)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+ 
+@@ -199,12 +183,12 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter,
+ 		return -EBUSY;
+ 
+ 	switch (function) {
+-	case STM32_LPTIM_COUNTER_INCREASE:
++	case COUNTER_FUNCTION_INCREASE:
+ 		priv->quadrature_mode = 0;
+ 		return 0;
+-	case STM32_LPTIM_ENCODER_BOTH_EDGE:
++	case COUNTER_FUNCTION_QUADRATURE_X4:
+ 		priv->quadrature_mode = 1;
+-		priv->polarity = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES;
++		priv->polarity = STM32_LPTIM_CKPOL_BOTH_EDGES;
+ 		return 0;
+ 	default:
+ 		/* should never reach this path */
+@@ -212,9 +196,9 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter,
+ 	}
+ }
+ 
+-static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
+-					   struct counter_count *count,
+-					   void *private, char *buf)
++static int stm32_lptim_cnt_enable_read(struct counter_device *counter,
++				       struct counter_count *count,
++				       u8 *enable)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+ 	int ret;
+@@ -223,22 +207,18 @@ static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
+ 	if (ret < 0)
+ 		return ret;
+ 
+-	return scnprintf(buf, PAGE_SIZE, "%u\n", ret);
++	*enable = ret;
++
++	return 0;
+ }
+ 
+-static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
+-					    struct counter_count *count,
+-					    void *private,
+-					    const char *buf, size_t len)
++static int stm32_lptim_cnt_enable_write(struct counter_device *counter,
++					struct counter_count *count,
++					u8 enable)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+-	bool enable;
+ 	int ret;
+ 
+-	ret = kstrtobool(buf, &enable);
+-	if (ret)
+-		return ret;
+-
+ 	/* Check nobody uses the timer, or already disabled/enabled */
+ 	ret = stm32_lptim_is_enabled(priv);
+ 	if ((ret < 0) || (!ret && !enable))
+@@ -254,78 +234,81 @@ static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
+ 	if (ret)
+ 		return ret;
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
+-					    struct counter_count *count,
+-					    void *private, char *buf)
++static int stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
++					struct counter_count *count,
++					u64 *ceiling)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+ 
+-	return snprintf(buf, PAGE_SIZE, "%u\n", priv->ceiling);
++	*ceiling = priv->ceiling;
++
++	return 0;
+ }
+ 
+-static ssize_t stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
+-					     struct counter_count *count,
+-					     void *private,
+-					     const char *buf, size_t len)
++static int stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
++					 struct counter_count *count,
++					 u64 ceiling)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+-	unsigned int ceiling;
+-	int ret;
+ 
+ 	if (stm32_lptim_is_enabled(priv))
+ 		return -EBUSY;
+ 
+-	ret = kstrtouint(buf, 0, &ceiling);
+-	if (ret)
+-		return ret;
+-
+ 	if (ceiling > STM32_LPTIM_MAX_ARR)
+ 		return -ERANGE;
+ 
+ 	priv->ceiling = ceiling;
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static const struct counter_count_ext stm32_lptim_cnt_ext[] = {
+-	{
+-		.name = "enable",
+-		.read = stm32_lptim_cnt_enable_read,
+-		.write = stm32_lptim_cnt_enable_write
+-	},
+-	{
+-		.name = "ceiling",
+-		.read = stm32_lptim_cnt_ceiling_read,
+-		.write = stm32_lptim_cnt_ceiling_write
+-	},
++static struct counter_comp stm32_lptim_cnt_ext[] = {
++	COUNTER_COMP_ENABLE(stm32_lptim_cnt_enable_read,
++			    stm32_lptim_cnt_enable_write),
++	COUNTER_COMP_CEILING(stm32_lptim_cnt_ceiling_read,
++			     stm32_lptim_cnt_ceiling_write),
+ };
+ 
+-static int stm32_lptim_cnt_action_get(struct counter_device *counter,
+-				      struct counter_count *count,
+-				      struct counter_synapse *synapse,
+-				      size_t *action)
++static int stm32_lptim_cnt_action_read(struct counter_device *counter,
++				       struct counter_count *count,
++				       struct counter_synapse *synapse,
++				       enum counter_synapse_action *action)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+-	size_t function;
++	enum counter_function function;
+ 	int err;
+ 
+-	err = stm32_lptim_cnt_function_get(counter, count, &function);
++	err = stm32_lptim_cnt_function_read(counter, count, &function);
+ 	if (err)
+ 		return err;
+ 
+ 	switch (function) {
+-	case STM32_LPTIM_COUNTER_INCREASE:
++	case COUNTER_FUNCTION_INCREASE:
+ 		/* LP Timer acts as up-counter on input 1 */
+-		if (synapse->signal->id == count->synapses[0].signal->id)
+-			*action = priv->polarity;
+-		else
+-			*action = STM32_LPTIM_SYNAPSE_ACTION_NONE;
+-		return 0;
+-	case STM32_LPTIM_ENCODER_BOTH_EDGE:
+-		*action = priv->polarity;
++		if (synapse->signal->id != count->synapses[0].signal->id) {
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
++			return 0;
++		}
++
++		switch (priv->polarity) {
++		case STM32_LPTIM_CKPOL_RISING_EDGE:
++			*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
++			return 0;
++		case STM32_LPTIM_CKPOL_FALLING_EDGE:
++			*action = COUNTER_SYNAPSE_ACTION_FALLING_EDGE;
++			return 0;
++		case STM32_LPTIM_CKPOL_BOTH_EDGES:
++			*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
++			return 0;
++		default:
++			/* should never reach this path */
++			return -EINVAL;
++		}
++	case COUNTER_FUNCTION_QUADRATURE_X4:
++		*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		return 0;
+ 	default:
+ 		/* should never reach this path */
+@@ -333,43 +316,48 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter,
+ 	}
+ }
+ 
+-static int stm32_lptim_cnt_action_set(struct counter_device *counter,
+-				      struct counter_count *count,
+-				      struct counter_synapse *synapse,
+-				      size_t action)
++static int stm32_lptim_cnt_action_write(struct counter_device *counter,
++					struct counter_count *count,
++					struct counter_synapse *synapse,
++					enum counter_synapse_action action)
+ {
+ 	struct stm32_lptim_cnt *const priv = counter->priv;
+-	size_t function;
++	enum counter_function function;
+ 	int err;
+ 
+ 	if (stm32_lptim_is_enabled(priv))
+ 		return -EBUSY;
+ 
+-	err = stm32_lptim_cnt_function_get(counter, count, &function);
++	err = stm32_lptim_cnt_function_read(counter, count, &function);
+ 	if (err)
+ 		return err;
+ 
+ 	/* only set polarity when in counter mode (on input 1) */
+-	if (function == STM32_LPTIM_COUNTER_INCREASE
+-	    && synapse->signal->id == count->synapses[0].signal->id) {
+-		switch (action) {
+-		case STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE:
+-		case STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE:
+-		case STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES:
+-			priv->polarity = action;
+-			return 0;
+-		}
+-	}
++	if (function != COUNTER_FUNCTION_INCREASE
++	    || synapse->signal->id != count->synapses[0].signal->id)
++		return -EINVAL;
+ 
+-	return -EINVAL;
++	switch (action) {
++	case COUNTER_SYNAPSE_ACTION_RISING_EDGE:
++		priv->polarity = STM32_LPTIM_CKPOL_RISING_EDGE;
++		return 0;
++	case COUNTER_SYNAPSE_ACTION_FALLING_EDGE:
++		priv->polarity = STM32_LPTIM_CKPOL_FALLING_EDGE;
++		return 0;
++	case COUNTER_SYNAPSE_ACTION_BOTH_EDGES:
++		priv->polarity = STM32_LPTIM_CKPOL_BOTH_EDGES;
++		return 0;
++	default:
++		return -EINVAL;
++	}
+ }
+ 
+ static const struct counter_ops stm32_lptim_cnt_ops = {
+ 	.count_read = stm32_lptim_cnt_read,
+-	.function_get = stm32_lptim_cnt_function_get,
+-	.function_set = stm32_lptim_cnt_function_set,
+-	.action_get = stm32_lptim_cnt_action_get,
+-	.action_set = stm32_lptim_cnt_action_set,
++	.function_read = stm32_lptim_cnt_function_read,
++	.function_write = stm32_lptim_cnt_function_write,
++	.action_read = stm32_lptim_cnt_action_read,
++	.action_write = stm32_lptim_cnt_action_write,
+ };
+ 
+ static struct counter_signal stm32_lptim_cnt_signals[] = {
+diff --git a/drivers/counter/stm32-timer-cnt.c b/drivers/counter/stm32-timer-cnt.c
+index 3fb0debd7425d..0546e932db0c1 100644
+--- a/drivers/counter/stm32-timer-cnt.c
++++ b/drivers/counter/stm32-timer-cnt.c
+@@ -13,6 +13,7 @@
+ #include <linux/module.h>
+ #include <linux/pinctrl/consumer.h>
+ #include <linux/platform_device.h>
++#include <linux/types.h>
+ 
+ #define TIM_CCMR_CCXS	(BIT(8) | BIT(0))
+ #define TIM_CCMR_MASK	(TIM_CCMR_CC1S | TIM_CCMR_CC2S | \
+@@ -36,29 +37,15 @@ struct stm32_timer_cnt {
+ 	struct stm32_timer_regs bak;
+ };
+ 
+-/**
+- * enum stm32_count_function - enumerates stm32 timer counter encoder modes
+- * @STM32_COUNT_SLAVE_MODE_DISABLED: counts on internal clock when CEN=1
+- * @STM32_COUNT_ENCODER_MODE_1: counts TI1FP1 edges, depending on TI2FP2 level
+- * @STM32_COUNT_ENCODER_MODE_2: counts TI2FP2 edges, depending on TI1FP1 level
+- * @STM32_COUNT_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
+- */
+-enum stm32_count_function {
+-	STM32_COUNT_SLAVE_MODE_DISABLED,
+-	STM32_COUNT_ENCODER_MODE_1,
+-	STM32_COUNT_ENCODER_MODE_2,
+-	STM32_COUNT_ENCODER_MODE_3,
+-};
+-
+ static const enum counter_function stm32_count_functions[] = {
+-	[STM32_COUNT_SLAVE_MODE_DISABLED] = COUNTER_FUNCTION_INCREASE,
+-	[STM32_COUNT_ENCODER_MODE_1] = COUNTER_FUNCTION_QUADRATURE_X2_A,
+-	[STM32_COUNT_ENCODER_MODE_2] = COUNTER_FUNCTION_QUADRATURE_X2_B,
+-	[STM32_COUNT_ENCODER_MODE_3] = COUNTER_FUNCTION_QUADRATURE_X4,
++	COUNTER_FUNCTION_INCREASE,
++	COUNTER_FUNCTION_QUADRATURE_X2_A,
++	COUNTER_FUNCTION_QUADRATURE_X2_B,
++	COUNTER_FUNCTION_QUADRATURE_X4,
+ };
+ 
+ static int stm32_count_read(struct counter_device *counter,
+-			    struct counter_count *count, unsigned long *val)
++			    struct counter_count *count, u64 *val)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 cnt;
+@@ -70,8 +57,7 @@ static int stm32_count_read(struct counter_device *counter,
+ }
+ 
+ static int stm32_count_write(struct counter_device *counter,
+-			     struct counter_count *count,
+-			     const unsigned long val)
++			     struct counter_count *count, const u64 val)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 ceiling;
+@@ -83,9 +69,9 @@ static int stm32_count_write(struct counter_device *counter,
+ 	return regmap_write(priv->regmap, TIM_CNT, val);
+ }
+ 
+-static int stm32_count_function_get(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    size_t *function)
++static int stm32_count_function_read(struct counter_device *counter,
++				     struct counter_count *count,
++				     enum counter_function *function)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 smcr;
+@@ -93,42 +79,42 @@ static int stm32_count_function_get(struct counter_device *counter,
+ 	regmap_read(priv->regmap, TIM_SMCR, &smcr);
+ 
+ 	switch (smcr & TIM_SMCR_SMS) {
+-	case 0:
+-		*function = STM32_COUNT_SLAVE_MODE_DISABLED;
++	case TIM_SMCR_SMS_SLAVE_MODE_DISABLED:
++		*function = COUNTER_FUNCTION_INCREASE;
+ 		return 0;
+-	case 1:
+-		*function = STM32_COUNT_ENCODER_MODE_1;
++	case TIM_SMCR_SMS_ENCODER_MODE_1:
++		*function = COUNTER_FUNCTION_QUADRATURE_X2_A;
+ 		return 0;
+-	case 2:
+-		*function = STM32_COUNT_ENCODER_MODE_2;
++	case TIM_SMCR_SMS_ENCODER_MODE_2:
++		*function = COUNTER_FUNCTION_QUADRATURE_X2_B;
+ 		return 0;
+-	case 3:
+-		*function = STM32_COUNT_ENCODER_MODE_3;
++	case TIM_SMCR_SMS_ENCODER_MODE_3:
++		*function = COUNTER_FUNCTION_QUADRATURE_X4;
+ 		return 0;
+ 	default:
+ 		return -EINVAL;
+ 	}
+ }
+ 
+-static int stm32_count_function_set(struct counter_device *counter,
+-				    struct counter_count *count,
+-				    size_t function)
++static int stm32_count_function_write(struct counter_device *counter,
++				      struct counter_count *count,
++				      enum counter_function function)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 cr1, sms;
+ 
+ 	switch (function) {
+-	case STM32_COUNT_SLAVE_MODE_DISABLED:
+-		sms = 0;
++	case COUNTER_FUNCTION_INCREASE:
++		sms = TIM_SMCR_SMS_SLAVE_MODE_DISABLED;
+ 		break;
+-	case STM32_COUNT_ENCODER_MODE_1:
+-		sms = 1;
++	case COUNTER_FUNCTION_QUADRATURE_X2_A:
++		sms = TIM_SMCR_SMS_ENCODER_MODE_1;
+ 		break;
+-	case STM32_COUNT_ENCODER_MODE_2:
+-		sms = 2;
++	case COUNTER_FUNCTION_QUADRATURE_X2_B:
++		sms = TIM_SMCR_SMS_ENCODER_MODE_2;
+ 		break;
+-	case STM32_COUNT_ENCODER_MODE_3:
+-		sms = 3;
++	case COUNTER_FUNCTION_QUADRATURE_X4:
++		sms = TIM_SMCR_SMS_ENCODER_MODE_3;
+ 		break;
+ 	default:
+ 		return -EINVAL;
+@@ -150,44 +136,37 @@ static int stm32_count_function_set(struct counter_device *counter,
+ 	return 0;
+ }
+ 
+-static ssize_t stm32_count_direction_read(struct counter_device *counter,
++static int stm32_count_direction_read(struct counter_device *counter,
+ 				      struct counter_count *count,
+-				      void *private, char *buf)
++				      enum counter_count_direction *direction)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+-	const char *direction;
+ 	u32 cr1;
+ 
+ 	regmap_read(priv->regmap, TIM_CR1, &cr1);
+-	direction = (cr1 & TIM_CR1_DIR) ? "backward" : "forward";
++	*direction = (cr1 & TIM_CR1_DIR) ? COUNTER_COUNT_DIRECTION_BACKWARD :
++		COUNTER_COUNT_DIRECTION_FORWARD;
+ 
+-	return scnprintf(buf, PAGE_SIZE, "%s\n", direction);
++	return 0;
+ }
+ 
+-static ssize_t stm32_count_ceiling_read(struct counter_device *counter,
+-					struct counter_count *count,
+-					void *private, char *buf)
++static int stm32_count_ceiling_read(struct counter_device *counter,
++				    struct counter_count *count, u64 *ceiling)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 arr;
+ 
+ 	regmap_read(priv->regmap, TIM_ARR, &arr);
+ 
+-	return snprintf(buf, PAGE_SIZE, "%u\n", arr);
++	*ceiling = arr;
++
++	return 0;
+ }
+ 
+-static ssize_t stm32_count_ceiling_write(struct counter_device *counter,
+-					 struct counter_count *count,
+-					 void *private,
+-					 const char *buf, size_t len)
++static int stm32_count_ceiling_write(struct counter_device *counter,
++				     struct counter_count *count, u64 ceiling)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+-	unsigned int ceiling;
+-	int ret;
+-
+-	ret = kstrtouint(buf, 0, &ceiling);
+-	if (ret)
+-		return ret;
+ 
+ 	if (ceiling > priv->max_arr)
+ 		return -ERANGE;
+@@ -196,34 +175,27 @@ static ssize_t stm32_count_ceiling_write(struct counter_device *counter,
+ 	regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
+ 	regmap_write(priv->regmap, TIM_ARR, ceiling);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t stm32_count_enable_read(struct counter_device *counter,
+-				       struct counter_count *count,
+-				       void *private, char *buf)
++static int stm32_count_enable_read(struct counter_device *counter,
++				   struct counter_count *count, u8 *enable)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+ 	u32 cr1;
+ 
+ 	regmap_read(priv->regmap, TIM_CR1, &cr1);
+ 
+-	return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)(cr1 & TIM_CR1_CEN));
++	*enable = cr1 & TIM_CR1_CEN;
++
++	return 0;
+ }
+ 
+-static ssize_t stm32_count_enable_write(struct counter_device *counter,
+-					struct counter_count *count,
+-					void *private,
+-					const char *buf, size_t len)
++static int stm32_count_enable_write(struct counter_device *counter,
++				    struct counter_count *count, u8 enable)
+ {
+ 	struct stm32_timer_cnt *const priv = counter->priv;
+-	int err;
+ 	u32 cr1;
+-	bool enable;
+-
+-	err = kstrtobool(buf, &enable);
+-	if (err)
+-		return err;
+ 
+ 	if (enable) {
+ 		regmap_read(priv->regmap, TIM_CR1, &cr1);
+@@ -242,70 +214,55 @@ static ssize_t stm32_count_enable_write(struct counter_device *counter,
+ 	/* Keep enabled state to properly handle low power states */
+ 	priv->enabled = enable;
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static const struct counter_count_ext stm32_count_ext[] = {
+-	{
+-		.name = "direction",
+-		.read = stm32_count_direction_read,
+-	},
+-	{
+-		.name = "enable",
+-		.read = stm32_count_enable_read,
+-		.write = stm32_count_enable_write
+-	},
+-	{
+-		.name = "ceiling",
+-		.read = stm32_count_ceiling_read,
+-		.write = stm32_count_ceiling_write
+-	},
+-};
+-
+-enum stm32_synapse_action {
+-	STM32_SYNAPSE_ACTION_NONE,
+-	STM32_SYNAPSE_ACTION_BOTH_EDGES
++static struct counter_comp stm32_count_ext[] = {
++	COUNTER_COMP_DIRECTION(stm32_count_direction_read),
++	COUNTER_COMP_ENABLE(stm32_count_enable_read, stm32_count_enable_write),
++	COUNTER_COMP_CEILING(stm32_count_ceiling_read,
++			     stm32_count_ceiling_write),
+ };
+ 
+ static const enum counter_synapse_action stm32_synapse_actions[] = {
+-	[STM32_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
+-	[STM32_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
++	COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+ };
+ 
+-static int stm32_action_get(struct counter_device *counter,
+-			    struct counter_count *count,
+-			    struct counter_synapse *synapse,
+-			    size_t *action)
++static int stm32_action_read(struct counter_device *counter,
++			     struct counter_count *count,
++			     struct counter_synapse *synapse,
++			     enum counter_synapse_action *action)
+ {
+-	size_t function;
++	enum counter_function function;
+ 	int err;
+ 
+-	err = stm32_count_function_get(counter, count, &function);
++	err = stm32_count_function_read(counter, count, &function);
+ 	if (err)
+ 		return err;
+ 
+ 	switch (function) {
+-	case STM32_COUNT_SLAVE_MODE_DISABLED:
++	case COUNTER_FUNCTION_INCREASE:
+ 		/* counts on internal clock when CEN=1 */
+-		*action = STM32_SYNAPSE_ACTION_NONE;
++		*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 		return 0;
+-	case STM32_COUNT_ENCODER_MODE_1:
++	case COUNTER_FUNCTION_QUADRATURE_X2_A:
+ 		/* counts up/down on TI1FP1 edge depending on TI2FP2 level */
+ 		if (synapse->signal->id == count->synapses[0].signal->id)
+-			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
++			*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		else
+-			*action = STM32_SYNAPSE_ACTION_NONE;
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 		return 0;
+-	case STM32_COUNT_ENCODER_MODE_2:
++	case COUNTER_FUNCTION_QUADRATURE_X2_B:
+ 		/* counts up/down on TI2FP2 edge depending on TI1FP1 level */
+ 		if (synapse->signal->id == count->synapses[1].signal->id)
+-			*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
++			*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		else
+-			*action = STM32_SYNAPSE_ACTION_NONE;
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 		return 0;
+-	case STM32_COUNT_ENCODER_MODE_3:
++	case COUNTER_FUNCTION_QUADRATURE_X4:
+ 		/* counts up/down on both TI1FP1 and TI2FP2 edges */
+-		*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
++		*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		return 0;
+ 	default:
+ 		return -EINVAL;
+@@ -315,9 +272,9 @@ static int stm32_action_get(struct counter_device *counter,
+ static const struct counter_ops stm32_timer_cnt_ops = {
+ 	.count_read = stm32_count_read,
+ 	.count_write = stm32_count_write,
+-	.function_get = stm32_count_function_get,
+-	.function_set = stm32_count_function_set,
+-	.action_get = stm32_action_get,
++	.function_read = stm32_count_function_read,
++	.function_write = stm32_count_function_write,
++	.action_read = stm32_action_read,
+ };
+ 
+ static struct counter_signal stm32_signals[] = {
+diff --git a/drivers/counter/ti-eqep.c b/drivers/counter/ti-eqep.c
+index 94fe58bb3eab3..09817c953f9ab 100644
+--- a/drivers/counter/ti-eqep.c
++++ b/drivers/counter/ti-eqep.c
+@@ -13,6 +13,7 @@
+ #include <linux/platform_device.h>
+ #include <linux/pm_runtime.h>
+ #include <linux/regmap.h>
++#include <linux/types.h>
+ 
+ /* 32-bit registers */
+ #define QPOSCNT		0x0
+@@ -73,19 +74,13 @@ enum {
+ };
+ 
+ /* Position Counter Input Modes */
+-enum {
++enum ti_eqep_count_func {
+ 	TI_EQEP_COUNT_FUNC_QUAD_COUNT,
+ 	TI_EQEP_COUNT_FUNC_DIR_COUNT,
+ 	TI_EQEP_COUNT_FUNC_UP_COUNT,
+ 	TI_EQEP_COUNT_FUNC_DOWN_COUNT,
+ };
+ 
+-enum {
+-	TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES,
+-	TI_EQEP_SYNAPSE_ACTION_RISING_EDGE,
+-	TI_EQEP_SYNAPSE_ACTION_NONE,
+-};
+-
+ struct ti_eqep_cnt {
+ 	struct counter_device counter;
+ 	struct regmap *regmap32;
+@@ -93,7 +88,7 @@ struct ti_eqep_cnt {
+ };
+ 
+ static int ti_eqep_count_read(struct counter_device *counter,
+-			      struct counter_count *count, unsigned long *val)
++			      struct counter_count *count, u64 *val)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+ 	u32 cnt;
+@@ -105,7 +100,7 @@ static int ti_eqep_count_read(struct counter_device *counter,
+ }
+ 
+ static int ti_eqep_count_write(struct counter_device *counter,
+-			       struct counter_count *count, unsigned long val)
++			       struct counter_count *count, u64 val)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+ 	u32 max;
+@@ -117,64 +112,100 @@ static int ti_eqep_count_write(struct counter_device *counter,
+ 	return regmap_write(priv->regmap32, QPOSCNT, val);
+ }
+ 
+-static int ti_eqep_function_get(struct counter_device *counter,
+-				struct counter_count *count, size_t *function)
++static int ti_eqep_function_read(struct counter_device *counter,
++				 struct counter_count *count,
++				 enum counter_function *function)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+ 	u32 qdecctl;
+ 
+ 	regmap_read(priv->regmap16, QDECCTL, &qdecctl);
+-	*function = (qdecctl & QDECCTL_QSRC) >> QDECCTL_QSRC_SHIFT;
++
++	switch ((qdecctl & QDECCTL_QSRC) >> QDECCTL_QSRC_SHIFT) {
++	case TI_EQEP_COUNT_FUNC_QUAD_COUNT:
++		*function = COUNTER_FUNCTION_QUADRATURE_X4;
++		break;
++	case TI_EQEP_COUNT_FUNC_DIR_COUNT:
++		*function = COUNTER_FUNCTION_PULSE_DIRECTION;
++		break;
++	case TI_EQEP_COUNT_FUNC_UP_COUNT:
++		*function = COUNTER_FUNCTION_INCREASE;
++		break;
++	case TI_EQEP_COUNT_FUNC_DOWN_COUNT:
++		*function = COUNTER_FUNCTION_DECREASE;
++		break;
++	}
+ 
+ 	return 0;
+ }
+ 
+-static int ti_eqep_function_set(struct counter_device *counter,
+-				struct counter_count *count, size_t function)
++static int ti_eqep_function_write(struct counter_device *counter,
++				  struct counter_count *count,
++				  enum counter_function function)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
++	enum ti_eqep_count_func qsrc;
++
++	switch (function) {
++	case COUNTER_FUNCTION_QUADRATURE_X4:
++		qsrc = TI_EQEP_COUNT_FUNC_QUAD_COUNT;
++		break;
++	case COUNTER_FUNCTION_PULSE_DIRECTION:
++		qsrc = TI_EQEP_COUNT_FUNC_DIR_COUNT;
++		break;
++	case COUNTER_FUNCTION_INCREASE:
++		qsrc = TI_EQEP_COUNT_FUNC_UP_COUNT;
++		break;
++	case COUNTER_FUNCTION_DECREASE:
++		qsrc = TI_EQEP_COUNT_FUNC_DOWN_COUNT;
++		break;
++	default:
++		/* should never reach this path */
++		return -EINVAL;
++	}
+ 
+ 	return regmap_write_bits(priv->regmap16, QDECCTL, QDECCTL_QSRC,
+-				 function << QDECCTL_QSRC_SHIFT);
++				 qsrc << QDECCTL_QSRC_SHIFT);
+ }
+ 
+-static int ti_eqep_action_get(struct counter_device *counter,
+-			      struct counter_count *count,
+-			      struct counter_synapse *synapse, size_t *action)
++static int ti_eqep_action_read(struct counter_device *counter,
++			       struct counter_count *count,
++			       struct counter_synapse *synapse,
++			       enum counter_synapse_action *action)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+-	size_t function;
++	enum counter_function function;
+ 	u32 qdecctl;
+ 	int err;
+ 
+-	err = ti_eqep_function_get(counter, count, &function);
++	err = ti_eqep_function_read(counter, count, &function);
+ 	if (err)
+ 		return err;
+ 
+ 	switch (function) {
+-	case TI_EQEP_COUNT_FUNC_QUAD_COUNT:
++	case COUNTER_FUNCTION_QUADRATURE_X4:
+ 		/* In quadrature mode, the rising and falling edge of both
+ 		 * QEPA and QEPB trigger QCLK.
+ 		 */
+-		*action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
++		*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 		return 0;
+-	case TI_EQEP_COUNT_FUNC_DIR_COUNT:
++	case COUNTER_FUNCTION_PULSE_DIRECTION:
+ 		/* In direction-count mode only rising edge of QEPA is counted
+ 		 * and QEPB gives direction.
+ 		 */
+ 		switch (synapse->signal->id) {
+ 		case TI_EQEP_SIGNAL_QEPA:
+-			*action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
++			*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 			return 0;
+ 		case TI_EQEP_SIGNAL_QEPB:
+-			*action = TI_EQEP_SYNAPSE_ACTION_NONE;
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 			return 0;
+ 		default:
+ 			/* should never reach this path */
+ 			return -EINVAL;
+ 		}
+-	case TI_EQEP_COUNT_FUNC_UP_COUNT:
+-	case TI_EQEP_COUNT_FUNC_DOWN_COUNT:
++	case COUNTER_FUNCTION_INCREASE:
++	case COUNTER_FUNCTION_DECREASE:
+ 		/* In up/down-count modes only QEPA is counted and QEPB is not
+ 		 * used.
+ 		 */
+@@ -185,12 +216,12 @@ static int ti_eqep_action_get(struct counter_device *counter,
+ 				return err;
+ 
+ 			if (qdecctl & QDECCTL_XCR)
+-				*action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
++				*action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
+ 			else
+-				*action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
++				*action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
+ 			return 0;
+ 		case TI_EQEP_SIGNAL_QEPB:
+-			*action = TI_EQEP_SYNAPSE_ACTION_NONE;
++			*action = COUNTER_SYNAPSE_ACTION_NONE;
+ 			return 0;
+ 		default:
+ 			/* should never reach this path */
+@@ -205,82 +236,67 @@ static int ti_eqep_action_get(struct counter_device *counter,
+ static const struct counter_ops ti_eqep_counter_ops = {
+ 	.count_read	= ti_eqep_count_read,
+ 	.count_write	= ti_eqep_count_write,
+-	.function_get	= ti_eqep_function_get,
+-	.function_set	= ti_eqep_function_set,
+-	.action_get	= ti_eqep_action_get,
++	.function_read	= ti_eqep_function_read,
++	.function_write	= ti_eqep_function_write,
++	.action_read	= ti_eqep_action_read,
+ };
+ 
+-static ssize_t ti_eqep_position_ceiling_read(struct counter_device *counter,
+-					     struct counter_count *count,
+-					     void *ext_priv, char *buf)
++static int ti_eqep_position_ceiling_read(struct counter_device *counter,
++					 struct counter_count *count,
++					 u64 *ceiling)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+ 	u32 qposmax;
+ 
+ 	regmap_read(priv->regmap32, QPOSMAX, &qposmax);
+ 
+-	return sprintf(buf, "%u\n", qposmax);
++	*ceiling = qposmax;
++
++	return 0;
+ }
+ 
+-static ssize_t ti_eqep_position_ceiling_write(struct counter_device *counter,
+-					      struct counter_count *count,
+-					      void *ext_priv, const char *buf,
+-					      size_t len)
++static int ti_eqep_position_ceiling_write(struct counter_device *counter,
++					  struct counter_count *count,
++					  u64 ceiling)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+-	int err;
+-	u32 res;
+ 
+-	err = kstrtouint(buf, 0, &res);
+-	if (err < 0)
+-		return err;
++	if (ceiling != (u32)ceiling)
++		return -ERANGE;
+ 
+-	regmap_write(priv->regmap32, QPOSMAX, res);
++	regmap_write(priv->regmap32, QPOSMAX, ceiling);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static ssize_t ti_eqep_position_enable_read(struct counter_device *counter,
+-					    struct counter_count *count,
+-					    void *ext_priv, char *buf)
++static int ti_eqep_position_enable_read(struct counter_device *counter,
++					struct counter_count *count, u8 *enable)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+ 	u32 qepctl;
+ 
+ 	regmap_read(priv->regmap16, QEPCTL, &qepctl);
+ 
+-	return sprintf(buf, "%u\n", !!(qepctl & QEPCTL_PHEN));
++	*enable = !!(qepctl & QEPCTL_PHEN);
++
++	return 0;
+ }
+ 
+-static ssize_t ti_eqep_position_enable_write(struct counter_device *counter,
+-					     struct counter_count *count,
+-					     void *ext_priv, const char *buf,
+-					     size_t len)
++static int ti_eqep_position_enable_write(struct counter_device *counter,
++					 struct counter_count *count, u8 enable)
+ {
+ 	struct ti_eqep_cnt *priv = counter->priv;
+-	int err;
+-	bool res;
+-
+-	err = kstrtobool(buf, &res);
+-	if (err < 0)
+-		return err;
+ 
+-	regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, res ? -1 : 0);
++	regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, enable ? -1 : 0);
+ 
+-	return len;
++	return 0;
+ }
+ 
+-static struct counter_count_ext ti_eqep_position_ext[] = {
+-	{
+-		.name	= "ceiling",
+-		.read	= ti_eqep_position_ceiling_read,
+-		.write	= ti_eqep_position_ceiling_write,
+-	},
+-	{
+-		.name	= "enable",
+-		.read	= ti_eqep_position_enable_read,
+-		.write	= ti_eqep_position_enable_write,
+-	},
++static struct counter_comp ti_eqep_position_ext[] = {
++	COUNTER_COMP_CEILING(ti_eqep_position_ceiling_read,
++			     ti_eqep_position_ceiling_write),
++	COUNTER_COMP_ENABLE(ti_eqep_position_enable_read,
++			    ti_eqep_position_enable_write),
+ };
+ 
+ static struct counter_signal ti_eqep_signals[] = {
+@@ -295,16 +311,16 @@ static struct counter_signal ti_eqep_signals[] = {
+ };
+ 
+ static const enum counter_function ti_eqep_position_functions[] = {
+-	[TI_EQEP_COUNT_FUNC_QUAD_COUNT]	= COUNTER_FUNCTION_QUADRATURE_X4,
+-	[TI_EQEP_COUNT_FUNC_DIR_COUNT]	= COUNTER_FUNCTION_PULSE_DIRECTION,
+-	[TI_EQEP_COUNT_FUNC_UP_COUNT]	= COUNTER_FUNCTION_INCREASE,
+-	[TI_EQEP_COUNT_FUNC_DOWN_COUNT]	= COUNTER_FUNCTION_DECREASE,
++	COUNTER_FUNCTION_QUADRATURE_X4,
++	COUNTER_FUNCTION_PULSE_DIRECTION,
++	COUNTER_FUNCTION_INCREASE,
++	COUNTER_FUNCTION_DECREASE,
+ };
+ 
+ static const enum counter_synapse_action ti_eqep_position_synapse_actions[] = {
+-	[TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES]	= COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+-	[TI_EQEP_SYNAPSE_ACTION_RISING_EDGE]	= COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+-	[TI_EQEP_SYNAPSE_ACTION_NONE]		= COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
++	COUNTER_SYNAPSE_ACTION_NONE,
+ };
+ 
+ static struct counter_synapse ti_eqep_position_synapses[] = {
+diff --git a/drivers/firmware/efi/sysfb_efi.c b/drivers/firmware/efi/sysfb_efi.c
+index 7ac757843dcfe..24d6f6e08df8b 100644
+--- a/drivers/firmware/efi/sysfb_efi.c
++++ b/drivers/firmware/efi/sysfb_efi.c
+@@ -274,6 +274,14 @@ static const struct dmi_system_id efifb_dmi_swap_width_height[] __initconst = {
+ 					"IdeaPad Duet 3 10IGL5"),
+ 		},
+ 	},
++	{
++		/* Lenovo Yoga Book X91F / X91L */
++		.matches = {
++			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
++			/* Non exact match to match F + L versions */
++			DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X91"),
++		},
++	},
+ 	{},
+ };
+ 
+diff --git a/drivers/gpu/drm/armada/armada_drv.c b/drivers/gpu/drm/armada/armada_drv.c
+index 8e3e98f13db49..54168134d9b93 100644
+--- a/drivers/gpu/drm/armada/armada_drv.c
++++ b/drivers/gpu/drm/armada/armada_drv.c
+@@ -99,7 +99,6 @@ static int armada_drm_bind(struct device *dev)
+ 	if (ret) {
+ 		dev_err(dev, "[" DRM_NAME ":%s] can't kick out simple-fb: %d\n",
+ 			__func__, ret);
+-		kfree(priv);
+ 		return ret;
+ 	}
+ 
+diff --git a/drivers/gpu/drm/drm_panel_orientation_quirks.c b/drivers/gpu/drm/drm_panel_orientation_quirks.c
+index 8768073794fbf..6106fa7c43028 100644
+--- a/drivers/gpu/drm/drm_panel_orientation_quirks.c
++++ b/drivers/gpu/drm/drm_panel_orientation_quirks.c
+@@ -284,10 +284,17 @@ static const struct dmi_system_id orientation_data[] = {
+ 		  DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "IdeaPad Duet 3 10IGL5"),
+ 		},
+ 		.driver_data = (void *)&lcd1200x1920_rightside_up,
+-	}, {	/* Lenovo Yoga Book X90F / X91F / X91L */
++	}, {	/* Lenovo Yoga Book X90F / X90L */
+ 		.matches = {
+-		  /* Non exact match to match all versions */
+-		  DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9"),
++		  DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
++		  DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "CHERRYVIEW D1 PLATFORM"),
++		  DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "YETI-11"),
++		},
++		.driver_data = (void *)&lcd1200x1920_rightside_up,
++	}, {	/* Lenovo Yoga Book X91F / X91L */
++		.matches = {
++		  /* Non exact match to match F + L versions */
++		  DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X91"),
+ 		},
+ 		.driver_data = (void *)&lcd1200x1920_rightside_up,
+ 	}, {	/* OneGX1 Pro */
+diff --git a/drivers/gpu/drm/i915/display/icl_dsi.c b/drivers/gpu/drm/i915/display/icl_dsi.c
+index 2601873e15466..26dd5a2bd5024 100644
+--- a/drivers/gpu/drm/i915/display/icl_dsi.c
++++ b/drivers/gpu/drm/i915/display/icl_dsi.c
+@@ -307,9 +307,21 @@ static void configure_dual_link_mode(struct intel_encoder *encoder,
+ {
+ 	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+ 	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
++	i915_reg_t dss_ctl1_reg, dss_ctl2_reg;
+ 	u32 dss_ctl1;
+ 
+-	dss_ctl1 = intel_de_read(dev_priv, DSS_CTL1);
++	/* FIXME: Move all DSS handling to intel_vdsc.c */
++	if (DISPLAY_VER(dev_priv) >= 12) {
++		struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
++
++		dss_ctl1_reg = ICL_PIPE_DSS_CTL1(crtc->pipe);
++		dss_ctl2_reg = ICL_PIPE_DSS_CTL2(crtc->pipe);
++	} else {
++		dss_ctl1_reg = DSS_CTL1;
++		dss_ctl2_reg = DSS_CTL2;
++	}
++
++	dss_ctl1 = intel_de_read(dev_priv, dss_ctl1_reg);
+ 	dss_ctl1 |= SPLITTER_ENABLE;
+ 	dss_ctl1 &= ~OVERLAP_PIXELS_MASK;
+ 	dss_ctl1 |= OVERLAP_PIXELS(intel_dsi->pixel_overlap);
+@@ -330,16 +342,16 @@ static void configure_dual_link_mode(struct intel_encoder *encoder,
+ 
+ 		dss_ctl1 &= ~LEFT_DL_BUF_TARGET_DEPTH_MASK;
+ 		dss_ctl1 |= LEFT_DL_BUF_TARGET_DEPTH(dl_buffer_depth);
+-		dss_ctl2 = intel_de_read(dev_priv, DSS_CTL2);
++		dss_ctl2 = intel_de_read(dev_priv, dss_ctl2_reg);
+ 		dss_ctl2 &= ~RIGHT_DL_BUF_TARGET_DEPTH_MASK;
+ 		dss_ctl2 |= RIGHT_DL_BUF_TARGET_DEPTH(dl_buffer_depth);
+-		intel_de_write(dev_priv, DSS_CTL2, dss_ctl2);
++		intel_de_write(dev_priv, dss_ctl2_reg, dss_ctl2);
+ 	} else {
+ 		/* Interleave */
+ 		dss_ctl1 |= DUAL_LINK_MODE_INTERLEAVE;
+ 	}
+ 
+-	intel_de_write(dev_priv, DSS_CTL1, dss_ctl1);
++	intel_de_write(dev_priv, dss_ctl1_reg, dss_ctl1);
+ }
+ 
+ /* aka DSI 8X clock */
+diff --git a/drivers/gpu/drm/i915/i915_perf.c b/drivers/gpu/drm/i915/i915_perf.c
+index f3c8f87d25ae0..774d45142091b 100644
+--- a/drivers/gpu/drm/i915/i915_perf.c
++++ b/drivers/gpu/drm/i915/i915_perf.c
+@@ -879,8 +879,9 @@ static int gen8_oa_read(struct i915_perf_stream *stream,
+ 		if (ret)
+ 			return ret;
+ 
+-		DRM_DEBUG("OA buffer overflow (exponent = %d): force restart\n",
+-			  stream->period_exponent);
++		drm_dbg(&stream->perf->i915->drm,
++			"OA buffer overflow (exponent = %d): force restart\n",
++			stream->period_exponent);
+ 
+ 		stream->perf->ops.oa_disable(stream);
+ 		stream->perf->ops.oa_enable(stream);
+@@ -1102,8 +1103,9 @@ static int gen7_oa_read(struct i915_perf_stream *stream,
+ 		if (ret)
+ 			return ret;
+ 
+-		DRM_DEBUG("OA buffer overflow (exponent = %d): force restart\n",
+-			  stream->period_exponent);
++		drm_dbg(&stream->perf->i915->drm,
++			"OA buffer overflow (exponent = %d): force restart\n",
++			stream->period_exponent);
+ 
+ 		stream->perf->ops.oa_disable(stream);
+ 		stream->perf->ops.oa_enable(stream);
+@@ -2857,7 +2859,8 @@ static int i915_oa_stream_init(struct i915_perf_stream *stream,
+ 	int ret;
+ 
+ 	if (!props->engine) {
+-		DRM_DEBUG("OA engine not specified\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"OA engine not specified\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -2867,18 +2870,21 @@ static int i915_oa_stream_init(struct i915_perf_stream *stream,
+ 	 * IDs
+ 	 */
+ 	if (!perf->metrics_kobj) {
+-		DRM_DEBUG("OA metrics weren't advertised via sysfs\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"OA metrics weren't advertised via sysfs\n");
+ 		return -EINVAL;
+ 	}
+ 
+ 	if (!(props->sample_flags & SAMPLE_OA_REPORT) &&
+ 	    (GRAPHICS_VER(perf->i915) < 12 || !stream->ctx)) {
+-		DRM_DEBUG("Only OA report sampling supported\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"Only OA report sampling supported\n");
+ 		return -EINVAL;
+ 	}
+ 
+ 	if (!perf->ops.enable_metric_set) {
+-		DRM_DEBUG("OA unit not supported\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"OA unit not supported\n");
+ 		return -ENODEV;
+ 	}
+ 
+@@ -2888,12 +2894,14 @@ static int i915_oa_stream_init(struct i915_perf_stream *stream,
+ 	 * we currently only allow exclusive access
+ 	 */
+ 	if (perf->exclusive_stream) {
+-		DRM_DEBUG("OA unit already in use\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"OA unit already in use\n");
+ 		return -EBUSY;
+ 	}
+ 
+ 	if (!props->oa_format) {
+-		DRM_DEBUG("OA report format not specified\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"OA report format not specified\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -2923,20 +2931,23 @@ static int i915_oa_stream_init(struct i915_perf_stream *stream,
+ 	if (stream->ctx) {
+ 		ret = oa_get_render_ctx_id(stream);
+ 		if (ret) {
+-			DRM_DEBUG("Invalid context id to filter with\n");
++			drm_dbg(&stream->perf->i915->drm,
++				"Invalid context id to filter with\n");
+ 			return ret;
+ 		}
+ 	}
+ 
+ 	ret = alloc_noa_wait(stream);
+ 	if (ret) {
+-		DRM_DEBUG("Unable to allocate NOA wait batch buffer\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"Unable to allocate NOA wait batch buffer\n");
+ 		goto err_noa_wait_alloc;
+ 	}
+ 
+ 	stream->oa_config = i915_perf_get_oa_config(perf, props->metrics_set);
+ 	if (!stream->oa_config) {
+-		DRM_DEBUG("Invalid OA config id=%i\n", props->metrics_set);
++		drm_dbg(&stream->perf->i915->drm,
++			"Invalid OA config id=%i\n", props->metrics_set);
+ 		ret = -EINVAL;
+ 		goto err_config;
+ 	}
+@@ -2967,11 +2978,13 @@ static int i915_oa_stream_init(struct i915_perf_stream *stream,
+ 
+ 	ret = i915_perf_stream_enable_sync(stream);
+ 	if (ret) {
+-		DRM_DEBUG("Unable to enable metric set\n");
++		drm_dbg(&stream->perf->i915->drm,
++			"Unable to enable metric set\n");
+ 		goto err_enable;
+ 	}
+ 
+-	DRM_DEBUG("opening stream oa config uuid=%s\n",
++	drm_dbg(&stream->perf->i915->drm,
++		"opening stream oa config uuid=%s\n",
+ 		  stream->oa_config->uuid);
+ 
+ 	hrtimer_init(&stream->poll_check_timer,
+@@ -3423,7 +3436,8 @@ i915_perf_open_ioctl_locked(struct i915_perf *perf,
+ 
+ 		specific_ctx = i915_gem_context_lookup(file_priv, ctx_handle);
+ 		if (IS_ERR(specific_ctx)) {
+-			DRM_DEBUG("Failed to look up context with ID %u for opening perf stream\n",
++			drm_dbg(&perf->i915->drm,
++				"Failed to look up context with ID %u for opening perf stream\n",
+ 				  ctx_handle);
+ 			ret = PTR_ERR(specific_ctx);
+ 			goto err;
+@@ -3457,7 +3471,8 @@ i915_perf_open_ioctl_locked(struct i915_perf *perf,
+ 
+ 	if (props->hold_preemption) {
+ 		if (!props->single_context) {
+-			DRM_DEBUG("preemption disable with no context\n");
++			drm_dbg(&perf->i915->drm,
++				"preemption disable with no context\n");
+ 			ret = -EINVAL;
+ 			goto err;
+ 		}
+@@ -3479,7 +3494,8 @@ i915_perf_open_ioctl_locked(struct i915_perf *perf,
+ 	 */
+ 	if (privileged_op &&
+ 	    i915_perf_stream_paranoid && !perfmon_capable()) {
+-		DRM_DEBUG("Insufficient privileges to open i915 perf stream\n");
++		drm_dbg(&perf->i915->drm,
++			"Insufficient privileges to open i915 perf stream\n");
+ 		ret = -EACCES;
+ 		goto err_ctx;
+ 	}
+@@ -3586,7 +3602,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 	props->poll_oa_period = DEFAULT_POLL_PERIOD_NS;
+ 
+ 	if (!n_props) {
+-		DRM_DEBUG("No i915 perf properties given\n");
++		drm_dbg(&perf->i915->drm,
++			"No i915 perf properties given\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -3595,7 +3612,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 						 I915_ENGINE_CLASS_RENDER,
+ 						 0);
+ 	if (!props->engine) {
+-		DRM_DEBUG("No RENDER-capable engines\n");
++		drm_dbg(&perf->i915->drm,
++			"No RENDER-capable engines\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -3606,7 +3624,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 	 * from userspace.
+ 	 */
+ 	if (n_props >= DRM_I915_PERF_PROP_MAX) {
+-		DRM_DEBUG("More i915 perf properties specified than exist\n");
++		drm_dbg(&perf->i915->drm,
++			"More i915 perf properties specified than exist\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -3623,7 +3642,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 			return ret;
+ 
+ 		if (id == 0 || id >= DRM_I915_PERF_PROP_MAX) {
+-			DRM_DEBUG("Unknown i915 perf property ID\n");
++			drm_dbg(&perf->i915->drm,
++				"Unknown i915 perf property ID\n");
+ 			return -EINVAL;
+ 		}
+ 
+@@ -3638,19 +3658,22 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 			break;
+ 		case DRM_I915_PERF_PROP_OA_METRICS_SET:
+ 			if (value == 0) {
+-				DRM_DEBUG("Unknown OA metric set ID\n");
++				drm_dbg(&perf->i915->drm,
++					"Unknown OA metric set ID\n");
+ 				return -EINVAL;
+ 			}
+ 			props->metrics_set = value;
+ 			break;
+ 		case DRM_I915_PERF_PROP_OA_FORMAT:
+ 			if (value == 0 || value >= I915_OA_FORMAT_MAX) {
+-				DRM_DEBUG("Out-of-range OA report format %llu\n",
++				drm_dbg(&perf->i915->drm,
++					"Out-of-range OA report format %llu\n",
+ 					  value);
+ 				return -EINVAL;
+ 			}
+ 			if (!oa_format_valid(perf, value)) {
+-				DRM_DEBUG("Unsupported OA report format %llu\n",
++				drm_dbg(&perf->i915->drm,
++					"Unsupported OA report format %llu\n",
+ 					  value);
+ 				return -EINVAL;
+ 			}
+@@ -3658,7 +3681,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 			break;
+ 		case DRM_I915_PERF_PROP_OA_EXPONENT:
+ 			if (value > OA_EXPONENT_MAX) {
+-				DRM_DEBUG("OA timer exponent too high (> %u)\n",
++				drm_dbg(&perf->i915->drm,
++					"OA timer exponent too high (> %u)\n",
+ 					 OA_EXPONENT_MAX);
+ 				return -EINVAL;
+ 			}
+@@ -3686,7 +3710,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 				oa_freq_hz = 0;
+ 
+ 			if (oa_freq_hz > i915_oa_max_sample_rate && !perfmon_capable()) {
+-				DRM_DEBUG("OA exponent would exceed the max sampling frequency (sysctl dev.i915.oa_max_sample_rate) %uHz without CAP_PERFMON or CAP_SYS_ADMIN privileges\n",
++				drm_dbg(&perf->i915->drm,
++					"OA exponent would exceed the max sampling frequency (sysctl dev.i915.oa_max_sample_rate) %uHz without CAP_PERFMON or CAP_SYS_ADMIN privileges\n",
+ 					  i915_oa_max_sample_rate);
+ 				return -EACCES;
+ 			}
+@@ -3703,13 +3728,15 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 			if (copy_from_user(&user_sseu,
+ 					   u64_to_user_ptr(value),
+ 					   sizeof(user_sseu))) {
+-				DRM_DEBUG("Unable to copy global sseu parameter\n");
++				drm_dbg(&perf->i915->drm,
++					"Unable to copy global sseu parameter\n");
+ 				return -EFAULT;
+ 			}
+ 
+ 			ret = get_sseu_config(&props->sseu, props->engine, &user_sseu);
+ 			if (ret) {
+-				DRM_DEBUG("Invalid SSEU configuration\n");
++				drm_dbg(&perf->i915->drm,
++					"Invalid SSEU configuration\n");
+ 				return ret;
+ 			}
+ 			props->has_sseu = true;
+@@ -3717,7 +3744,8 @@ static int read_properties_unlocked(struct i915_perf *perf,
+ 		}
+ 		case DRM_I915_PERF_PROP_POLL_OA_PERIOD:
+ 			if (value < 100000 /* 100us */) {
+-				DRM_DEBUG("OA availability timer too small (%lluns < 100us)\n",
++				drm_dbg(&perf->i915->drm,
++					"OA availability timer too small (%lluns < 100us)\n",
+ 					  value);
+ 				return -EINVAL;
+ 			}
+@@ -3768,7 +3796,8 @@ int i915_perf_open_ioctl(struct drm_device *dev, void *data,
+ 	int ret;
+ 
+ 	if (!perf->i915) {
+-		DRM_DEBUG("i915 perf interface not available for this system\n");
++		drm_dbg(&perf->i915->drm,
++			"i915 perf interface not available for this system\n");
+ 		return -ENOTSUPP;
+ 	}
+ 
+@@ -3776,7 +3805,8 @@ int i915_perf_open_ioctl(struct drm_device *dev, void *data,
+ 			   I915_PERF_FLAG_FD_NONBLOCK |
+ 			   I915_PERF_FLAG_DISABLED;
+ 	if (param->flags & ~known_open_flags) {
+-		DRM_DEBUG("Unknown drm_i915_perf_open_param flag\n");
++		drm_dbg(&perf->i915->drm,
++			"Unknown drm_i915_perf_open_param flag\n");
+ 		return -EINVAL;
+ 	}
+ 
+@@ -3986,7 +4016,8 @@ static struct i915_oa_reg *alloc_oa_regs(struct i915_perf *perf,
+ 			goto addr_err;
+ 
+ 		if (!is_valid(perf, addr)) {
+-			DRM_DEBUG("Invalid oa_reg address: %X\n", addr);
++			drm_dbg(&perf->i915->drm,
++				"Invalid oa_reg address: %X\n", addr);
+ 			err = -EINVAL;
+ 			goto addr_err;
+ 		}
+@@ -4060,30 +4091,35 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 	int err, id;
+ 
+ 	if (!perf->i915) {
+-		DRM_DEBUG("i915 perf interface not available for this system\n");
++		drm_dbg(&perf->i915->drm,
++			"i915 perf interface not available for this system\n");
+ 		return -ENOTSUPP;
+ 	}
+ 
+ 	if (!perf->metrics_kobj) {
+-		DRM_DEBUG("OA metrics weren't advertised via sysfs\n");
++		drm_dbg(&perf->i915->drm,
++			"OA metrics weren't advertised via sysfs\n");
+ 		return -EINVAL;
+ 	}
+ 
+ 	if (i915_perf_stream_paranoid && !perfmon_capable()) {
+-		DRM_DEBUG("Insufficient privileges to add i915 OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Insufficient privileges to add i915 OA config\n");
+ 		return -EACCES;
+ 	}
+ 
+ 	if ((!args->mux_regs_ptr || !args->n_mux_regs) &&
+ 	    (!args->boolean_regs_ptr || !args->n_boolean_regs) &&
+ 	    (!args->flex_regs_ptr || !args->n_flex_regs)) {
+-		DRM_DEBUG("No OA registers given\n");
++		drm_dbg(&perf->i915->drm,
++			"No OA registers given\n");
+ 		return -EINVAL;
+ 	}
+ 
+ 	oa_config = kzalloc(sizeof(*oa_config), GFP_KERNEL);
+ 	if (!oa_config) {
+-		DRM_DEBUG("Failed to allocate memory for the OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to allocate memory for the OA config\n");
+ 		return -ENOMEM;
+ 	}
+ 
+@@ -4091,7 +4127,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 	kref_init(&oa_config->ref);
+ 
+ 	if (!uuid_is_valid(args->uuid)) {
+-		DRM_DEBUG("Invalid uuid format for OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Invalid uuid format for OA config\n");
+ 		err = -EINVAL;
+ 		goto reg_err;
+ 	}
+@@ -4108,7 +4145,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 			     args->n_mux_regs);
+ 
+ 	if (IS_ERR(regs)) {
+-		DRM_DEBUG("Failed to create OA config for mux_regs\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to create OA config for mux_regs\n");
+ 		err = PTR_ERR(regs);
+ 		goto reg_err;
+ 	}
+@@ -4121,7 +4159,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 			     args->n_boolean_regs);
+ 
+ 	if (IS_ERR(regs)) {
+-		DRM_DEBUG("Failed to create OA config for b_counter_regs\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to create OA config for b_counter_regs\n");
+ 		err = PTR_ERR(regs);
+ 		goto reg_err;
+ 	}
+@@ -4140,7 +4179,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 				     args->n_flex_regs);
+ 
+ 		if (IS_ERR(regs)) {
+-			DRM_DEBUG("Failed to create OA config for flex_regs\n");
++			drm_dbg(&perf->i915->drm,
++				"Failed to create OA config for flex_regs\n");
+ 			err = PTR_ERR(regs);
+ 			goto reg_err;
+ 		}
+@@ -4156,7 +4196,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 	 */
+ 	idr_for_each_entry(&perf->metrics_idr, tmp, id) {
+ 		if (!strcmp(tmp->uuid, oa_config->uuid)) {
+-			DRM_DEBUG("OA config already exists with this uuid\n");
++			drm_dbg(&perf->i915->drm,
++				"OA config already exists with this uuid\n");
+ 			err = -EADDRINUSE;
+ 			goto sysfs_err;
+ 		}
+@@ -4164,7 +4205,8 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 
+ 	err = create_dynamic_oa_sysfs_entry(perf, oa_config);
+ 	if (err) {
+-		DRM_DEBUG("Failed to create sysfs entry for OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to create sysfs entry for OA config\n");
+ 		goto sysfs_err;
+ 	}
+ 
+@@ -4173,22 +4215,25 @@ int i915_perf_add_config_ioctl(struct drm_device *dev, void *data,
+ 				  oa_config, 2,
+ 				  0, GFP_KERNEL);
+ 	if (oa_config->id < 0) {
+-		DRM_DEBUG("Failed to create sysfs entry for OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to create sysfs entry for OA config\n");
+ 		err = oa_config->id;
+ 		goto sysfs_err;
+ 	}
++	id = oa_config->id;
+ 
++	drm_dbg(&perf->i915->drm,
++		"Added config %s id=%i\n", oa_config->uuid, oa_config->id);
+ 	mutex_unlock(&perf->metrics_lock);
+ 
+-	DRM_DEBUG("Added config %s id=%i\n", oa_config->uuid, oa_config->id);
+-
+-	return oa_config->id;
++	return id;
+ 
+ sysfs_err:
+ 	mutex_unlock(&perf->metrics_lock);
+ reg_err:
+ 	i915_oa_config_put(oa_config);
+-	DRM_DEBUG("Failed to add new OA config\n");
++	drm_dbg(&perf->i915->drm,
++		"Failed to add new OA config\n");
+ 	return err;
+ }
+ 
+@@ -4212,12 +4257,14 @@ int i915_perf_remove_config_ioctl(struct drm_device *dev, void *data,
+ 	int ret;
+ 
+ 	if (!perf->i915) {
+-		DRM_DEBUG("i915 perf interface not available for this system\n");
++		drm_dbg(&perf->i915->drm,
++			"i915 perf interface not available for this system\n");
+ 		return -ENOTSUPP;
+ 	}
+ 
+ 	if (i915_perf_stream_paranoid && !perfmon_capable()) {
+-		DRM_DEBUG("Insufficient privileges to remove i915 OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Insufficient privileges to remove i915 OA config\n");
+ 		return -EACCES;
+ 	}
+ 
+@@ -4227,7 +4274,8 @@ int i915_perf_remove_config_ioctl(struct drm_device *dev, void *data,
+ 
+ 	oa_config = idr_find(&perf->metrics_idr, *arg);
+ 	if (!oa_config) {
+-		DRM_DEBUG("Failed to remove unknown OA config\n");
++		drm_dbg(&perf->i915->drm,
++			"Failed to remove unknown OA config\n");
+ 		ret = -ENOENT;
+ 		goto err_unlock;
+ 	}
+@@ -4240,7 +4288,8 @@ int i915_perf_remove_config_ioctl(struct drm_device *dev, void *data,
+ 
+ 	mutex_unlock(&perf->metrics_lock);
+ 
+-	DRM_DEBUG("Removed config %s id=%i\n", oa_config->uuid, oa_config->id);
++	drm_dbg(&perf->i915->drm,
++		"Removed config %s id=%i\n", oa_config->uuid, oa_config->id);
+ 
+ 	i915_oa_config_put(oa_config);
+ 
+diff --git a/drivers/i2c/busses/i2c-hisi.c b/drivers/i2c/busses/i2c-hisi.c
+index 72e43ecaff133..1f406e6f4ece3 100644
+--- a/drivers/i2c/busses/i2c-hisi.c
++++ b/drivers/i2c/busses/i2c-hisi.c
+@@ -315,6 +315,13 @@ static void hisi_i2c_xfer_msg(struct hisi_i2c_controller *ctlr)
+ 		    max_write == 0)
+ 			break;
+ 	}
++
++	/*
++	 * Disable the TX_EMPTY interrupt after finishing all the messages to
++	 * avoid overwhelming the CPU.
++	 */
++	if (ctlr->msg_tx_idx == ctlr->msg_num)
++		hisi_i2c_disable_int(ctlr, HISI_I2C_INT_TX_EMPTY);
+ }
+ 
+ static irqreturn_t hisi_i2c_irq(int irq, void *context)
+diff --git a/drivers/i2c/busses/i2c-imx-lpi2c.c b/drivers/i2c/busses/i2c-imx-lpi2c.c
+index 2018dbcf241e9..d45ec26d51cb9 100644
+--- a/drivers/i2c/busses/i2c-imx-lpi2c.c
++++ b/drivers/i2c/busses/i2c-imx-lpi2c.c
+@@ -462,6 +462,8 @@ static int lpi2c_imx_xfer(struct i2c_adapter *adapter,
+ 		if (num == 1 && msgs[0].len == 0)
+ 			goto stop;
+ 
++		lpi2c_imx->rx_buf = NULL;
++		lpi2c_imx->tx_buf = NULL;
+ 		lpi2c_imx->delivered = 0;
+ 		lpi2c_imx->msglen = msgs[i].len;
+ 		init_completion(&lpi2c_imx->complete);
+diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c
+index a0af027db04c1..2e575856c5cd5 100644
+--- a/drivers/i2c/busses/i2c-ocores.c
++++ b/drivers/i2c/busses/i2c-ocores.c
+@@ -342,18 +342,18 @@ static int ocores_poll_wait(struct ocores_i2c *i2c)
+  * ocores_isr(), we just add our polling code around it.
+  *
+  * It can run in atomic context
++ *
++ * Return: 0 on success, -ETIMEDOUT on timeout
+  */
+-static void ocores_process_polling(struct ocores_i2c *i2c)
++static int ocores_process_polling(struct ocores_i2c *i2c)
+ {
+-	while (1) {
+-		irqreturn_t ret;
+-		int err;
++	irqreturn_t ret;
++	int err = 0;
+ 
++	while (1) {
+ 		err = ocores_poll_wait(i2c);
+-		if (err) {
+-			i2c->state = STATE_ERROR;
++		if (err)
+ 			break; /* timeout */
+-		}
+ 
+ 		ret = ocores_isr(-1, i2c);
+ 		if (ret == IRQ_NONE)
+@@ -364,13 +364,15 @@ static void ocores_process_polling(struct ocores_i2c *i2c)
+ 					break;
+ 		}
+ 	}
++
++	return err;
+ }
+ 
+ static int ocores_xfer_core(struct ocores_i2c *i2c,
+ 			    struct i2c_msg *msgs, int num,
+ 			    bool polling)
+ {
+-	int ret;
++	int ret = 0;
+ 	u8 ctrl;
+ 
+ 	ctrl = oc_getreg(i2c, OCI2C_CONTROL);
+@@ -388,15 +390,16 @@ static int ocores_xfer_core(struct ocores_i2c *i2c,
+ 	oc_setreg(i2c, OCI2C_CMD, OCI2C_CMD_START);
+ 
+ 	if (polling) {
+-		ocores_process_polling(i2c);
++		ret = ocores_process_polling(i2c);
+ 	} else {
+-		ret = wait_event_timeout(i2c->wait,
+-					 (i2c->state == STATE_ERROR) ||
+-					 (i2c->state == STATE_DONE), HZ);
+-		if (ret == 0) {
+-			ocores_process_timeout(i2c);
+-			return -ETIMEDOUT;
+-		}
++		if (wait_event_timeout(i2c->wait,
++				       (i2c->state == STATE_ERROR) ||
++				       (i2c->state == STATE_DONE), HZ) == 0)
++			ret = -ETIMEDOUT;
++	}
++	if (ret) {
++		ocores_process_timeout(i2c);
++		return ret;
+ 	}
+ 
+ 	return (i2c->state == STATE_DONE) ? num : -EIO;
+diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
+index fd192104fd8d3..c66d8bf405854 100644
+--- a/drivers/infiniband/core/cma.c
++++ b/drivers/infiniband/core/cma.c
+@@ -496,22 +496,11 @@ static inline unsigned short cma_family(struct rdma_id_private *id_priv)
+ 	return id_priv->id.route.addr.src_addr.ss_family;
+ }
+ 
+-static int cma_set_qkey(struct rdma_id_private *id_priv, u32 qkey)
++static int cma_set_default_qkey(struct rdma_id_private *id_priv)
+ {
+ 	struct ib_sa_mcmember_rec rec;
+ 	int ret = 0;
+ 
+-	if (id_priv->qkey) {
+-		if (qkey && id_priv->qkey != qkey)
+-			return -EINVAL;
+-		return 0;
+-	}
+-
+-	if (qkey) {
+-		id_priv->qkey = qkey;
+-		return 0;
+-	}
+-
+ 	switch (id_priv->id.ps) {
+ 	case RDMA_PS_UDP:
+ 	case RDMA_PS_IB:
+@@ -531,6 +520,16 @@ static int cma_set_qkey(struct rdma_id_private *id_priv, u32 qkey)
+ 	return ret;
+ }
+ 
++static int cma_set_qkey(struct rdma_id_private *id_priv, u32 qkey)
++{
++	if (!qkey ||
++	    (id_priv->qkey && (id_priv->qkey != qkey)))
++		return -EINVAL;
++
++	id_priv->qkey = qkey;
++	return 0;
++}
++
+ static void cma_translate_ib(struct sockaddr_ib *sib, struct rdma_dev_addr *dev_addr)
+ {
+ 	dev_addr->dev_type = ARPHRD_INFINIBAND;
+@@ -1099,7 +1098,7 @@ static int cma_ib_init_qp_attr(struct rdma_id_private *id_priv,
+ 	*qp_attr_mask = IB_QP_STATE | IB_QP_PKEY_INDEX | IB_QP_PORT;
+ 
+ 	if (id_priv->id.qp_type == IB_QPT_UD) {
+-		ret = cma_set_qkey(id_priv, 0);
++		ret = cma_set_default_qkey(id_priv);
+ 		if (ret)
+ 			return ret;
+ 
+@@ -4373,7 +4372,10 @@ static int cma_send_sidr_rep(struct rdma_id_private *id_priv,
+ 	memset(&rep, 0, sizeof rep);
+ 	rep.status = status;
+ 	if (status == IB_SIDR_SUCCESS) {
+-		ret = cma_set_qkey(id_priv, qkey);
++		if (qkey)
++			ret = cma_set_qkey(id_priv, qkey);
++		else
++			ret = cma_set_default_qkey(id_priv);
+ 		if (ret)
+ 			return ret;
+ 		rep.qp_num = id_priv->qp_num;
+@@ -4578,9 +4580,7 @@ static void cma_make_mc_event(int status, struct rdma_id_private *id_priv,
+ 	enum ib_gid_type gid_type;
+ 	struct net_device *ndev;
+ 
+-	if (!status)
+-		status = cma_set_qkey(id_priv, be32_to_cpu(multicast->rec.qkey));
+-	else
++	if (status)
+ 		pr_debug_ratelimited("RDMA CM: MULTICAST_ERROR: failed to join multicast. status %d\n",
+ 				     status);
+ 
+@@ -4608,7 +4608,7 @@ static void cma_make_mc_event(int status, struct rdma_id_private *id_priv,
+ 	}
+ 
+ 	event->param.ud.qp_num = 0xFFFFFF;
+-	event->param.ud.qkey = be32_to_cpu(multicast->rec.qkey);
++	event->param.ud.qkey = id_priv->qkey;
+ 
+ out:
+ 	if (ndev)
+@@ -4627,8 +4627,11 @@ static int cma_ib_mc_handler(int status, struct ib_sa_multicast *multicast)
+ 	    READ_ONCE(id_priv->state) == RDMA_CM_DESTROYING)
+ 		goto out;
+ 
+-	cma_make_mc_event(status, id_priv, multicast, &event, mc);
+-	ret = cma_cm_event_handler(id_priv, &event);
++	ret = cma_set_qkey(id_priv, be32_to_cpu(multicast->rec.qkey));
++	if (!ret) {
++		cma_make_mc_event(status, id_priv, multicast, &event, mc);
++		ret = cma_cm_event_handler(id_priv, &event);
++	}
+ 	rdma_destroy_ah_attr(&event.param.ud.ah_attr);
+ 	WARN_ON(ret);
+ 
+@@ -4681,9 +4684,11 @@ static int cma_join_ib_multicast(struct rdma_id_private *id_priv,
+ 	if (ret)
+ 		return ret;
+ 
+-	ret = cma_set_qkey(id_priv, 0);
+-	if (ret)
+-		return ret;
++	if (!id_priv->qkey) {
++		ret = cma_set_default_qkey(id_priv);
++		if (ret)
++			return ret;
++	}
+ 
+ 	cma_set_mgid(id_priv, (struct sockaddr *) &mc->addr, &rec.mgid);
+ 	rec.qkey = cpu_to_be32(id_priv->qkey);
+@@ -4760,9 +4765,6 @@ static int cma_iboe_join_multicast(struct rdma_id_private *id_priv,
+ 	cma_iboe_set_mgid(addr, &ib.rec.mgid, gid_type);
+ 
+ 	ib.rec.pkey = cpu_to_be16(0xffff);
+-	if (id_priv->id.ps == RDMA_PS_UDP)
+-		ib.rec.qkey = cpu_to_be32(RDMA_UDP_QKEY);
+-
+ 	if (dev_addr->bound_dev_if)
+ 		ndev = dev_get_by_index(dev_addr->net, dev_addr->bound_dev_if);
+ 	if (!ndev)
+@@ -4788,6 +4790,9 @@ static int cma_iboe_join_multicast(struct rdma_id_private *id_priv,
+ 	if (err || !ib.rec.mtu)
+ 		return err ?: -EINVAL;
+ 
++	if (!id_priv->qkey)
++		cma_set_default_qkey(id_priv);
++
+ 	rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
+ 		    &ib.rec.port_gid);
+ 	INIT_WORK(&mc->iboe_join.work, cma_iboe_join_work_handler);
+@@ -4813,6 +4818,9 @@ int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
+ 			    READ_ONCE(id_priv->state) != RDMA_CM_ADDR_RESOLVED))
+ 		return -EINVAL;
+ 
++	if (id_priv->id.qp_type != IB_QPT_UD)
++		return -EINVAL;
++
+ 	mc = kzalloc(sizeof(*mc), GFP_KERNEL);
+ 	if (!mc)
+ 		return -ENOMEM;
+diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
+index f0c07e4ba4388..cae013130eb1d 100644
+--- a/drivers/infiniband/core/verbs.c
++++ b/drivers/infiniband/core/verbs.c
+@@ -540,6 +540,8 @@ static struct ib_ah *_rdma_create_ah(struct ib_pd *pd,
+ 	else
+ 		ret = device->ops.create_ah(ah, &init_attr, NULL);
+ 	if (ret) {
++		if (ah->sgid_attr)
++			rdma_put_gid_attr(ah->sgid_attr);
+ 		kfree(ah);
+ 		return ERR_PTR(ret);
+ 	}
+diff --git a/drivers/infiniband/hw/irdma/cm.c b/drivers/infiniband/hw/irdma/cm.c
+index a8ec3d8f6e465..64d4bb0e9a12f 100644
+--- a/drivers/infiniband/hw/irdma/cm.c
++++ b/drivers/infiniband/hw/irdma/cm.c
+@@ -1458,13 +1458,15 @@ static int irdma_send_fin(struct irdma_cm_node *cm_node)
+  * irdma_find_listener - find a cm node listening on this addr-port pair
+  * @cm_core: cm's core
+  * @dst_addr: listener ip addr
++ * @ipv4: flag indicating IPv4 when true
+  * @dst_port: listener tcp port num
+  * @vlan_id: virtual LAN ID
+  * @listener_state: state to match with listen node's
+  */
+ static struct irdma_cm_listener *
+-irdma_find_listener(struct irdma_cm_core *cm_core, u32 *dst_addr, u16 dst_port,
+-		    u16 vlan_id, enum irdma_cm_listener_state listener_state)
++irdma_find_listener(struct irdma_cm_core *cm_core, u32 *dst_addr, bool ipv4,
++		    u16 dst_port, u16 vlan_id,
++		    enum irdma_cm_listener_state listener_state)
+ {
+ 	struct irdma_cm_listener *listen_node;
+ 	static const u32 ip_zero[4] = { 0, 0, 0, 0 };
+@@ -1477,7 +1479,7 @@ irdma_find_listener(struct irdma_cm_core *cm_core, u32 *dst_addr, u16 dst_port,
+ 	list_for_each_entry (listen_node, &cm_core->listen_list, list) {
+ 		memcpy(listen_addr, listen_node->loc_addr, sizeof(listen_addr));
+ 		listen_port = listen_node->loc_port;
+-		if (listen_port != dst_port ||
++		if (listen_node->ipv4 != ipv4 || listen_port != dst_port ||
+ 		    !(listener_state & listen_node->listener_state))
+ 			continue;
+ 		/* compare node pair, return node handle if a match */
+@@ -2899,9 +2901,10 @@ irdma_make_listen_node(struct irdma_cm_core *cm_core,
+ 	unsigned long flags;
+ 
+ 	/* cannot have multiple matching listeners */
+-	listener = irdma_find_listener(cm_core, cm_info->loc_addr,
+-				       cm_info->loc_port, cm_info->vlan_id,
+-				       IRDMA_CM_LISTENER_EITHER_STATE);
++	listener =
++		irdma_find_listener(cm_core, cm_info->loc_addr, cm_info->ipv4,
++				    cm_info->loc_port, cm_info->vlan_id,
++				    IRDMA_CM_LISTENER_EITHER_STATE);
+ 	if (listener &&
+ 	    listener->listener_state == IRDMA_CM_LISTENER_ACTIVE_STATE) {
+ 		refcount_dec(&listener->refcnt);
+@@ -3150,6 +3153,7 @@ void irdma_receive_ilq(struct irdma_sc_vsi *vsi, struct irdma_puda_buf *rbuf)
+ 
+ 		listener = irdma_find_listener(cm_core,
+ 					       cm_info.loc_addr,
++					       cm_info.ipv4,
+ 					       cm_info.loc_port,
+ 					       cm_info.vlan_id,
+ 					       IRDMA_CM_LISTENER_ACTIVE_STATE);
+diff --git a/drivers/infiniband/hw/irdma/cm.h b/drivers/infiniband/hw/irdma/cm.h
+index d03cd29333eab..2b0fb5a6b3001 100644
+--- a/drivers/infiniband/hw/irdma/cm.h
++++ b/drivers/infiniband/hw/irdma/cm.h
+@@ -41,7 +41,7 @@
+ #define TCP_OPTIONS_PADDING	3
+ 
+ #define IRDMA_DEFAULT_RETRYS	64
+-#define IRDMA_DEFAULT_RETRANS	8
++#define IRDMA_DEFAULT_RETRANS	32
+ #define IRDMA_DEFAULT_TTL		0x40
+ #define IRDMA_DEFAULT_RTT_VAR		6
+ #define IRDMA_DEFAULT_SS_THRESH		0x3fffffff
+diff --git a/drivers/infiniband/hw/irdma/hw.c b/drivers/infiniband/hw/irdma/hw.c
+index b918f80d2e2c6..3b070cb3c4da7 100644
+--- a/drivers/infiniband/hw/irdma/hw.c
++++ b/drivers/infiniband/hw/irdma/hw.c
+@@ -41,6 +41,7 @@ static enum irdma_hmc_rsrc_type iw_hmc_obj_types[] = {
+ 	IRDMA_HMC_IW_XFFL,
+ 	IRDMA_HMC_IW_Q1,
+ 	IRDMA_HMC_IW_Q1FL,
++	IRDMA_HMC_IW_PBLE,
+ 	IRDMA_HMC_IW_TIMER,
+ 	IRDMA_HMC_IW_FSIMC,
+ 	IRDMA_HMC_IW_FSIAV,
+@@ -829,6 +830,8 @@ irdma_create_hmc_objs(struct irdma_pci_f *rf, bool privileged, enum irdma_vers v
+ 	info.entry_type = rf->sd_type;
+ 
+ 	for (i = 0; i < IW_HMC_OBJ_TYPE_NUM; i++) {
++		if (iw_hmc_obj_types[i] == IRDMA_HMC_IW_PBLE)
++			continue;
+ 		if (dev->hmc_info->hmc_obj[iw_hmc_obj_types[i]].cnt) {
+ 			info.rsrc_type = iw_hmc_obj_types[i];
+ 			info.count = dev->hmc_info->hmc_obj[info.rsrc_type].cnt;
+diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
+index 827ee3040bea2..2361caa385471 100644
+--- a/drivers/infiniband/hw/mlx5/main.c
++++ b/drivers/infiniband/hw/mlx5/main.c
+@@ -443,6 +443,10 @@ static int translate_eth_ext_proto_oper(u32 eth_proto_oper, u16 *active_speed,
+ 		*active_width = IB_WIDTH_2X;
+ 		*active_speed = IB_SPEED_NDR;
+ 		break;
++	case MLX5E_PROT_MASK(MLX5E_400GAUI_8):
++		*active_width = IB_WIDTH_8X;
++		*active_speed = IB_SPEED_HDR;
++		break;
+ 	case MLX5E_PROT_MASK(MLX5E_400GAUI_4_400GBASE_CR4_KR4):
+ 		*active_width = IB_WIDTH_4X;
+ 		*active_speed = IB_SPEED_NDR;
+diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
+index 1e94e7d10b8be..a0a1194dc1d90 100644
+--- a/drivers/mtd/mtdblock.c
++++ b/drivers/mtd/mtdblock.c
+@@ -153,7 +153,7 @@ static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,
+ 				mtdblk->cache_state = STATE_EMPTY;
+ 				ret = mtd_read(mtd, sect_start, sect_size,
+ 					       &retlen, mtdblk->cache_data);
+-				if (ret)
++				if (ret && !mtd_is_bitflip(ret))
+ 					return ret;
+ 				if (retlen != sect_size)
+ 					return -EIO;
+@@ -188,8 +188,12 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
+ 	pr_debug("mtdblock: read on \"%s\" at 0x%lx, size 0x%x\n",
+ 			mtd->name, pos, len);
+ 
+-	if (!sect_size)
+-		return mtd_read(mtd, pos, len, &retlen, buf);
++	if (!sect_size) {
++		ret = mtd_read(mtd, pos, len, &retlen, buf);
++		if (ret && !mtd_is_bitflip(ret))
++			return ret;
++		return 0;
++	}
+ 
+ 	while (len > 0) {
+ 		unsigned long sect_start = (pos/sect_size)*sect_size;
+@@ -209,7 +213,7 @@ static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,
+ 			memcpy (buf, mtdblk->cache_data + offset, size);
+ 		} else {
+ 			ret = mtd_read(mtd, pos, size, &retlen, buf);
+-			if (ret)
++			if (ret && !mtd_is_bitflip(ret))
+ 				return ret;
+ 			if (retlen != size)
+ 				return -EIO;
+diff --git a/drivers/mtd/nand/raw/meson_nand.c b/drivers/mtd/nand/raw/meson_nand.c
+index 4fd20e70aabd4..c66edabec9f11 100644
+--- a/drivers/mtd/nand/raw/meson_nand.c
++++ b/drivers/mtd/nand/raw/meson_nand.c
+@@ -276,7 +276,7 @@ static void meson_nfc_cmd_access(struct nand_chip *nand, int raw, bool dir,
+ 
+ 	if (raw) {
+ 		len = mtd->writesize + mtd->oobsize;
+-		cmd = (len & GENMASK(5, 0)) | scrambler | DMA_DIR(dir);
++		cmd = (len & GENMASK(13, 0)) | scrambler | DMA_DIR(dir);
+ 		writel(cmd, nfc->reg_base + NFC_REG_CMD);
+ 		return;
+ 	}
+@@ -540,7 +540,7 @@ static int meson_nfc_read_buf(struct nand_chip *nand, u8 *buf, int len)
+ 	if (ret)
+ 		goto out;
+ 
+-	cmd = NFC_CMD_N2M | (len & GENMASK(5, 0));
++	cmd = NFC_CMD_N2M | (len & GENMASK(13, 0));
+ 	writel(cmd, nfc->reg_base + NFC_REG_CMD);
+ 
+ 	meson_nfc_drain_cmd(nfc);
+@@ -564,7 +564,7 @@ static int meson_nfc_write_buf(struct nand_chip *nand, u8 *buf, int len)
+ 	if (ret)
+ 		return ret;
+ 
+-	cmd = NFC_CMD_M2N | (len & GENMASK(5, 0));
++	cmd = NFC_CMD_M2N | (len & GENMASK(13, 0));
+ 	writel(cmd, nfc->reg_base + NFC_REG_CMD);
+ 
+ 	meson_nfc_drain_cmd(nfc);
+diff --git a/drivers/mtd/nand/raw/stm32_fmc2_nand.c b/drivers/mtd/nand/raw/stm32_fmc2_nand.c
+index 1c277fbb91f2b..1ac8c4887ce03 100644
+--- a/drivers/mtd/nand/raw/stm32_fmc2_nand.c
++++ b/drivers/mtd/nand/raw/stm32_fmc2_nand.c
+@@ -1527,6 +1527,9 @@ static int stm32_fmc2_nfc_setup_interface(struct nand_chip *chip, int chipnr,
+ 	if (IS_ERR(sdrt))
+ 		return PTR_ERR(sdrt);
+ 
++	if (conf->timings.mode > 3)
++		return -EOPNOTSUPP;
++
+ 	if (chipnr == NAND_DATA_IFACE_CHECK_ONLY)
+ 		return 0;
+ 
+diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
+index 3499ff2649d54..762dc14aef742 100644
+--- a/drivers/mtd/ubi/build.c
++++ b/drivers/mtd/ubi/build.c
+@@ -664,12 +664,6 @@ static int io_init(struct ubi_device *ubi, int max_beb_per1024)
+ 	ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
+ 	ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
+ 
+-	if (ubi->vid_hdr_offset && ((ubi->vid_hdr_offset + UBI_VID_HDR_SIZE) >
+-	    ubi->vid_hdr_alsize)) {
+-		ubi_err(ubi, "VID header offset %d too large.", ubi->vid_hdr_offset);
+-		return -EINVAL;
+-	}
+-
+ 	dbg_gen("min_io_size      %d", ubi->min_io_size);
+ 	dbg_gen("max_write_size   %d", ubi->max_write_size);
+ 	dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
+@@ -687,6 +681,21 @@ static int io_init(struct ubi_device *ubi, int max_beb_per1024)
+ 						ubi->vid_hdr_aloffset;
+ 	}
+ 
++	/*
++	 * Memory allocation for VID header is ubi->vid_hdr_alsize
++	 * which is described in comments in io.c.
++	 * Make sure VID header shift + UBI_VID_HDR_SIZE not exceeds
++	 * ubi->vid_hdr_alsize, so that all vid header operations
++	 * won't access memory out of bounds.
++	 */
++	if ((ubi->vid_hdr_shift + UBI_VID_HDR_SIZE) > ubi->vid_hdr_alsize) {
++		ubi_err(ubi, "Invalid VID header offset %d, VID header shift(%d)"
++			" + VID header size(%zu) > VID header aligned size(%d).",
++			ubi->vid_hdr_offset, ubi->vid_hdr_shift,
++			UBI_VID_HDR_SIZE, ubi->vid_hdr_alsize);
++		return -EINVAL;
++	}
++
+ 	/* Similar for the data offset */
+ 	ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
+ 	ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
+diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
+index 2ee0e60c43c2e..4427018ad4d9b 100644
+--- a/drivers/mtd/ubi/wl.c
++++ b/drivers/mtd/ubi/wl.c
+@@ -575,7 +575,7 @@ static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
+  * @vol_id: the volume ID that last used this PEB
+  * @lnum: the last used logical eraseblock number for the PEB
+  * @torture: if the physical eraseblock has to be tortured
+- * @nested: denotes whether the work_sem is already held in read mode
++ * @nested: denotes whether the work_sem is already held
+  *
+  * This function returns zero in case of success and a %-ENOMEM in case of
+  * failure.
+@@ -1121,7 +1121,7 @@ static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk)
+ 		int err1;
+ 
+ 		/* Re-schedule the LEB for erasure */
+-		err1 = schedule_erase(ubi, e, vol_id, lnum, 0, false);
++		err1 = schedule_erase(ubi, e, vol_id, lnum, 0, true);
+ 		if (err1) {
+ 			spin_lock(&ubi->wl_lock);
+ 			wl_entry_destroy(ubi, e);
+diff --git a/drivers/net/ethernet/cadence/macb_main.c b/drivers/net/ethernet/cadence/macb_main.c
+index 906c5bbefaac9..ddadb1822d897 100644
+--- a/drivers/net/ethernet/cadence/macb_main.c
++++ b/drivers/net/ethernet/cadence/macb_main.c
+@@ -1044,6 +1044,10 @@ static dma_addr_t macb_get_addr(struct macb *bp, struct macb_dma_desc *desc)
+ 	}
+ #endif
+ 	addr |= MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));
++#ifdef CONFIG_MACB_USE_HWSTAMP
++	if (bp->hw_dma_cap & HW_DMA_CAP_PTP)
++		addr &= ~GEM_BIT(DMA_RXVALID);
++#endif
+ 	return addr;
+ }
+ 
+diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
+index 87f76bac2e463..eb827b86ecae8 100644
+--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
++++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
+@@ -628,7 +628,13 @@ int qlcnic_fw_create_ctx(struct qlcnic_adapter *dev)
+ 	int i, err, ring;
+ 
+ 	if (dev->flags & QLCNIC_NEED_FLR) {
+-		pci_reset_function(dev->pdev);
++		err = pci_reset_function(dev->pdev);
++		if (err) {
++			dev_err(&dev->pdev->dev,
++				"Adapter reset failed (%d). Please reboot\n",
++				err);
++			return err;
++		}
+ 		dev->flags &= ~QLCNIC_NEED_FLR;
+ 	}
+ 
+diff --git a/drivers/net/ethernet/sun/niu.c b/drivers/net/ethernet/sun/niu.c
+index a68a01d1b2b10..3fdc7c9824a39 100644
+--- a/drivers/net/ethernet/sun/niu.c
++++ b/drivers/net/ethernet/sun/niu.c
+@@ -4503,7 +4503,7 @@ static int niu_alloc_channels(struct niu *np)
+ 
+ 		err = niu_rbr_fill(np, rp, GFP_KERNEL);
+ 		if (err)
+-			return err;
++			goto out_err;
+ 	}
+ 
+ 	tx_rings = kcalloc(num_tx_rings, sizeof(struct tx_ring_info),
+diff --git a/drivers/net/phy/nxp-c45-tja11xx.c b/drivers/net/phy/nxp-c45-tja11xx.c
+index fbb64aa324040..a3196c04caf68 100644
+--- a/drivers/net/phy/nxp-c45-tja11xx.c
++++ b/drivers/net/phy/nxp-c45-tja11xx.c
+@@ -168,7 +168,7 @@
+ #define MAX_ID_PS			2260U
+ #define DEFAULT_ID_PS			2000U
+ 
+-#define PPM_TO_SUBNS_INC(ppb)	div_u64(GENMASK(31, 0) * (ppb) * \
++#define PPM_TO_SUBNS_INC(ppb)	div_u64(GENMASK_ULL(31, 0) * (ppb) * \
+ 					PTP_CLK_PERIOD_100BT1, NSEC_PER_SEC)
+ 
+ #define NXP_C45_SKB_CB(skb)	((struct nxp_c45_skb_cb *)(skb)->cb)
+@@ -1117,6 +1117,17 @@ no_ptp_support:
+ 	return ret;
+ }
+ 
++static void nxp_c45_remove(struct phy_device *phydev)
++{
++	struct nxp_c45_phy *priv = phydev->priv;
++
++	if (priv->ptp_clock)
++		ptp_clock_unregister(priv->ptp_clock);
++
++	skb_queue_purge(&priv->tx_queue);
++	skb_queue_purge(&priv->rx_queue);
++}
++
+ static struct phy_driver nxp_c45_driver[] = {
+ 	{
+ 		PHY_ID_MATCH_MODEL(PHY_ID_TJA_1103),
+@@ -1139,6 +1150,7 @@ static struct phy_driver nxp_c45_driver[] = {
+ 		.set_loopback		= genphy_c45_loopback,
+ 		.get_sqi		= nxp_c45_get_sqi,
+ 		.get_sqi_max		= nxp_c45_get_sqi_max,
++		.remove			= nxp_c45_remove,
+ 	},
+ };
+ 
+diff --git a/drivers/net/phy/sfp.c b/drivers/net/phy/sfp.c
+index 028a5df5c5385..d5918605eae6f 100644
+--- a/drivers/net/phy/sfp.c
++++ b/drivers/net/phy/sfp.c
+@@ -208,6 +208,12 @@ static const enum gpiod_flags gpio_flags[] = {
+  */
+ #define SFP_PHY_ADDR	22
+ 
++/* SFP_EEPROM_BLOCK_SIZE is the size of data chunk to read the EEPROM
++ * at a time. Some SFP modules and also some Linux I2C drivers do not like
++ * reads longer than 16 bytes.
++ */
++#define SFP_EEPROM_BLOCK_SIZE	16
++
+ struct sff_data {
+ 	unsigned int gpios;
+ 	bool (*module_supported)(const struct sfp_eeprom_id *id);
+@@ -1806,11 +1812,7 @@ static int sfp_sm_mod_probe(struct sfp *sfp, bool report)
+ 	u8 check;
+ 	int ret;
+ 
+-	/* Some SFP modules and also some Linux I2C drivers do not like reads
+-	 * longer than 16 bytes, so read the EEPROM in chunks of 16 bytes at
+-	 * a time.
+-	 */
+-	sfp->i2c_block_size = 16;
++	sfp->i2c_block_size = SFP_EEPROM_BLOCK_SIZE;
+ 
+ 	ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base));
+ 	if (ret < 0) {
+@@ -2462,6 +2464,7 @@ static struct sfp *sfp_alloc(struct device *dev)
+ 		return ERR_PTR(-ENOMEM);
+ 
+ 	sfp->dev = dev;
++	sfp->i2c_block_size = SFP_EEPROM_BLOCK_SIZE;
+ 
+ 	mutex_init(&sfp->sm_mutex);
+ 	mutex_init(&sfp->st_mutex);
+diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+index 56c7a68a6491c..fa7de3e47b8cc 100644
+--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
++++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+@@ -820,7 +820,10 @@ void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
+ 
+ 	rcu_read_lock();
+ 	do {
+-		while (likely(!mvmtxq->stopped &&
++		while (likely(!test_bit(IWL_MVM_TXQ_STATE_STOP_FULL,
++					&mvmtxq->state) &&
++			      !test_bit(IWL_MVM_TXQ_STATE_STOP_REDIRECT,
++					&mvmtxq->state) &&
+ 			      !test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status))) {
+ 			skb = ieee80211_tx_dequeue(hw, txq);
+ 
+diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
+index 46af8dd2dc930..6b59425dbdb19 100644
+--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
++++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
+@@ -727,7 +727,9 @@ struct iwl_mvm_txq {
+ 	struct list_head list;
+ 	u16 txq_id;
+ 	atomic_t tx_request;
+-	bool stopped;
++#define IWL_MVM_TXQ_STATE_STOP_FULL	0
++#define IWL_MVM_TXQ_STATE_STOP_REDIRECT	1
++	unsigned long state;
+ };
+ 
+ static inline struct iwl_mvm_txq *
+diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+index eeb81808db088..3ee4b3ecd0c82 100644
+--- a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
++++ b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+@@ -1304,7 +1304,10 @@ static void iwl_mvm_queue_state_change(struct iwl_op_mode *op_mode,
+ 
+ 		txq = sta->txq[tid];
+ 		mvmtxq = iwl_mvm_txq_from_mac80211(txq);
+-		mvmtxq->stopped = !start;
++		if (start)
++			clear_bit(IWL_MVM_TXQ_STATE_STOP_FULL, &mvmtxq->state);
++		else
++			set_bit(IWL_MVM_TXQ_STATE_STOP_FULL, &mvmtxq->state);
+ 
+ 		if (start && mvmsta->sta_state != IEEE80211_STA_NOTEXIST)
+ 			iwl_mvm_mac_itxq_xmit(mvm->hw, txq);
+diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+index 1bb456daff9e9..45dfee3ad8c60 100644
+--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
++++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+@@ -640,7 +640,7 @@ static int iwl_mvm_redirect_queue(struct iwl_mvm *mvm, int queue, int tid,
+ 			    queue, iwl_mvm_ac_to_tx_fifo[ac]);
+ 
+ 	/* Stop the queue and wait for it to empty */
+-	txq->stopped = true;
++	set_bit(IWL_MVM_TXQ_STATE_STOP_REDIRECT, &txq->state);
+ 
+ 	ret = iwl_trans_wait_tx_queues_empty(mvm->trans, BIT(queue));
+ 	if (ret) {
+@@ -683,7 +683,7 @@ static int iwl_mvm_redirect_queue(struct iwl_mvm *mvm, int queue, int tid,
+ 
+ out:
+ 	/* Continue using the queue */
+-	txq->stopped = false;
++	clear_bit(IWL_MVM_TXQ_STATE_STOP_REDIRECT, &txq->state);
+ 
+ 	return ret;
+ }
+diff --git a/drivers/net/wireless/marvell/mwifiex/pcie.c b/drivers/net/wireless/marvell/mwifiex/pcie.c
+index d5fb29400bad5..94a6bbcae2d38 100644
+--- a/drivers/net/wireless/marvell/mwifiex/pcie.c
++++ b/drivers/net/wireless/marvell/mwifiex/pcie.c
+@@ -184,7 +184,7 @@ static const struct mwifiex_pcie_device mwifiex_pcie8997 = {
+ 	.can_ext_scan = true,
+ };
+ 
+-static const struct of_device_id mwifiex_pcie_of_match_table[] = {
++static const struct of_device_id mwifiex_pcie_of_match_table[] __maybe_unused = {
+ 	{ .compatible = "pci11ab,2b42" },
+ 	{ .compatible = "pci1b4b,2b42" },
+ 	{ }
+diff --git a/drivers/net/wireless/marvell/mwifiex/sdio.c b/drivers/net/wireless/marvell/mwifiex/sdio.c
+index 7fb6eef409285..b09e60fedeb16 100644
+--- a/drivers/net/wireless/marvell/mwifiex/sdio.c
++++ b/drivers/net/wireless/marvell/mwifiex/sdio.c
+@@ -484,7 +484,7 @@ static struct memory_type_mapping mem_type_mapping_tbl[] = {
+ 	{"EXTLAST", NULL, 0, 0xFE},
+ };
+ 
+-static const struct of_device_id mwifiex_sdio_of_match_table[] = {
++static const struct of_device_id mwifiex_sdio_of_match_table[] __maybe_unused = {
+ 	{ .compatible = "marvell,sd8787" },
+ 	{ .compatible = "marvell,sd8897" },
+ 	{ .compatible = "marvell,sd8997" },
+diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
+index 6539332b42b31..c3acef6c32917 100644
+--- a/drivers/nvme/host/pci.c
++++ b/drivers/nvme/host/pci.c
+@@ -3388,6 +3388,21 @@ static const struct pci_device_id nvme_id_table[] = {
+ 		.driver_data = NVME_QUIRK_BOGUS_NID, },
+ 	{ PCI_DEVICE(0x1e4B, 0x1202),   /* MAXIO MAP1202 */
+ 		.driver_data = NVME_QUIRK_BOGUS_NID, },
++	{ PCI_DEVICE(0x1cc1, 0x5350),   /* ADATA XPG GAMMIX S50 */
++		.driver_data = NVME_QUIRK_BOGUS_NID, },
++	{ PCI_DEVICE(0x1e49, 0x0021),   /* ZHITAI TiPro5000 NVMe SSD */
++		.driver_data = NVME_QUIRK_NO_DEEPEST_PS, },
++	{ PCI_DEVICE(0x1e49, 0x0041),   /* ZHITAI TiPro7000 NVMe SSD */
++		.driver_data = NVME_QUIRK_NO_DEEPEST_PS, },
++	{ PCI_DEVICE(0xc0a9, 0x540a),   /* Crucial P2 */
++		.driver_data = NVME_QUIRK_BOGUS_NID, },
++	{ PCI_DEVICE(0x1d97, 0x2263), /* Lexar NM610 */
++		.driver_data = NVME_QUIRK_BOGUS_NID, },
++	{ PCI_DEVICE(0x1d97, 0x2269), /* Lexar NM760 */
++		.driver_data = NVME_QUIRK_BOGUS_NID |
++				NVME_QUIRK_IGNORE_DEV_SUBNQN, },
++	{ PCI_DEVICE(0x10ec, 0x5763), /* TEAMGROUP T-FORCE CARDEA ZERO Z330 SSD */
++		.driver_data = NVME_QUIRK_BOGUS_NID, },
+ 	{ PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0061),
+ 		.driver_data = NVME_QUIRK_DMA_ADDRESS_BITS_48, },
+ 	{ PCI_DEVICE(PCI_VENDOR_ID_AMAZON, 0x0065),
+diff --git a/drivers/pinctrl/pinctrl-amd.c b/drivers/pinctrl/pinctrl-amd.c
+index 0a77b8426817e..52d1fe5ec3e74 100644
+--- a/drivers/pinctrl/pinctrl-amd.c
++++ b/drivers/pinctrl/pinctrl-amd.c
+@@ -863,34 +863,32 @@ static const struct pinconf_ops amd_pinconf_ops = {
+ 	.pin_config_group_set = amd_pinconf_group_set,
+ };
+ 
+-static void amd_gpio_irq_init_pin(struct amd_gpio *gpio_dev, int pin)
++static void amd_gpio_irq_init(struct amd_gpio *gpio_dev)
+ {
+-	const struct pin_desc *pd;
++	struct pinctrl_desc *desc = gpio_dev->pctrl->desc;
+ 	unsigned long flags;
+ 	u32 pin_reg, mask;
++	int i;
+ 
+ 	mask = BIT(WAKE_CNTRL_OFF_S0I3) | BIT(WAKE_CNTRL_OFF_S3) |
+ 		BIT(INTERRUPT_MASK_OFF) | BIT(INTERRUPT_ENABLE_OFF) |
+ 		BIT(WAKE_CNTRL_OFF_S4);
+ 
+-	pd = pin_desc_get(gpio_dev->pctrl, pin);
+-	if (!pd)
+-		return;
++	for (i = 0; i < desc->npins; i++) {
++		int pin = desc->pins[i].number;
++		const struct pin_desc *pd = pin_desc_get(gpio_dev->pctrl, pin);
+ 
+-	raw_spin_lock_irqsave(&gpio_dev->lock, flags);
+-	pin_reg = readl(gpio_dev->base + pin * 4);
+-	pin_reg &= ~mask;
+-	writel(pin_reg, gpio_dev->base + pin * 4);
+-	raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
+-}
++		if (!pd)
++			continue;
+ 
+-static void amd_gpio_irq_init(struct amd_gpio *gpio_dev)
+-{
+-	struct pinctrl_desc *desc = gpio_dev->pctrl->desc;
+-	int i;
++		raw_spin_lock_irqsave(&gpio_dev->lock, flags);
+ 
+-	for (i = 0; i < desc->npins; i++)
+-		amd_gpio_irq_init_pin(gpio_dev, i);
++		pin_reg = readl(gpio_dev->base + i * 4);
++		pin_reg &= ~mask;
++		writel(pin_reg, gpio_dev->base + i * 4);
++
++		raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
++	}
+ }
+ 
+ #ifdef CONFIG_PM_SLEEP
+@@ -943,10 +941,8 @@ static int amd_gpio_resume(struct device *dev)
+ 	for (i = 0; i < desc->npins; i++) {
+ 		int pin = desc->pins[i].number;
+ 
+-		if (!amd_gpio_should_save(gpio_dev, pin)) {
+-			amd_gpio_irq_init_pin(gpio_dev, pin);
++		if (!amd_gpio_should_save(gpio_dev, pin))
+ 			continue;
+-		}
+ 
+ 		raw_spin_lock_irqsave(&gpio_dev->lock, flags);
+ 		gpio_dev->saved_regs[i] |= readl(gpio_dev->base + pin * 4) & PIN_IRQ_PENDING;
+diff --git a/drivers/power/supply/cros_usbpd-charger.c b/drivers/power/supply/cros_usbpd-charger.c
+index d89e08efd2ad0..0a4f02e4ae7ba 100644
+--- a/drivers/power/supply/cros_usbpd-charger.c
++++ b/drivers/power/supply/cros_usbpd-charger.c
+@@ -276,7 +276,7 @@ static int cros_usbpd_charger_get_power_info(struct port_data *port)
+ 		port->psy_current_max = 0;
+ 		break;
+ 	default:
+-		dev_err(dev, "Port %d: default case!\n", port->port_number);
++		dev_dbg(dev, "Port %d: default case!\n", port->port_number);
+ 		port->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
+ 	}
+ 
+diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
+index 1707d6d144d21..6a1428d453f3e 100644
+--- a/drivers/scsi/ses.c
++++ b/drivers/scsi/ses.c
+@@ -503,9 +503,6 @@ static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
+ 	int i;
+ 	struct ses_component *scomp;
+ 
+-	if (!edev->component[0].scratch)
+-		return 0;
+-
+ 	for (i = 0; i < edev->components; i++) {
+ 		scomp = edev->component[i].scratch;
+ 		if (scomp->addr != efd->addr)
+@@ -596,8 +593,10 @@ static void ses_enclosure_data_process(struct enclosure_device *edev,
+ 						components++,
+ 						type_ptr[0],
+ 						name);
+-				else
++				else if (components < edev->components)
+ 					ecomp = &edev->component[components++];
++				else
++					ecomp = ERR_PTR(-EINVAL);
+ 
+ 				if (!IS_ERR(ecomp)) {
+ 					if (addl_desc_ptr) {
+@@ -728,11 +727,6 @@ static int ses_intf_add(struct device *cdev,
+ 			components += type_ptr[1];
+ 	}
+ 
+-	if (components == 0) {
+-		sdev_printk(KERN_WARNING, sdev, "enclosure has no enumerated components\n");
+-		goto err_free;
+-	}
+-
+ 	ses_dev->page1 = buf;
+ 	ses_dev->page1_len = len;
+ 	buf = NULL;
+@@ -774,9 +768,11 @@ static int ses_intf_add(struct device *cdev,
+ 		buf = NULL;
+ 	}
+ page2_not_supported:
+-	scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
+-	if (!scomp)
+-		goto err_free;
++	if (components > 0) {
++		scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
++		if (!scomp)
++			goto err_free;
++	}
+ 
+ 	edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
+ 				  components, &ses_enclosure_callbacks);
+diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
+index 528c87ff14d80..1b288a613a6e5 100644
+--- a/drivers/video/fbdev/core/fbmem.c
++++ b/drivers/video/fbdev/core/fbmem.c
+@@ -1119,6 +1119,8 @@ static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
+ 	case FBIOPUT_VSCREENINFO:
+ 		if (copy_from_user(&var, argp, sizeof(var)))
+ 			return -EFAULT;
++		/* only for kernel-internal use */
++		var.activate &= ~FB_ACTIVATE_KD_TEXT;
+ 		console_lock();
+ 		lock_fb_info(info);
+ 		ret = fbcon_modechange_possible(info, &var);
+diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
+index ce2da06c9d7b7..a4bfa5acaf9f2 100644
+--- a/fs/btrfs/disk-io.c
++++ b/fs/btrfs/disk-io.c
+@@ -2318,6 +2318,23 @@ static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)
+ 
+ 	fs_info->csum_shash = csum_shash;
+ 
++	/*
++	 * Check if the checksum implementation is a fast accelerated one.
++	 * As-is this is a bit of a hack and should be replaced once the csum
++	 * implementations provide that information themselves.
++	 */
++	switch (csum_type) {
++	case BTRFS_CSUM_TYPE_CRC32:
++		if (!strstr(crypto_shash_driver_name(csum_shash), "generic"))
++			set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
++		break;
++	default:
++		break;
++	}
++
++	btrfs_info(fs_info, "using %s (%s) checksum algorithm",
++			btrfs_super_csum_name(csum_type),
++			crypto_shash_driver_name(csum_shash));
+ 	return 0;
+ }
+ 
+diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
+index 4ff55457f9021..ea23b83fc96be 100644
+--- a/fs/btrfs/super.c
++++ b/fs/btrfs/super.c
+@@ -1749,8 +1749,6 @@ static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,
+ 	} else {
+ 		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
+ 		btrfs_sb(s)->bdev_holder = fs_type;
+-		if (!strstr(crc32c_impl(), "generic"))
+-			set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
+ 		error = btrfs_fill_super(s, fs_devices, data);
+ 	}
+ 	if (!error)
+diff --git a/include/linux/counter.h b/include/linux/counter.h
+index d16ce2819b48b..c72dda6d6af54 100644
+--- a/include/linux/counter.h
++++ b/include/linux/counter.h
+@@ -6,42 +6,184 @@
+ #ifndef _COUNTER_H_
+ #define _COUNTER_H_
+ 
+-#include <linux/counter_enum.h>
+ #include <linux/device.h>
++#include <linux/kernel.h>
+ #include <linux/types.h>
+ 
++struct counter_device;
++struct counter_count;
++struct counter_synapse;
++struct counter_signal;
++
++enum counter_comp_type {
++	COUNTER_COMP_U8,
++	COUNTER_COMP_U64,
++	COUNTER_COMP_BOOL,
++	COUNTER_COMP_SIGNAL_LEVEL,
++	COUNTER_COMP_FUNCTION,
++	COUNTER_COMP_SYNAPSE_ACTION,
++	COUNTER_COMP_ENUM,
++	COUNTER_COMP_COUNT_DIRECTION,
++	COUNTER_COMP_COUNT_MODE,
++};
++
++enum counter_scope {
++	COUNTER_SCOPE_DEVICE,
++	COUNTER_SCOPE_SIGNAL,
++	COUNTER_SCOPE_COUNT,
++};
++
+ enum counter_count_direction {
+-	COUNTER_COUNT_DIRECTION_FORWARD = 0,
+-	COUNTER_COUNT_DIRECTION_BACKWARD
++	COUNTER_COUNT_DIRECTION_FORWARD,
++	COUNTER_COUNT_DIRECTION_BACKWARD,
+ };
+-extern const char *const counter_count_direction_str[2];
+ 
+ enum counter_count_mode {
+-	COUNTER_COUNT_MODE_NORMAL = 0,
++	COUNTER_COUNT_MODE_NORMAL,
+ 	COUNTER_COUNT_MODE_RANGE_LIMIT,
+ 	COUNTER_COUNT_MODE_NON_RECYCLE,
+-	COUNTER_COUNT_MODE_MODULO_N
++	COUNTER_COUNT_MODE_MODULO_N,
+ };
+-extern const char *const counter_count_mode_str[4];
+ 
+-struct counter_device;
+-struct counter_signal;
++enum counter_function {
++	COUNTER_FUNCTION_INCREASE,
++	COUNTER_FUNCTION_DECREASE,
++	COUNTER_FUNCTION_PULSE_DIRECTION,
++	COUNTER_FUNCTION_QUADRATURE_X1_A,
++	COUNTER_FUNCTION_QUADRATURE_X1_B,
++	COUNTER_FUNCTION_QUADRATURE_X2_A,
++	COUNTER_FUNCTION_QUADRATURE_X2_B,
++	COUNTER_FUNCTION_QUADRATURE_X4,
++};
++
++enum counter_signal_level {
++	COUNTER_SIGNAL_LEVEL_LOW,
++	COUNTER_SIGNAL_LEVEL_HIGH,
++};
++
++enum counter_synapse_action {
++	COUNTER_SYNAPSE_ACTION_NONE,
++	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
++	COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
++	COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
++};
+ 
+ /**
+- * struct counter_signal_ext - Counter Signal extensions
+- * @name:	attribute name
+- * @read:	read callback for this attribute; may be NULL
+- * @write:	write callback for this attribute; may be NULL
+- * @priv:	data private to the driver
++ * struct counter_comp - Counter component node
++ * @type:		Counter component data type
++ * @name:		device-specific component name
++ * @priv:		component-relevant data
++ * @action_read:		Synapse action mode read callback. The read value of the
++ *			respective Synapse action mode should be passed back via
++ *			the action parameter.
++ * @device_u8_read:		Device u8 component read callback. The read value of the
++ *			respective Device u8 component should be passed back via
++ *			the val parameter.
++ * @count_u8_read:		Count u8 component read callback. The read value of the
++ *			respective Count u8 component should be passed back via
++ *			the val parameter.
++ * @signal_u8_read:		Signal u8 component read callback. The read value of the
++ *			respective Signal u8 component should be passed back via
++ *			the val parameter.
++ * @device_u32_read:		Device u32 component read callback. The read value of
++ *			the respective Device u32 component should be passed
++ *			back via the val parameter.
++ * @count_u32_read:		Count u32 component read callback. The read value of the
++ *			respective Count u32 component should be passed back via
++ *			the val parameter.
++ * @signal_u32_read:		Signal u32 component read callback. The read value of
++ *			the respective Signal u32 component should be passed
++ *			back via the val parameter.
++ * @device_u64_read:		Device u64 component read callback. The read value of
++ *			the respective Device u64 component should be passed
++ *			back via the val parameter.
++ * @count_u64_read:		Count u64 component read callback. The read value of the
++ *			respective Count u64 component should be passed back via
++ *			the val parameter.
++ * @signal_u64_read:		Signal u64 component read callback. The read value of
++ *			the respective Signal u64 component should be passed
++ *			back via the val parameter.
++ * @action_write:		Synapse action mode write callback. The write value of
++ *			the respective Synapse action mode is passed via the
++ *			action parameter.
++ * @device_u8_write:		Device u8 component write callback. The write value of
++ *			the respective Device u8 component is passed via the val
++ *			parameter.
++ * @count_u8_write:		Count u8 component write callback. The write value of
++ *			the respective Count u8 component is passed via the val
++ *			parameter.
++ * @signal_u8_write:		Signal u8 component write callback. The write value of
++ *			the respective Signal u8 component is passed via the val
++ *			parameter.
++ * @device_u32_write:		Device u32 component write callback. The write value of
++ *			the respective Device u32 component is passed via the
++ *			val parameter.
++ * @count_u32_write:		Count u32 component write callback. The write value of
++ *			the respective Count u32 component is passed via the val
++ *			parameter.
++ * @signal_u32_write:		Signal u32 component write callback. The write value of
++ *			the respective Signal u32 component is passed via the
++ *			val parameter.
++ * @device_u64_write:		Device u64 component write callback. The write value of
++ *			the respective Device u64 component is passed via the
++ *			val parameter.
++ * @count_u64_write:		Count u64 component write callback. The write value of
++ *			the respective Count u64 component is passed via the val
++ *			parameter.
++ * @signal_u64_write:		Signal u64 component write callback. The write value of
++ *			the respective Signal u64 component is passed via the
++ *			val parameter.
+  */
+-struct counter_signal_ext {
++struct counter_comp {
++	enum counter_comp_type type;
+ 	const char *name;
+-	ssize_t (*read)(struct counter_device *counter,
+-			struct counter_signal *signal, void *priv, char *buf);
+-	ssize_t (*write)(struct counter_device *counter,
+-			 struct counter_signal *signal, void *priv,
+-			 const char *buf, size_t len);
+ 	void *priv;
++	union {
++		int (*action_read)(struct counter_device *counter,
++				   struct counter_count *count,
++				   struct counter_synapse *synapse,
++				   enum counter_synapse_action *action);
++		int (*device_u8_read)(struct counter_device *counter, u8 *val);
++		int (*count_u8_read)(struct counter_device *counter,
++				     struct counter_count *count, u8 *val);
++		int (*signal_u8_read)(struct counter_device *counter,
++				      struct counter_signal *signal, u8 *val);
++		int (*device_u32_read)(struct counter_device *counter,
++				       u32 *val);
++		int (*count_u32_read)(struct counter_device *counter,
++				      struct counter_count *count, u32 *val);
++		int (*signal_u32_read)(struct counter_device *counter,
++				       struct counter_signal *signal, u32 *val);
++		int (*device_u64_read)(struct counter_device *counter,
++				       u64 *val);
++		int (*count_u64_read)(struct counter_device *counter,
++				      struct counter_count *count, u64 *val);
++		int (*signal_u64_read)(struct counter_device *counter,
++				       struct counter_signal *signal, u64 *val);
++	};
++	union {
++		int (*action_write)(struct counter_device *counter,
++				    struct counter_count *count,
++				    struct counter_synapse *synapse,
++				    enum counter_synapse_action action);
++		int (*device_u8_write)(struct counter_device *counter, u8 val);
++		int (*count_u8_write)(struct counter_device *counter,
++				      struct counter_count *count, u8 val);
++		int (*signal_u8_write)(struct counter_device *counter,
++				       struct counter_signal *signal, u8 val);
++		int (*device_u32_write)(struct counter_device *counter,
++					u32 val);
++		int (*count_u32_write)(struct counter_device *counter,
++				       struct counter_count *count, u32 val);
++		int (*signal_u32_write)(struct counter_device *counter,
++					struct counter_signal *signal, u32 val);
++		int (*device_u64_write)(struct counter_device *counter,
++					u64 val);
++		int (*count_u64_write)(struct counter_device *counter,
++				       struct counter_count *count, u64 val);
++		int (*signal_u64_write)(struct counter_device *counter,
++					struct counter_signal *signal, u64 val);
++	};
+ };
+ 
+ /**
+@@ -51,248 +193,52 @@ struct counter_signal_ext {
+  *		as it appears in the datasheet documentation
+  * @ext:	optional array of Counter Signal extensions
+  * @num_ext:	number of Counter Signal extensions specified in @ext
+- * @priv:	optional private data supplied by driver
+  */
+ struct counter_signal {
+ 	int id;
+ 	const char *name;
+ 
+-	const struct counter_signal_ext *ext;
++	struct counter_comp *ext;
+ 	size_t num_ext;
+-
+-	void *priv;
+-};
+-
+-/**
+- * struct counter_signal_enum_ext - Signal enum extension attribute
+- * @items:	Array of strings
+- * @num_items:	Number of items specified in @items
+- * @set:	Set callback function; may be NULL
+- * @get:	Get callback function; may be NULL
+- *
+- * The counter_signal_enum_ext structure can be used to implement enum style
+- * Signal extension attributes. Enum style attributes are those which have a set
+- * of strings that map to unsigned integer values. The Generic Counter Signal
+- * enum extension helper code takes care of mapping between value and string, as
+- * well as generating a "_available" file which contains a list of all available
+- * items. The get callback is used to query the currently active item; the index
+- * of the item within the respective items array is returned via the 'item'
+- * parameter. The set callback is called when the attribute is updated; the
+- * 'item' parameter contains the index of the newly activated item within the
+- * respective items array.
+- */
+-struct counter_signal_enum_ext {
+-	const char * const *items;
+-	size_t num_items;
+-	int (*get)(struct counter_device *counter,
+-		   struct counter_signal *signal, size_t *item);
+-	int (*set)(struct counter_device *counter,
+-		   struct counter_signal *signal, size_t item);
+-};
+-
+-/**
+- * COUNTER_SIGNAL_ENUM() - Initialize Signal enum extension
+- * @_name:	Attribute name
+- * @_e:		Pointer to a counter_signal_enum_ext structure
+- *
+- * This should usually be used together with COUNTER_SIGNAL_ENUM_AVAILABLE()
+- */
+-#define COUNTER_SIGNAL_ENUM(_name, _e) \
+-{ \
+-	.name = (_name), \
+-	.read = counter_signal_enum_read, \
+-	.write = counter_signal_enum_write, \
+-	.priv = (_e) \
+-}
+-
+-/**
+- * COUNTER_SIGNAL_ENUM_AVAILABLE() - Initialize Signal enum available extension
+- * @_name:	Attribute name ("_available" will be appended to the name)
+- * @_e:		Pointer to a counter_signal_enum_ext structure
+- *
+- * Creates a read only attribute that lists all the available enum items in a
+- * newline separated list. This should usually be used together with
+- * COUNTER_SIGNAL_ENUM()
+- */
+-#define COUNTER_SIGNAL_ENUM_AVAILABLE(_name, _e) \
+-{ \
+-	.name = (_name "_available"), \
+-	.read = counter_signal_enum_available_read, \
+-	.priv = (_e) \
+-}
+-
+-enum counter_synapse_action {
+-	COUNTER_SYNAPSE_ACTION_NONE = 0,
+-	COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+-	COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+-	COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+ };
+ 
+ /**
+  * struct counter_synapse - Counter Synapse node
+- * @action:		index of current action mode
+  * @actions_list:	array of available action modes
+  * @num_actions:	number of action modes specified in @actions_list
+  * @signal:		pointer to associated signal
+  */
+ struct counter_synapse {
+-	size_t action;
+ 	const enum counter_synapse_action *actions_list;
+ 	size_t num_actions;
+ 
+ 	struct counter_signal *signal;
+ };
+ 
+-struct counter_count;
+-
+-/**
+- * struct counter_count_ext - Counter Count extension
+- * @name:	attribute name
+- * @read:	read callback for this attribute; may be NULL
+- * @write:	write callback for this attribute; may be NULL
+- * @priv:	data private to the driver
+- */
+-struct counter_count_ext {
+-	const char *name;
+-	ssize_t (*read)(struct counter_device *counter,
+-			struct counter_count *count, void *priv, char *buf);
+-	ssize_t (*write)(struct counter_device *counter,
+-			 struct counter_count *count, void *priv,
+-			 const char *buf, size_t len);
+-	void *priv;
+-};
+-
+-enum counter_function {
+-	COUNTER_FUNCTION_INCREASE = 0,
+-	COUNTER_FUNCTION_DECREASE,
+-	COUNTER_FUNCTION_PULSE_DIRECTION,
+-	COUNTER_FUNCTION_QUADRATURE_X1_A,
+-	COUNTER_FUNCTION_QUADRATURE_X1_B,
+-	COUNTER_FUNCTION_QUADRATURE_X2_A,
+-	COUNTER_FUNCTION_QUADRATURE_X2_B,
+-	COUNTER_FUNCTION_QUADRATURE_X4
+-};
+-
+ /**
+  * struct counter_count - Counter Count node
+  * @id:			unique ID used to identify Count
+  * @name:		device-specific Count name; ideally, this should match
+  *			the name as it appears in the datasheet documentation
+- * @function:		index of current function mode
+  * @functions_list:	array available function modes
+  * @num_functions:	number of function modes specified in @functions_list
+  * @synapses:		array of synapses for initialization
+  * @num_synapses:	number of synapses specified in @synapses
+  * @ext:		optional array of Counter Count extensions
+  * @num_ext:		number of Counter Count extensions specified in @ext
+- * @priv:		optional private data supplied by driver
+  */
+ struct counter_count {
+ 	int id;
+ 	const char *name;
+ 
+-	size_t function;
+ 	const enum counter_function *functions_list;
+ 	size_t num_functions;
+ 
+ 	struct counter_synapse *synapses;
+ 	size_t num_synapses;
+ 
+-	const struct counter_count_ext *ext;
++	struct counter_comp *ext;
+ 	size_t num_ext;
+-
+-	void *priv;
+-};
+-
+-/**
+- * struct counter_count_enum_ext - Count enum extension attribute
+- * @items:	Array of strings
+- * @num_items:	Number of items specified in @items
+- * @set:	Set callback function; may be NULL
+- * @get:	Get callback function; may be NULL
+- *
+- * The counter_count_enum_ext structure can be used to implement enum style
+- * Count extension attributes. Enum style attributes are those which have a set
+- * of strings that map to unsigned integer values. The Generic Counter Count
+- * enum extension helper code takes care of mapping between value and string, as
+- * well as generating a "_available" file which contains a list of all available
+- * items. The get callback is used to query the currently active item; the index
+- * of the item within the respective items array is returned via the 'item'
+- * parameter. The set callback is called when the attribute is updated; the
+- * 'item' parameter contains the index of the newly activated item within the
+- * respective items array.
+- */
+-struct counter_count_enum_ext {
+-	const char * const *items;
+-	size_t num_items;
+-	int (*get)(struct counter_device *counter, struct counter_count *count,
+-		   size_t *item);
+-	int (*set)(struct counter_device *counter, struct counter_count *count,
+-		   size_t item);
+-};
+-
+-/**
+- * COUNTER_COUNT_ENUM() - Initialize Count enum extension
+- * @_name:	Attribute name
+- * @_e:		Pointer to a counter_count_enum_ext structure
+- *
+- * This should usually be used together with COUNTER_COUNT_ENUM_AVAILABLE()
+- */
+-#define COUNTER_COUNT_ENUM(_name, _e) \
+-{ \
+-	.name = (_name), \
+-	.read = counter_count_enum_read, \
+-	.write = counter_count_enum_write, \
+-	.priv = (_e) \
+-}
+-
+-/**
+- * COUNTER_COUNT_ENUM_AVAILABLE() - Initialize Count enum available extension
+- * @_name:	Attribute name ("_available" will be appended to the name)
+- * @_e:		Pointer to a counter_count_enum_ext structure
+- *
+- * Creates a read only attribute that lists all the available enum items in a
+- * newline separated list. This should usually be used together with
+- * COUNTER_COUNT_ENUM()
+- */
+-#define COUNTER_COUNT_ENUM_AVAILABLE(_name, _e) \
+-{ \
+-	.name = (_name "_available"), \
+-	.read = counter_count_enum_available_read, \
+-	.priv = (_e) \
+-}
+-
+-/**
+- * struct counter_device_attr_group - internal container for attribute group
+- * @attr_group:	Counter sysfs attributes group
+- * @attr_list:	list to keep track of created Counter sysfs attributes
+- * @num_attr:	number of Counter sysfs attributes
+- */
+-struct counter_device_attr_group {
+-	struct attribute_group attr_group;
+-	struct list_head attr_list;
+-	size_t num_attr;
+-};
+-
+-/**
+- * struct counter_device_state - internal state container for a Counter device
+- * @id:			unique ID used to identify the Counter
+- * @dev:		internal device structure
+- * @groups_list:	attribute groups list (for Signals, Counts, and ext)
+- * @num_groups:		number of attribute groups containers
+- * @groups:		Counter sysfs attribute groups (to populate @dev.groups)
+- */
+-struct counter_device_state {
+-	int id;
+-	struct device dev;
+-	struct counter_device_attr_group *groups_list;
+-	size_t num_groups;
+-	const struct attribute_group **groups;
+-};
+-
+-enum counter_signal_level {
+-	COUNTER_SIGNAL_LEVEL_LOW,
+-	COUNTER_SIGNAL_LEVEL_HIGH,
+ };
+ 
+ /**
+@@ -306,117 +252,47 @@ enum counter_signal_level {
+  * @count_write:	optional write callback for Count attribute. The write
+  *			value for the respective Count is passed in via the val
+  *			parameter.
+- * @function_get:	function to get the current count function mode. Returns
+- *			0 on success and negative error code on error. The index
+- *			of the respective Count's returned function mode should
+- *			be passed back via the function parameter.
+- * @function_set:	function to set the count function mode. function is the
+- *			index of the requested function mode from the respective
+- *			Count's functions_list array.
+- * @action_get:		function to get the current action mode. Returns 0 on
+- *			success and negative error code on error. The index of
+- *			the respective Synapse's returned action mode should be
+- *			passed back via the action parameter.
+- * @action_set:		function to set the action mode. action is the index of
+- *			the requested action mode from the respective Synapse's
+- *			actions_list array.
++ * @function_read:	read callback the Count function modes. The read
++ *			function mode of the respective Count should be passed
++ *			back via the function parameter.
++ * @function_write:	write callback for Count function modes. The function
++ *			mode to write for the respective Count is passed in via
++ *			the function parameter.
++ * @action_read:	read callback the Synapse action modes. The read action
++ *			mode of the respective Synapse should be passed back via
++ *			the action parameter.
++ * @action_write:	write callback for Synapse action modes. The action mode
++ *			to write for the respective Synapse is passed in via the
++ *			action parameter.
+  */
+ struct counter_ops {
+ 	int (*signal_read)(struct counter_device *counter,
+ 			   struct counter_signal *signal,
+ 			   enum counter_signal_level *level);
+ 	int (*count_read)(struct counter_device *counter,
+-			  struct counter_count *count, unsigned long *val);
++			  struct counter_count *count, u64 *value);
+ 	int (*count_write)(struct counter_device *counter,
+-			   struct counter_count *count, unsigned long val);
+-	int (*function_get)(struct counter_device *counter,
+-			    struct counter_count *count, size_t *function);
+-	int (*function_set)(struct counter_device *counter,
+-			    struct counter_count *count, size_t function);
+-	int (*action_get)(struct counter_device *counter,
+-			  struct counter_count *count,
+-			  struct counter_synapse *synapse, size_t *action);
+-	int (*action_set)(struct counter_device *counter,
+-			  struct counter_count *count,
+-			  struct counter_synapse *synapse, size_t action);
+-};
+-
+-/**
+- * struct counter_device_ext - Counter device extension
+- * @name:	attribute name
+- * @read:	read callback for this attribute; may be NULL
+- * @write:	write callback for this attribute; may be NULL
+- * @priv:	data private to the driver
+- */
+-struct counter_device_ext {
+-	const char *name;
+-	ssize_t (*read)(struct counter_device *counter, void *priv, char *buf);
+-	ssize_t (*write)(struct counter_device *counter, void *priv,
+-			 const char *buf, size_t len);
+-	void *priv;
++			   struct counter_count *count, u64 value);
++	int (*function_read)(struct counter_device *counter,
++			     struct counter_count *count,
++			     enum counter_function *function);
++	int (*function_write)(struct counter_device *counter,
++			      struct counter_count *count,
++			      enum counter_function function);
++	int (*action_read)(struct counter_device *counter,
++			   struct counter_count *count,
++			   struct counter_synapse *synapse,
++			   enum counter_synapse_action *action);
++	int (*action_write)(struct counter_device *counter,
++			    struct counter_count *count,
++			    struct counter_synapse *synapse,
++			    enum counter_synapse_action action);
+ };
+ 
+-/**
+- * struct counter_device_enum_ext - Counter enum extension attribute
+- * @items:	Array of strings
+- * @num_items:	Number of items specified in @items
+- * @set:	Set callback function; may be NULL
+- * @get:	Get callback function; may be NULL
+- *
+- * The counter_device_enum_ext structure can be used to implement enum style
+- * Counter extension attributes. Enum style attributes are those which have a
+- * set of strings that map to unsigned integer values. The Generic Counter enum
+- * extension helper code takes care of mapping between value and string, as well
+- * as generating a "_available" file which contains a list of all available
+- * items. The get callback is used to query the currently active item; the index
+- * of the item within the respective items array is returned via the 'item'
+- * parameter. The set callback is called when the attribute is updated; the
+- * 'item' parameter contains the index of the newly activated item within the
+- * respective items array.
+- */
+-struct counter_device_enum_ext {
+-	const char * const *items;
+-	size_t num_items;
+-	int (*get)(struct counter_device *counter, size_t *item);
+-	int (*set)(struct counter_device *counter, size_t item);
+-};
+-
+-/**
+- * COUNTER_DEVICE_ENUM() - Initialize Counter enum extension
+- * @_name:	Attribute name
+- * @_e:		Pointer to a counter_device_enum_ext structure
+- *
+- * This should usually be used together with COUNTER_DEVICE_ENUM_AVAILABLE()
+- */
+-#define COUNTER_DEVICE_ENUM(_name, _e) \
+-{ \
+-	.name = (_name), \
+-	.read = counter_device_enum_read, \
+-	.write = counter_device_enum_write, \
+-	.priv = (_e) \
+-}
+-
+-/**
+- * COUNTER_DEVICE_ENUM_AVAILABLE() - Initialize Counter enum available extension
+- * @_name:	Attribute name ("_available" will be appended to the name)
+- * @_e:		Pointer to a counter_device_enum_ext structure
+- *
+- * Creates a read only attribute that lists all the available enum items in a
+- * newline separated list. This should usually be used together with
+- * COUNTER_DEVICE_ENUM()
+- */
+-#define COUNTER_DEVICE_ENUM_AVAILABLE(_name, _e) \
+-{ \
+-	.name = (_name "_available"), \
+-	.read = counter_device_enum_available_read, \
+-	.priv = (_e) \
+-}
+-
+ /**
+  * struct counter_device - Counter data structure
+  * @name:		name of the device as it appears in the datasheet
+  * @parent:		optional parent device providing the counters
+- * @device_state:	internal device state container
+  * @ops:		callbacks from driver
+  * @signals:		array of Signals
+  * @num_signals:	number of Signals specified in @signals
+@@ -425,11 +301,11 @@ struct counter_device_enum_ext {
+  * @ext:		optional array of Counter device extensions
+  * @num_ext:		number of Counter device extensions specified in @ext
+  * @priv:		optional private data supplied by driver
++ * @dev:		internal device structure
+  */
+ struct counter_device {
+ 	const char *name;
+ 	struct device *parent;
+-	struct counter_device_state *device_state;
+ 
+ 	const struct counter_ops *ops;
+ 
+@@ -438,17 +314,159 @@ struct counter_device {
+ 	struct counter_count *counts;
+ 	size_t num_counts;
+ 
+-	const struct counter_device_ext *ext;
++	struct counter_comp *ext;
+ 	size_t num_ext;
+ 
+ 	void *priv;
++
++	struct device dev;
+ };
+ 
+ int counter_register(struct counter_device *const counter);
+ void counter_unregister(struct counter_device *const counter);
+ int devm_counter_register(struct device *dev,
+ 			  struct counter_device *const counter);
+-void devm_counter_unregister(struct device *dev,
+-			     struct counter_device *const counter);
++
++#define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U8, \
++	.name = (_name), \
++	.device_u8_read = (_read), \
++	.device_u8_write = (_write), \
++}
++#define COUNTER_COMP_COUNT_U8(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U8, \
++	.name = (_name), \
++	.count_u8_read = (_read), \
++	.count_u8_write = (_write), \
++}
++#define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U8, \
++	.name = (_name), \
++	.signal_u8_read = (_read), \
++	.signal_u8_write = (_write), \
++}
++
++#define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U64, \
++	.name = (_name), \
++	.device_u64_read = (_read), \
++	.device_u64_write = (_write), \
++}
++#define COUNTER_COMP_COUNT_U64(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U64, \
++	.name = (_name), \
++	.count_u64_read = (_read), \
++	.count_u64_write = (_write), \
++}
++#define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_U64, \
++	.name = (_name), \
++	.signal_u64_read = (_read), \
++	.signal_u64_write = (_write), \
++}
++
++#define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_BOOL, \
++	.name = (_name), \
++	.device_u8_read = (_read), \
++	.device_u8_write = (_write), \
++}
++#define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_BOOL, \
++	.name = (_name), \
++	.count_u8_read = (_read), \
++	.count_u8_write = (_write), \
++}
++#define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \
++{ \
++	.type = COUNTER_COMP_BOOL, \
++	.name = (_name), \
++	.signal_u8_read = (_read), \
++	.signal_u8_write = (_write), \
++}
++
++struct counter_available {
++	union {
++		const u32 *enums;
++		const char *const *strs;
++	};
++	size_t num_items;
++};
++
++#define DEFINE_COUNTER_AVAILABLE(_name, _enums) \
++	struct counter_available _name = { \
++		.enums = (_enums), \
++		.num_items = ARRAY_SIZE(_enums), \
++	}
++
++#define DEFINE_COUNTER_ENUM(_name, _strs) \
++	struct counter_available _name = { \
++		.strs = (_strs), \
++		.num_items = ARRAY_SIZE(_strs), \
++	}
++
++#define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \
++{ \
++	.type = COUNTER_COMP_ENUM, \
++	.name = (_name), \
++	.device_u32_read = (_get), \
++	.device_u32_write = (_set), \
++	.priv = &(_available), \
++}
++#define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \
++{ \
++	.type = COUNTER_COMP_ENUM, \
++	.name = (_name), \
++	.count_u32_read = (_get), \
++	.count_u32_write = (_set), \
++	.priv = &(_available), \
++}
++#define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \
++{ \
++	.type = COUNTER_COMP_ENUM, \
++	.name = (_name), \
++	.signal_u32_read = (_get), \
++	.signal_u32_write = (_set), \
++	.priv = &(_available), \
++}
++
++#define COUNTER_COMP_CEILING(_read, _write) \
++	COUNTER_COMP_COUNT_U64("ceiling", _read, _write)
++
++#define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \
++{ \
++	.type = COUNTER_COMP_COUNT_MODE, \
++	.name = "count_mode", \
++	.count_u32_read = (_read), \
++	.count_u32_write = (_write), \
++	.priv = &(_available), \
++}
++
++#define COUNTER_COMP_DIRECTION(_read) \
++{ \
++	.type = COUNTER_COMP_COUNT_DIRECTION, \
++	.name = "direction", \
++	.count_u32_read = (_read), \
++}
++
++#define COUNTER_COMP_ENABLE(_read, _write) \
++	COUNTER_COMP_COUNT_BOOL("enable", _read, _write)
++
++#define COUNTER_COMP_FLOOR(_read, _write) \
++	COUNTER_COMP_COUNT_U64("floor", _read, _write)
++
++#define COUNTER_COMP_PRESET(_read, _write) \
++	COUNTER_COMP_COUNT_U64("preset", _read, _write)
++
++#define COUNTER_COMP_PRESET_ENABLE(_read, _write) \
++	COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write)
+ 
+ #endif /* _COUNTER_H_ */
+diff --git a/include/linux/counter_enum.h b/include/linux/counter_enum.h
+deleted file mode 100644
+index 9f917298a88f8..0000000000000
+--- a/include/linux/counter_enum.h
++++ /dev/null
+@@ -1,45 +0,0 @@
+-/* SPDX-License-Identifier: GPL-2.0 */
+-/*
+- * Counter interface enum functions
+- * Copyright (C) 2018 William Breathitt Gray
+- */
+-#ifndef _COUNTER_ENUM_H_
+-#define _COUNTER_ENUM_H_
+-
+-#include <linux/types.h>
+-
+-struct counter_device;
+-struct counter_signal;
+-struct counter_count;
+-
+-ssize_t counter_signal_enum_read(struct counter_device *counter,
+-				 struct counter_signal *signal, void *priv,
+-				 char *buf);
+-ssize_t counter_signal_enum_write(struct counter_device *counter,
+-				  struct counter_signal *signal, void *priv,
+-				  const char *buf, size_t len);
+-
+-ssize_t counter_signal_enum_available_read(struct counter_device *counter,
+-					   struct counter_signal *signal,
+-					   void *priv, char *buf);
+-
+-ssize_t counter_count_enum_read(struct counter_device *counter,
+-				struct counter_count *count, void *priv,
+-				char *buf);
+-ssize_t counter_count_enum_write(struct counter_device *counter,
+-				 struct counter_count *count, void *priv,
+-				 const char *buf, size_t len);
+-
+-ssize_t counter_count_enum_available_read(struct counter_device *counter,
+-					  struct counter_count *count,
+-					  void *priv, char *buf);
+-
+-ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
+-				 char *buf);
+-ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
+-				  const char *buf, size_t len);
+-
+-ssize_t counter_device_enum_available_read(struct counter_device *counter,
+-					   void *priv, char *buf);
+-
+-#endif /* _COUNTER_ENUM_H_ */
+diff --git a/include/linux/kexec.h b/include/linux/kexec.h
+index cf042d41c87b9..88c289ce3039c 100644
+--- a/include/linux/kexec.h
++++ b/include/linux/kexec.h
+@@ -390,8 +390,8 @@ extern note_buf_t __percpu *crash_notes;
+ extern bool kexec_in_progress;
+ 
+ int crash_shrink_memory(unsigned long new_size);
+-size_t crash_get_memory_size(void);
+ void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
++ssize_t crash_get_memory_size(void);
+ 
+ void arch_kexec_protect_crashkres(void);
+ void arch_kexec_unprotect_crashkres(void);
+diff --git a/include/linux/mfd/stm32-lptimer.h b/include/linux/mfd/stm32-lptimer.h
+index 90b20550c1c8b..06d3f11dc3c9f 100644
+--- a/include/linux/mfd/stm32-lptimer.h
++++ b/include/linux/mfd/stm32-lptimer.h
+@@ -45,6 +45,11 @@
+ #define STM32_LPTIM_PRESC	GENMASK(11, 9)
+ #define STM32_LPTIM_CKPOL	GENMASK(2, 1)
+ 
++/* STM32_LPTIM_CKPOL */
++#define STM32_LPTIM_CKPOL_RISING_EDGE	0
++#define STM32_LPTIM_CKPOL_FALLING_EDGE	1
++#define STM32_LPTIM_CKPOL_BOTH_EDGES	2
++
+ /* STM32_LPTIM_ARR */
+ #define STM32_LPTIM_MAX_ARR	0xFFFF
+ 
+diff --git a/include/linux/mfd/stm32-timers.h b/include/linux/mfd/stm32-timers.h
+index f8db83aedb2b5..5f5c43fd69ddd 100644
+--- a/include/linux/mfd/stm32-timers.h
++++ b/include/linux/mfd/stm32-timers.h
+@@ -82,6 +82,10 @@
+ #define MAX_TIM_ICPSC		0x3
+ #define TIM_CR2_MMS_SHIFT	4
+ #define TIM_CR2_MMS2_SHIFT	20
++#define TIM_SMCR_SMS_SLAVE_MODE_DISABLED	0 /* counts on internal clock when CEN=1 */
++#define TIM_SMCR_SMS_ENCODER_MODE_1		1 /* counts TI1FP1 edges, depending on TI2FP2 level */
++#define TIM_SMCR_SMS_ENCODER_MODE_2		2 /* counts TI2FP2 edges, depending on TI1FP1 level */
++#define TIM_SMCR_SMS_ENCODER_MODE_3		3 /* counts on both TI1FP1 and TI2FP2 edges */
+ #define TIM_SMCR_TS_SHIFT	4
+ #define TIM_BDTR_BKF_MASK	0xF
+ #define TIM_BDTR_BKF_SHIFT(x)	(16 + (x) * 4)
+diff --git a/include/linux/trace.h b/include/linux/trace.h
+index 80ffda8717491..2a70a447184c9 100644
+--- a/include/linux/trace.h
++++ b/include/linux/trace.h
+@@ -33,6 +33,18 @@ struct trace_array;
+ int register_ftrace_export(struct trace_export *export);
+ int unregister_ftrace_export(struct trace_export *export);
+ 
++/**
++ * trace_array_puts - write a constant string into the trace buffer.
++ * @tr:    The trace array to write to
++ * @str:   The constant string to write
++ */
++#define trace_array_puts(tr, str)					\
++	({								\
++		str ? __trace_array_puts(tr, _THIS_IP_, str, strlen(str)) : -1;	\
++	})
++int __trace_array_puts(struct trace_array *tr, unsigned long ip,
++		       const char *str, int size);
++
+ void trace_printk_init_buffers(void);
+ __printf(3, 4)
+ int trace_array_printk(struct trace_array *tr, unsigned long ip,
+diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
+index 428820bf141d1..fb895eaf3a7c3 100644
+--- a/kernel/cgroup/cpuset.c
++++ b/kernel/cgroup/cpuset.c
+@@ -2225,11 +2225,15 @@ out_unlock:
+ static void cpuset_cancel_attach(struct cgroup_taskset *tset)
+ {
+ 	struct cgroup_subsys_state *css;
++	struct cpuset *cs;
+ 
+ 	cgroup_taskset_first(tset, &css);
++	cs = css_cs(css);
+ 
+ 	percpu_down_write(&cpuset_rwsem);
+-	css_cs(css)->attach_in_progress--;
++	cs->attach_in_progress--;
++	if (!cs->attach_in_progress)
++		wake_up(&cpuset_attach_wq);
+ 	percpu_up_write(&cpuset_rwsem);
+ }
+ 
+diff --git a/kernel/kexec.c b/kernel/kexec.c
+index b5e40f0697681..cb8e6e6f983c7 100644
+--- a/kernel/kexec.c
++++ b/kernel/kexec.c
+@@ -93,13 +93,10 @@ static int do_kexec_load(unsigned long entry, unsigned long nr_segments,
+ 
+ 	/*
+ 	 * Because we write directly to the reserved memory region when loading
+-	 * crash kernels we need a mutex here to prevent multiple crash kernels
+-	 * from attempting to load simultaneously, and to prevent a crash kernel
+-	 * from loading over the top of a in use crash kernel.
+-	 *
+-	 * KISS: always take the mutex.
++	 * crash kernels we need a serialization here to prevent multiple crash
++	 * kernels from attempting to load simultaneously.
+ 	 */
+-	if (!mutex_trylock(&kexec_mutex))
++	if (!kexec_trylock())
+ 		return -EBUSY;
+ 
+ 	if (flags & KEXEC_ON_CRASH) {
+@@ -165,7 +162,7 @@ out:
+ 
+ 	kimage_free(image);
+ out_unlock:
+-	mutex_unlock(&kexec_mutex);
++	kexec_unlock();
+ 	return ret;
+ }
+ 
+diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
+index 5a5d192a89ac3..bdc2d952911ce 100644
+--- a/kernel/kexec_core.c
++++ b/kernel/kexec_core.c
+@@ -46,7 +46,7 @@
+ #include <crypto/hash.h>
+ #include "kexec_internal.h"
+ 
+-DEFINE_MUTEX(kexec_mutex);
++atomic_t __kexec_lock = ATOMIC_INIT(0);
+ 
+ /* Per cpu memory for storing cpu states in case of system crash. */
+ note_buf_t __percpu *crash_notes;
+@@ -944,7 +944,7 @@ int kexec_load_disabled;
+  */
+ void __noclone __crash_kexec(struct pt_regs *regs)
+ {
+-	/* Take the kexec_mutex here to prevent sys_kexec_load
++	/* Take the kexec_lock here to prevent sys_kexec_load
+ 	 * running on one cpu from replacing the crash kernel
+ 	 * we are using after a panic on a different cpu.
+ 	 *
+@@ -952,7 +952,7 @@ void __noclone __crash_kexec(struct pt_regs *regs)
+ 	 * of memory the xchg(&kexec_crash_image) would be
+ 	 * sufficient.  But since I reuse the memory...
+ 	 */
+-	if (mutex_trylock(&kexec_mutex)) {
++	if (kexec_trylock()) {
+ 		if (kexec_crash_image) {
+ 			struct pt_regs fixed_regs;
+ 
+@@ -961,7 +961,7 @@ void __noclone __crash_kexec(struct pt_regs *regs)
+ 			machine_crash_shutdown(&fixed_regs);
+ 			machine_kexec(kexec_crash_image);
+ 		}
+-		mutex_unlock(&kexec_mutex);
++		kexec_unlock();
+ 	}
+ }
+ STACK_FRAME_NON_STANDARD(__crash_kexec);
+@@ -989,14 +989,17 @@ void crash_kexec(struct pt_regs *regs)
+ 	}
+ }
+ 
+-size_t crash_get_memory_size(void)
++ssize_t crash_get_memory_size(void)
+ {
+-	size_t size = 0;
++	ssize_t size = 0;
++
++	if (!kexec_trylock())
++		return -EBUSY;
+ 
+-	mutex_lock(&kexec_mutex);
+ 	if (crashk_res.end != crashk_res.start)
+ 		size = resource_size(&crashk_res);
+-	mutex_unlock(&kexec_mutex);
++
++	kexec_unlock();
+ 	return size;
+ }
+ 
+@@ -1016,7 +1019,8 @@ int crash_shrink_memory(unsigned long new_size)
+ 	unsigned long old_size;
+ 	struct resource *ram_res;
+ 
+-	mutex_lock(&kexec_mutex);
++	if (!kexec_trylock())
++		return -EBUSY;
+ 
+ 	if (kexec_crash_image) {
+ 		ret = -ENOENT;
+@@ -1054,7 +1058,7 @@ int crash_shrink_memory(unsigned long new_size)
+ 	insert_resource(&iomem_resource, ram_res);
+ 
+ unlock:
+-	mutex_unlock(&kexec_mutex);
++	kexec_unlock();
+ 	return ret;
+ }
+ 
+@@ -1126,7 +1130,7 @@ int kernel_kexec(void)
+ {
+ 	int error = 0;
+ 
+-	if (!mutex_trylock(&kexec_mutex))
++	if (!kexec_trylock())
+ 		return -EBUSY;
+ 	if (!kexec_image) {
+ 		error = -EINVAL;
+@@ -1202,7 +1206,7 @@ int kernel_kexec(void)
+ #endif
+ 
+  Unlock:
+-	mutex_unlock(&kexec_mutex);
++	kexec_unlock();
+ 	return error;
+ }
+ 
+diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c
+index f7a4fd4d243f4..1fb7ff690577d 100644
+--- a/kernel/kexec_file.c
++++ b/kernel/kexec_file.c
+@@ -343,7 +343,7 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,
+ 
+ 	image = NULL;
+ 
+-	if (!mutex_trylock(&kexec_mutex))
++	if (!kexec_trylock())
+ 		return -EBUSY;
+ 
+ 	dest_image = &kexec_image;
+@@ -415,7 +415,7 @@ out:
+ 	if ((flags & KEXEC_FILE_ON_CRASH) && kexec_crash_image)
+ 		arch_kexec_protect_crashkres();
+ 
+-	mutex_unlock(&kexec_mutex);
++	kexec_unlock();
+ 	kimage_free(image);
+ 	return ret;
+ }
+diff --git a/kernel/kexec_internal.h b/kernel/kexec_internal.h
+index 48aaf2ac0d0d1..74da1409cd14b 100644
+--- a/kernel/kexec_internal.h
++++ b/kernel/kexec_internal.h
+@@ -13,7 +13,20 @@ void kimage_terminate(struct kimage *image);
+ int kimage_is_destination_range(struct kimage *image,
+ 				unsigned long start, unsigned long end);
+ 
+-extern struct mutex kexec_mutex;
++/*
++ * Whatever is used to serialize accesses to the kexec_crash_image needs to be
++ * NMI safe, as __crash_kexec() can happen during nmi_panic(), so here we use a
++ * "simple" atomic variable that is acquired with a cmpxchg().
++ */
++extern atomic_t __kexec_lock;
++static inline bool kexec_trylock(void)
++{
++	return atomic_cmpxchg_acquire(&__kexec_lock, 0, 1) == 0;
++}
++static inline void kexec_unlock(void)
++{
++	atomic_set_release(&__kexec_lock, 0);
++}
+ 
+ #ifdef CONFIG_KEXEC_FILE
+ #include <linux/purgatory.h>
+diff --git a/kernel/ksysfs.c b/kernel/ksysfs.c
+index 35859da8bd4f7..e20c19e3ba49c 100644
+--- a/kernel/ksysfs.c
++++ b/kernel/ksysfs.c
+@@ -106,7 +106,12 @@ KERNEL_ATTR_RO(kexec_crash_loaded);
+ static ssize_t kexec_crash_size_show(struct kobject *kobj,
+ 				       struct kobj_attribute *attr, char *buf)
+ {
+-	return sprintf(buf, "%zu\n", crash_get_memory_size());
++	ssize_t size = crash_get_memory_size();
++
++	if (size < 0)
++		return size;
++
++	return sprintf(buf, "%zd\n", size);
+ }
+ static ssize_t kexec_crash_size_store(struct kobject *kobj,
+ 				   struct kobj_attribute *attr,
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 8f5a5e72bdb3e..7ac00dede846c 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -9636,8 +9636,6 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
+ 		local->avg_load = (local->group_load * SCHED_CAPACITY_SCALE) /
+ 				  local->group_capacity;
+ 
+-		sds->avg_load = (sds->total_load * SCHED_CAPACITY_SCALE) /
+-				sds->total_capacity;
+ 		/*
+ 		 * If the local group is more loaded than the selected
+ 		 * busiest group don't try to pull any tasks.
+@@ -9646,6 +9644,19 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
+ 			env->imbalance = 0;
+ 			return;
+ 		}
++
++		sds->avg_load = (sds->total_load * SCHED_CAPACITY_SCALE) /
++				sds->total_capacity;
++
++		/*
++		 * If the local group is more loaded than the average system
++		 * load, don't try to pull any tasks.
++		 */
++		if (local->avg_load >= sds->avg_load) {
++			env->imbalance = 0;
++			return;
++		}
++
+ 	}
+ 
+ 	/*
+diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
+index dc097bd23dc3e..e2277cba4817b 100644
+--- a/kernel/trace/trace.c
++++ b/kernel/trace/trace.c
+@@ -990,13 +990,8 @@ __buffer_unlock_commit(struct trace_buffer *buffer, struct ring_buffer_event *ev
+ 		ring_buffer_unlock_commit(buffer, event);
+ }
+ 
+-/**
+- * __trace_puts - write a constant string into the trace buffer.
+- * @ip:	   The address of the caller
+- * @str:   The constant string to write
+- * @size:  The size of the string.
+- */
+-int __trace_puts(unsigned long ip, const char *str, int size)
++int __trace_array_puts(struct trace_array *tr, unsigned long ip,
++		       const char *str, int size)
+ {
+ 	struct ring_buffer_event *event;
+ 	struct trace_buffer *buffer;
+@@ -1004,7 +999,7 @@ int __trace_puts(unsigned long ip, const char *str, int size)
+ 	unsigned int trace_ctx;
+ 	int alloc;
+ 
+-	if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
++	if (!(tr->trace_flags & TRACE_ITER_PRINTK))
+ 		return 0;
+ 
+ 	if (unlikely(tracing_selftest_running || tracing_disabled))
+@@ -1013,7 +1008,7 @@ int __trace_puts(unsigned long ip, const char *str, int size)
+ 	alloc = sizeof(*entry) + size + 2; /* possible \n added */
+ 
+ 	trace_ctx = tracing_gen_ctx();
+-	buffer = global_trace.array_buffer.buffer;
++	buffer = tr->array_buffer.buffer;
+ 	ring_buffer_nest_start(buffer);
+ 	event = __trace_buffer_lock_reserve(buffer, TRACE_PRINT, alloc,
+ 					    trace_ctx);
+@@ -1035,11 +1030,23 @@ int __trace_puts(unsigned long ip, const char *str, int size)
+ 		entry->buf[size] = '\0';
+ 
+ 	__buffer_unlock_commit(buffer, event);
+-	ftrace_trace_stack(&global_trace, buffer, trace_ctx, 4, NULL);
++	ftrace_trace_stack(tr, buffer, trace_ctx, 4, NULL);
+  out:
+ 	ring_buffer_nest_end(buffer);
+ 	return size;
+ }
++EXPORT_SYMBOL_GPL(__trace_array_puts);
++
++/**
++ * __trace_puts - write a constant string into the trace buffer.
++ * @ip:	   The address of the caller
++ * @str:   The constant string to write
++ * @size:  The size of the string.
++ */
++int __trace_puts(unsigned long ip, const char *str, int size)
++{
++	return __trace_array_puts(&global_trace, ip, str, size);
++}
+ EXPORT_SYMBOL_GPL(__trace_puts);
+ 
+ /**
+@@ -1093,22 +1100,22 @@ static void tracing_snapshot_instance_cond(struct trace_array *tr,
+ 	unsigned long flags;
+ 
+ 	if (in_nmi()) {
+-		internal_trace_puts("*** SNAPSHOT CALLED FROM NMI CONTEXT ***\n");
+-		internal_trace_puts("*** snapshot is being ignored        ***\n");
++		trace_array_puts(tr, "*** SNAPSHOT CALLED FROM NMI CONTEXT ***\n");
++		trace_array_puts(tr, "*** snapshot is being ignored        ***\n");
+ 		return;
+ 	}
+ 
+ 	if (!tr->allocated_snapshot) {
+-		internal_trace_puts("*** SNAPSHOT NOT ALLOCATED ***\n");
+-		internal_trace_puts("*** stopping trace here!   ***\n");
+-		tracing_off();
++		trace_array_puts(tr, "*** SNAPSHOT NOT ALLOCATED ***\n");
++		trace_array_puts(tr, "*** stopping trace here!   ***\n");
++		tracer_tracing_off(tr);
+ 		return;
+ 	}
+ 
+ 	/* Note, snapshot can not be used when the tracer uses it */
+ 	if (tracer->use_max_tr) {
+-		internal_trace_puts("*** LATENCY TRACER ACTIVE ***\n");
+-		internal_trace_puts("*** Can not use snapshot (sorry) ***\n");
++		trace_array_puts(tr, "*** LATENCY TRACER ACTIVE ***\n");
++		trace_array_puts(tr, "*** Can not use snapshot (sorry) ***\n");
+ 		return;
+ 	}
+ 
+diff --git a/net/9p/trans_xen.c b/net/9p/trans_xen.c
+index 9e4da8c1b907e..99e6b2483311c 100644
+--- a/net/9p/trans_xen.c
++++ b/net/9p/trans_xen.c
+@@ -300,6 +300,10 @@ static void xen_9pfs_front_free(struct xen_9pfs_front_priv *priv)
+ 	write_unlock(&xen_9pfs_lock);
+ 
+ 	for (i = 0; i < priv->num_rings; i++) {
++		struct xen_9pfs_dataring *ring = &priv->rings[i];
++
++		cancel_work_sync(&ring->work);
++
+ 		if (!priv->rings[i].intf)
+ 			break;
+ 		if (priv->rings[i].irq > 0)
+diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
+index 80848dfc01db5..021ab957a5c4d 100644
+--- a/net/bluetooth/hidp/core.c
++++ b/net/bluetooth/hidp/core.c
+@@ -433,7 +433,7 @@ static void hidp_set_timer(struct hidp_session *session)
+ static void hidp_del_timer(struct hidp_session *session)
+ {
+ 	if (session->idle_to > 0)
+-		del_timer(&session->timer);
++		del_timer_sync(&session->timer);
+ }
+ 
+ static void hidp_process_report(struct hidp_session *session, int type,
+diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
+index 0194c25b8dc57..446343348329f 100644
+--- a/net/bluetooth/l2cap_core.c
++++ b/net/bluetooth/l2cap_core.c
+@@ -4652,33 +4652,27 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn,
+ 
+ 	BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
+ 
+-	mutex_lock(&conn->chan_lock);
+-
+-	chan = __l2cap_get_chan_by_scid(conn, dcid);
++	chan = l2cap_get_chan_by_scid(conn, dcid);
+ 	if (!chan) {
+-		mutex_unlock(&conn->chan_lock);
+ 		cmd_reject_invalid_cid(conn, cmd->ident, dcid, scid);
+ 		return 0;
+ 	}
+ 
+-	l2cap_chan_hold(chan);
+-	l2cap_chan_lock(chan);
+-
+ 	rsp.dcid = cpu_to_le16(chan->scid);
+ 	rsp.scid = cpu_to_le16(chan->dcid);
+ 	l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
+ 
+ 	chan->ops->set_shutdown(chan);
+ 
++	mutex_lock(&conn->chan_lock);
+ 	l2cap_chan_del(chan, ECONNRESET);
++	mutex_unlock(&conn->chan_lock);
+ 
+ 	chan->ops->close(chan);
+ 
+ 	l2cap_chan_unlock(chan);
+ 	l2cap_chan_put(chan);
+ 
+-	mutex_unlock(&conn->chan_lock);
+-
+ 	return 0;
+ }
+ 
+@@ -4698,33 +4692,27 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn,
+ 
+ 	BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
+ 
+-	mutex_lock(&conn->chan_lock);
+-
+-	chan = __l2cap_get_chan_by_scid(conn, scid);
++	chan = l2cap_get_chan_by_scid(conn, scid);
+ 	if (!chan) {
+ 		mutex_unlock(&conn->chan_lock);
+ 		return 0;
+ 	}
+ 
+-	l2cap_chan_hold(chan);
+-	l2cap_chan_lock(chan);
+-
+ 	if (chan->state != BT_DISCONN) {
+ 		l2cap_chan_unlock(chan);
+ 		l2cap_chan_put(chan);
+-		mutex_unlock(&conn->chan_lock);
+ 		return 0;
+ 	}
+ 
++	mutex_lock(&conn->chan_lock);
+ 	l2cap_chan_del(chan, 0);
++	mutex_unlock(&conn->chan_lock);
+ 
+ 	chan->ops->close(chan);
+ 
+ 	l2cap_chan_unlock(chan);
+ 	l2cap_chan_put(chan);
+ 
+-	mutex_unlock(&conn->chan_lock);
+-
+ 	return 0;
+ }
+ 
+diff --git a/net/core/skbuff.c b/net/core/skbuff.c
+index 2d3f82b622366..46cc3a7632f79 100644
+--- a/net/core/skbuff.c
++++ b/net/core/skbuff.c
+@@ -5397,18 +5397,18 @@ bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
+ 	if (skb_cloned(to))
+ 		return false;
+ 
+-	/* In general, avoid mixing slab allocated and page_pool allocated
+-	 * pages within the same SKB. However when @to is not pp_recycle and
+-	 * @from is cloned, we can transition frag pages from page_pool to
+-	 * reference counted.
+-	 *
+-	 * On the other hand, don't allow coalescing two pp_recycle SKBs if
+-	 * @from is cloned, in case the SKB is using page_pool fragment
++	/* In general, avoid mixing page_pool and non-page_pool allocated
++	 * pages within the same SKB. Additionally avoid dealing with clones
++	 * with page_pool pages, in case the SKB is using page_pool fragment
+ 	 * references (PP_FLAG_PAGE_FRAG). Since we only take full page
+ 	 * references for cloned SKBs at the moment that would result in
+ 	 * inconsistent reference counts.
++	 * In theory we could take full references if @from is cloned and
++	 * !@to->pp_recycle but its tricky (due to potential race with
++	 * the clone disappearing) and rare, so not worth dealing with.
+ 	 */
+-	if (to->pp_recycle != (from->pp_recycle && !skb_cloned(from)))
++	if (to->pp_recycle != from->pp_recycle ||
++	    (from->pp_recycle && skb_cloned(from)))
+ 		return false;
+ 
+ 	if (len <= skb_tailroom(to)) {
+diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
+index 495c58e442e2a..1f22e72074fdc 100644
+--- a/net/ipv4/sysctl_net_ipv4.c
++++ b/net/ipv4/sysctl_net_ipv4.c
+@@ -38,6 +38,7 @@ static int ip_local_port_range_min[] = { 1, 1 };
+ static int ip_local_port_range_max[] = { 65535, 65535 };
+ static int tcp_adv_win_scale_min = -31;
+ static int tcp_adv_win_scale_max = 31;
++static int tcp_app_win_max = 31;
+ static int tcp_min_snd_mss_min = TCP_MIN_SND_MSS;
+ static int tcp_min_snd_mss_max = 65535;
+ static int ip_privileged_port_min;
+@@ -1168,6 +1169,8 @@ static struct ctl_table ipv4_net_table[] = {
+ 		.maxlen		= sizeof(u8),
+ 		.mode		= 0644,
+ 		.proc_handler	= proc_dou8vec_minmax,
++		.extra1		= SYSCTL_ZERO,
++		.extra2		= &tcp_app_win_max,
+ 	},
+ 	{
+ 		.procname	= "tcp_adv_win_scale",
+diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
+index 0e1fbad17dbe3..63472c9b39ae4 100644
+--- a/net/ipv4/tcp_ipv4.c
++++ b/net/ipv4/tcp_ipv4.c
+@@ -2760,7 +2760,7 @@ static int tcp_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,
+ static void bpf_iter_tcp_put_batch(struct bpf_tcp_iter_state *iter)
+ {
+ 	while (iter->cur_sk < iter->end_sk)
+-		sock_put(iter->batch[iter->cur_sk++]);
++		sock_gen_put(iter->batch[iter->cur_sk++]);
+ }
+ 
+ static int bpf_iter_tcp_realloc_batch(struct bpf_tcp_iter_state *iter,
+@@ -2919,7 +2919,7 @@ static void *bpf_iter_tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+ 		 * st->bucket.  See tcp_seek_last_pos().
+ 		 */
+ 		st->offset++;
+-		sock_put(iter->batch[iter->cur_sk++]);
++		sock_gen_put(iter->batch[iter->cur_sk++]);
+ 	}
+ 
+ 	if (iter->cur_sk < iter->end_sk)
+diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
+index 9dfb4bb54344b..921129c3df8ad 100644
+--- a/net/ipv6/udp.c
++++ b/net/ipv6/udp.c
+@@ -1359,9 +1359,11 @@ int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
+ 			msg->msg_name = &sin;
+ 			msg->msg_namelen = sizeof(sin);
+ do_udp_sendmsg:
+-			if (__ipv6_only_sock(sk))
+-				return -ENETUNREACH;
+-			return udp_sendmsg(sk, msg, len);
++			err = __ipv6_only_sock(sk) ?
++				-ENETUNREACH : udp_sendmsg(sk, msg, len);
++			msg->msg_name = sin6;
++			msg->msg_namelen = addr_len;
++			return err;
+ 		}
+ 	}
+ 
+diff --git a/net/mptcp/options.c b/net/mptcp/options.c
+index 193f0fcce8d85..aa4b0cf7c6380 100644
+--- a/net/mptcp/options.c
++++ b/net/mptcp/options.c
+@@ -1156,9 +1156,8 @@ bool mptcp_incoming_options(struct sock *sk, struct sk_buff *skb)
+ 	 */
+ 	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
+ 		if (mp_opt.data_fin && mp_opt.data_len == 1 &&
+-		    mptcp_update_rcv_data_fin(msk, mp_opt.data_seq, mp_opt.dsn64) &&
+-		    schedule_work(&msk->work))
+-			sock_hold(subflow->conn);
++		    mptcp_update_rcv_data_fin(msk, mp_opt.data_seq, mp_opt.dsn64))
++			mptcp_schedule_work((struct sock *)msk);
+ 
+ 		return true;
+ 	}
+diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c
+index 5d05d85242bc6..4c4577775c5df 100644
+--- a/net/mptcp/protocol.c
++++ b/net/mptcp/protocol.c
+@@ -2448,7 +2448,7 @@ static void mptcp_worker(struct work_struct *work)
+ 
+ 	lock_sock(sk);
+ 	state = sk->sk_state;
+-	if (unlikely(state == TCP_CLOSE))
++	if (unlikely((1 << state) & (TCPF_CLOSE | TCPF_LISTEN)))
+ 		goto unlock;
+ 
+ 	mptcp_check_data_fin_ack(sk);
+diff --git a/net/mptcp/subflow.c b/net/mptcp/subflow.c
+index 232f437770a67..9b89999062c97 100644
+--- a/net/mptcp/subflow.c
++++ b/net/mptcp/subflow.c
+@@ -360,9 +360,8 @@ void mptcp_subflow_reset(struct sock *ssk)
+ 
+ 	tcp_send_active_reset(ssk, GFP_ATOMIC);
+ 	tcp_done(ssk);
+-	if (!test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &mptcp_sk(sk)->flags) &&
+-	    schedule_work(&mptcp_sk(sk)->work))
+-		return; /* worker will put sk for us */
++	if (!test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &mptcp_sk(sk)->flags))
++		mptcp_schedule_work(sk);
+ 
+ 	sock_put(sk);
+ }
+@@ -1010,8 +1009,8 @@ static enum mapping_status get_mapping_status(struct sock *ssk,
+ 				skb_ext_del(skb, SKB_EXT_MPTCP);
+ 				return MAPPING_OK;
+ 			} else {
+-				if (updated && schedule_work(&msk->work))
+-					sock_hold((struct sock *)msk);
++				if (updated)
++					mptcp_schedule_work((struct sock *)msk);
+ 
+ 				return MAPPING_DATA_FIN;
+ 			}
+@@ -1114,17 +1113,12 @@ static void mptcp_subflow_discard_data(struct sock *ssk, struct sk_buff *skb,
+ /* sched mptcp worker to remove the subflow if no more data is pending */
+ static void subflow_sched_work_if_closed(struct mptcp_sock *msk, struct sock *ssk)
+ {
+-	struct sock *sk = (struct sock *)msk;
+-
+ 	if (likely(ssk->sk_state != TCP_CLOSE))
+ 		return;
+ 
+ 	if (skb_queue_empty(&ssk->sk_receive_queue) &&
+-	    !test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags)) {
+-		sock_hold(sk);
+-		if (!schedule_work(&msk->work))
+-			sock_put(sk);
+-	}
++	    !test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags))
++		mptcp_schedule_work((struct sock *)msk);
+ }
+ 
+ static bool subflow_can_fallback(struct mptcp_subflow_context *subflow)
+diff --git a/net/qrtr/af_qrtr.c b/net/qrtr/af_qrtr.c
+index 6e88ba812d2a2..e0a27a404404f 100644
+--- a/net/qrtr/af_qrtr.c
++++ b/net/qrtr/af_qrtr.c
+@@ -498,6 +498,11 @@ int qrtr_endpoint_post(struct qrtr_endpoint *ep, const void *data, size_t len)
+ 	if (!size || len != ALIGN(size, 4) + hdrlen)
+ 		goto err;
+ 
++	if ((cb->type == QRTR_TYPE_NEW_SERVER ||
++	     cb->type == QRTR_TYPE_RESUME_TX) &&
++	    size < sizeof(struct qrtr_ctrl_pkt))
++		goto err;
++
+ 	if (cb->dst_port != QRTR_PORT_CTRL && cb->type != QRTR_TYPE_DATA &&
+ 	    cb->type != QRTR_TYPE_RESUME_TX)
+ 		goto err;
+@@ -510,9 +515,6 @@ int qrtr_endpoint_post(struct qrtr_endpoint *ep, const void *data, size_t len)
+ 		/* Remote node endpoint can bridge other distant nodes */
+ 		const struct qrtr_ctrl_pkt *pkt;
+ 
+-		if (size < sizeof(*pkt))
+-			goto err;
+-
+ 		pkt = data + hdrlen;
+ 		qrtr_node_assign(node, le32_to_cpu(pkt->server.node));
+ 	}
+diff --git a/net/sctp/stream_interleave.c b/net/sctp/stream_interleave.c
+index 6b13f737ebf2e..e3aad75cb11d9 100644
+--- a/net/sctp/stream_interleave.c
++++ b/net/sctp/stream_interleave.c
+@@ -1162,7 +1162,8 @@ static void sctp_generate_iftsn(struct sctp_outq *q, __u32 ctsn)
+ 
+ #define _sctp_walk_ifwdtsn(pos, chunk, end) \
+ 	for (pos = chunk->subh.ifwdtsn_hdr->skip; \
+-	     (void *)pos < (void *)chunk->subh.ifwdtsn_hdr->skip + (end); pos++)
++	     (void *)pos <= (void *)chunk->subh.ifwdtsn_hdr->skip + (end) - \
++			    sizeof(struct sctp_ifwdtsn_skip); pos++)
+ 
+ #define sctp_walk_ifwdtsn(pos, ch) \
+ 	_sctp_walk_ifwdtsn((pos), (ch), ntohs((ch)->chunk_hdr->length) - \
+diff --git a/sound/firewire/tascam/tascam-stream.c b/sound/firewire/tascam/tascam-stream.c
+index 53e094cc411f8..dfe783d01d7d2 100644
+--- a/sound/firewire/tascam/tascam-stream.c
++++ b/sound/firewire/tascam/tascam-stream.c
+@@ -490,7 +490,7 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
+ 		// packet is important for media clock recovery.
+ 		err = amdtp_domain_start(&tscm->domain, tx_init_skip_cycles, true, true);
+ 		if (err < 0)
+-			return err;
++			goto error;
+ 
+ 		if (!amdtp_domain_wait_ready(&tscm->domain, READY_TIMEOUT_MS)) {
+ 			err = -ETIMEDOUT;
+diff --git a/sound/i2c/cs8427.c b/sound/i2c/cs8427.c
+index 65012af6a36e4..f58b14b490455 100644
+--- a/sound/i2c/cs8427.c
++++ b/sound/i2c/cs8427.c
+@@ -561,10 +561,13 @@ int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active)
+ 	if (snd_BUG_ON(!cs8427))
+ 		return -ENXIO;
+ 	chip = cs8427->private_data;
+-	if (active)
++	if (active) {
+ 		memcpy(chip->playback.pcm_status,
+ 		       chip->playback.def_status, 24);
+-	chip->playback.pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
++		chip->playback.pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
++	} else {
++		chip->playback.pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
++	}
+ 	snd_ctl_notify(cs8427->bus->card,
+ 		       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
+ 		       &chip->playback.pcm_ctl->id);
+diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
+index 48af77ae8020f..6ec394fb18468 100644
+--- a/sound/pci/emu10k1/emupcm.c
++++ b/sound/pci/emu10k1/emupcm.c
+@@ -1236,7 +1236,7 @@ static int snd_emu10k1_capture_mic_close(struct snd_pcm_substream *substream)
+ {
+ 	struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
+ 
+-	emu->capture_interrupt = NULL;
++	emu->capture_mic_interrupt = NULL;
+ 	emu->pcm_capture_mic_substream = NULL;
+ 	return 0;
+ }
+@@ -1344,7 +1344,7 @@ static int snd_emu10k1_capture_efx_close(struct snd_pcm_substream *substream)
+ {
+ 	struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
+ 
+-	emu->capture_interrupt = NULL;
++	emu->capture_efx_interrupt = NULL;
+ 	emu->pcm_capture_efx_substream = NULL;
+ 	return 0;
+ }
+@@ -1781,17 +1781,21 @@ int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device)
+ 	struct snd_kcontrol *kctl;
+ 	int err;
+ 
+-	err = snd_pcm_new(emu->card, "emu10k1 efx", device, 8, 1, &pcm);
++	err = snd_pcm_new(emu->card, "emu10k1 efx", device, emu->audigy ? 0 : 8, 1, &pcm);
+ 	if (err < 0)
+ 		return err;
+ 
+ 	pcm->private_data = emu;
+ 
+-	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_fx8010_playback_ops);
++	if (!emu->audigy)
++		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_fx8010_playback_ops);
+ 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_efx_ops);
+ 
+ 	pcm->info_flags = 0;
+-	strcpy(pcm->name, "Multichannel Capture/PT Playback");
++	if (emu->audigy)
++		strcpy(pcm->name, "Multichannel Capture");
++	else
++		strcpy(pcm->name, "Multichannel Capture/PT Playback");
+ 	emu->pcm_efx = pcm;
+ 
+ 	/* EFX capture - record the "FXBUS2" channels, by default we connect the EXTINs 
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index a794a01a68ca6..61258b0aac8d6 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -1707,6 +1707,7 @@ static const struct snd_pci_quirk stac925x_fixup_tbl[] = {
+ };
+ 
+ static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
++	// Port A-H
+ 	{ 0x0a, 0x02214030 },
+ 	{ 0x0b, 0x02a19040 },
+ 	{ 0x0c, 0x01a19020 },
+@@ -1715,9 +1716,12 @@ static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
+ 	{ 0x0f, 0x01014010 },
+ 	{ 0x10, 0x01014020 },
+ 	{ 0x11, 0x01014030 },
++	// CD in
+ 	{ 0x12, 0x02319040 },
++	// Digial Mic ins
+ 	{ 0x13, 0x90a000f0 },
+ 	{ 0x14, 0x90a000f0 },
++	// Digital outs
+ 	{ 0x22, 0x01452050 },
+ 	{ 0x23, 0x01452050 },
+ 	{}
+@@ -1758,6 +1762,7 @@ static const struct hda_pintbl alienware_m17x_pin_configs[] = {
+ };
+ 
+ static const struct hda_pintbl intel_dg45id_pin_configs[] = {
++	// Analog outputs
+ 	{ 0x0a, 0x02214230 },
+ 	{ 0x0b, 0x02A19240 },
+ 	{ 0x0c, 0x01013214 },
+@@ -1765,6 +1770,9 @@ static const struct hda_pintbl intel_dg45id_pin_configs[] = {
+ 	{ 0x0e, 0x01A19250 },
+ 	{ 0x0f, 0x01011212 },
+ 	{ 0x10, 0x01016211 },
++	// Digital output
++	{ 0x22, 0x01451380 },
++	{ 0x23, 0x40f000f0 },
+ 	{}
+ };
+ 
+@@ -1955,6 +1963,8 @@ static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
+ 				"DFI LanParty", STAC_92HD73XX_REF),
+ 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+ 				"DFI LanParty", STAC_92HD73XX_REF),
++	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5001,
++				"Intel DP45SG", STAC_92HD73XX_INTEL),
+ 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
+ 				"Intel DG45ID", STAC_92HD73XX_INTEL),
+ 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
+diff --git a/tools/lib/bpf/btf_dump.c b/tools/lib/bpf/btf_dump.c
+index a9f974e5fb856..98cb3831aa18c 100644
+--- a/tools/lib/bpf/btf_dump.c
++++ b/tools/lib/bpf/btf_dump.c
+@@ -1003,9 +1003,12 @@ static void btf_dump_emit_struct_def(struct btf_dump *d,
+ 	 * Keep `struct empty {}` on a single line,
+ 	 * only print newline when there are regular or padding fields.
+ 	 */
+-	if (vlen || t->size)
++	if (vlen || t->size) {
+ 		btf_dump_printf(d, "\n");
+-	btf_dump_printf(d, "%s}", pfx(lvl));
++		btf_dump_printf(d, "%s}", pfx(lvl));
++	} else {
++		btf_dump_printf(d, "}");
++	}
+ 	if (packed)
+ 		btf_dump_printf(d, " __attribute__((packed))");
+ }