| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20250409144250.206590-6-ivecera@redhat.com>
Date: Wed, 9 Apr 2025 16:42:41 +0200
From: Ivan Vecera <ivecera@...hat.com>
To: netdev@...r.kernel.org
Cc: Vadim Fedorenko <vadim.fedorenko@...ux.dev>,
Arkadiusz Kubalewski <arkadiusz.kubalewski@...el.com>,
Jiri Pirko <jiri@...nulli.us>,
Rob Herring <robh@...nel.org>,
Krzysztof Kozlowski <krzk+dt@...nel.org>,
Conor Dooley <conor+dt@...nel.org>,
Prathosh Satish <Prathosh.Satish@...rochip.com>,
Lee Jones <lee@...nel.org>,
Kees Cook <kees@...nel.org>,
Andy Shevchenko <andy@...nel.org>,
Andrew Morton <akpm@...ux-foundation.org>,
Michal Schmidt <mschmidt@...hat.com>,
devicetree@...r.kernel.org,
linux-kernel@...r.kernel.org,
linux-hardening@...r.kernel.org
Subject: [PATCH v2 05/14] mfd: zl3073x: Add register access helpers
Add helpers zl3073x_{read,write}_reg() to access device registers.
These functions have to be called with device lock that can be taken
by zl3073x_{lock,unlock}() or a caller can use defined guard.
Locking mechanism of regmap is not sufficient because sometimes is
necessary to perform several register operations at once. This is
especially a case of register mailboxes (more details in patch 7 & 8).
Disable regmap locking mechanism and use this device lock instead.
Signed-off-by: Ivan Vecera <ivecera@...hat.com>
---
v1->v2:
* disabled regmap locking
---
drivers/mfd/zl3073x-core.c | 90 +++++++++++++++++++++++++++++++++++++
include/linux/mfd/zl3073x.h | 33 ++++++++++++++
2 files changed, 123 insertions(+)
diff --git a/drivers/mfd/zl3073x-core.c b/drivers/mfd/zl3073x-core.c
index 116c6dd9eebc7..f0d85f77a7a76 100644
--- a/drivers/mfd/zl3073x-core.c
+++ b/drivers/mfd/zl3073x-core.c
@@ -5,9 +5,11 @@
#include <linux/dev_printk.h>
#include <linux/device.h>
#include <linux/export.h>
+#include <linux/lockdep.h>
#include <linux/mfd/zl3073x.h>
#include <linux/module.h>
#include <linux/regmap.h>
+#include <linux/unaligned.h>
#include <net/devlink.h>
#include "zl3073x.h"
@@ -46,6 +48,7 @@ const struct regmap_config zl3073x_regmap_config = {
.max_register = ZL3073x_NUM_PAGES * ZL3073x_PAGE_SIZE,
.ranges = zl3073x_regmap_ranges,
.num_ranges = ARRAY_SIZE(zl3073x_regmap_ranges),
+ .disable_locking = true,
};
/**
@@ -59,6 +62,93 @@ const struct regmap_config *zl3073x_get_regmap_config(void)
}
EXPORT_SYMBOL_NS_GPL(zl3073x_get_regmap_config, "ZL3073X");
+/**
+ * zl3073x_read_reg - Read value from device register
+ * @zldev: pointer to zl3073x device
+ * @reg: register to be read
+ * @len: number of bytes to read
+ * @value: pointer to place to store value read from the register
+ *
+ * Caller has to hold the device lock that can be obtained
+ * by zl3073x_lock().
+ *
+ * Return: 0 on success or <0 on error
+ */
+int zl3073x_read_reg(struct zl3073x_dev *zldev, unsigned int reg,
+ unsigned int len, void *value)
+{
+ u8 buf[6];
+ int rc;
+
+ lockdep_assert_held(&zldev->lock);
+
+ rc = regmap_bulk_read(zldev->regmap, reg, buf, len);
+ if (rc)
+ return rc;
+
+ switch (len) {
+ case 1:
+ *(u8 *)value = buf[0];
+ break;
+ case 2:
+ *(u16 *)value = get_unaligned_be16(buf);
+ break;
+ case 4:
+ *(u32 *)value = get_unaligned_be32(buf);
+ break;
+ case 6:
+ *(u64 *)value = get_unaligned_be48(buf);
+ break;
+ default:
+ WARN(true, "Unsupported register size: %u\n", len);
+ break;
+ }
+
+ return rc;
+}
+EXPORT_SYMBOL_GPL(zl3073x_read_reg);
+
+/**
+ * zl3073x_write_reg - Write value to device register
+ * @zldev: pointer to zl3073x device
+ * @reg: register to be written
+ * @len: number of bytes to write
+ * @value: pointer to value to write to the register
+ *
+ * Caller has to hold the device lock that can be obtained
+ * by zl3073x_lock().
+ *
+ * Return: 0 on success, <0 on error
+ */
+int zl3073x_write_reg(struct zl3073x_dev *zldev, unsigned int reg,
+ unsigned int len, const void *value)
+{
+ u8 buf[6];
+
+ lockdep_assert_held(&zldev->lock);
+
+ switch (len) {
+ case 1:
+ buf[0] = *(u8 *)value;
+ break;
+ case 2:
+ put_unaligned_be16(*(u16 *)value, buf);
+ break;
+ case 4:
+ put_unaligned_be32(*(u32 *)value, buf);
+ break;
+ case 6:
+ put_unaligned_be48(*(u64 *)value, buf);
+ break;
+ default:
+ WARN(true, "Unsupported register size: %u\n", len);
+ break;
+ }
+
+ return regmap_bulk_write(zldev->regmap, reg, buf, len);
+}
+EXPORT_SYMBOL_GPL(zl3073x_write_reg);
+
static const struct devlink_ops zl3073x_devlink_ops = {
};
diff --git a/include/linux/mfd/zl3073x.h b/include/linux/mfd/zl3073x.h
index f3f33ef8bfa18..00dcc73aeeb34 100644
--- a/include/linux/mfd/zl3073x.h
+++ b/include/linux/mfd/zl3073x.h
@@ -3,6 +3,7 @@
#ifndef __LINUX_MFD_ZL3073X_H
#define __LINUX_MFD_ZL3073X_H
+#include <linux/cleanup.h>
#include <linux/mutex.h>
struct device;
@@ -20,4 +21,36 @@ struct zl3073x_dev {
struct mutex lock;
};
+/**
+ * zl3073x_lock - Lock the device
+ * @zldev: device structure pointer
+ *
+ * Caller has to take this lock when it needs to access device registers.
+ */
+static inline void zl3073x_lock(struct zl3073x_dev *zldev)
+{
+ mutex_lock(&zldev->lock);
+}
+
+/**
+ * zl3073x_unlock - Unlock the device
+ * @zldev: device structure pointer
+ *
+ * Caller unlocks the device when it does not need to access device
+ * registers anymore.
+ */
+static inline void zl3073x_unlock(struct zl3073x_dev *zldev)
+{
+ mutex_unlock(&zldev->lock);
+}
+
+DEFINE_GUARD(zl3073x, struct zl3073x_dev *, zl3073x_lock(_T),
+ zl3073x_unlock(_T));
+
+int zl3073x_read_reg(struct zl3073x_dev *zldev, unsigned int reg,
+ unsigned int len, void *value);
+
+int zl3073x_write_reg(struct zl3073x_dev *zldev, unsigned int reg,
+ unsigned int len, const void *value);
+
#endif /* __LINUX_MFD_ZL3073X_H */
--
2.48.1
Powered by blists - more mailing lists