From 30eb99dfd3439f25d0f79815f7f859da03fc8fff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= Date: Wed, 10 Dec 2025 08:02:53 +0100 Subject: [PATCH 01/59] gpio: stub: Drop empty probe function MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A probe callback that just returns 0 does the same as not having a probe callback at all. So gpio_stub_drv_probe() can be dropped without side effects. Signed-off-by: Uwe Kleine-König Link: https://lore.kernel.org/r/20251210070255.484169-2-u.kleine-koenig@baylibre.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.c | 30 ++++++++++++------------------ 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index 91e0c384f34a..409c2f415251 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -5242,27 +5242,21 @@ void gpiod_put_array(struct gpio_descs *descs) } EXPORT_SYMBOL_GPL(gpiod_put_array); -static int gpio_stub_drv_probe(struct device *dev) -{ - /* - * The DT node of some GPIO chips have a "compatible" property, but - * never have a struct device added and probed by a driver to register - * the GPIO chip with gpiolib. In such cases, fw_devlink=on will cause - * the consumers of the GPIO chip to get probe deferred forever because - * they will be waiting for a device associated with the GPIO chip - * firmware node to get added and bound to a driver. - * - * To allow these consumers to probe, we associate the struct - * gpio_device of the GPIO chip with the firmware node and then simply - * bind it to this stub driver. - */ - return 0; -} - +/* + * The DT node of some GPIO chips have a "compatible" property, but + * never have a struct device added and probed by a driver to register + * the GPIO chip with gpiolib. In such cases, fw_devlink=on will cause + * the consumers of the GPIO chip to get probe deferred forever because + * they will be waiting for a device associated with the GPIO chip + * firmware node to get added and bound to a driver. + * + * To allow these consumers to probe, we associate the struct + * gpio_device of the GPIO chip with the firmware node and then simply + * bind it to this stub driver. + */ static struct device_driver gpio_stub_drv = { .name = "gpio_stub_drv", .bus = &gpio_bus_type, - .probe = gpio_stub_drv_probe, }; static int __init gpiolib_dev_init(void) From 77f25f0c2e1f59b35600b4d29bd6b2c54c31ab75 Mon Sep 17 00:00:00 2001 From: Daniel Palmer Date: Sun, 14 Dec 2025 12:40:45 +0900 Subject: [PATCH 02/59] gpiolib: of: Only compile in MT2701 quirk when it is needed. The compiler cannot workout if this is actually needed or not so machines that will never need this code also get it. For example: m68k-linux-gnu-nm vmlinux | grep mt27 00135742 t of_find_mt2701_gpio Add some ugly ifdef'ery to get rid of it. Signed-off-by: Daniel Palmer Link: https://lore.kernel.org/r/20251214034045.4029590-1-daniel@thingy.jp Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib-of.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c index 8657379e9165..ef1ac68b94b7 100644 --- a/drivers/gpio/gpiolib-of.c +++ b/drivers/gpio/gpiolib-of.c @@ -634,6 +634,7 @@ static struct gpio_desc *of_find_gpio_rename(struct device_node *np, return ERR_PTR(-ENOENT); } +#if IS_ENABLED(CONFIG_SND_SOC_MT2701_CS42448) static struct gpio_desc *of_find_mt2701_gpio(struct device_node *np, const char *con_id, unsigned int idx, @@ -665,6 +666,7 @@ static struct gpio_desc *of_find_mt2701_gpio(struct device_node *np, return desc; } +#endif /* * Trigger sources are special, they allow us to use any GPIO as a LED trigger @@ -699,7 +701,9 @@ typedef struct gpio_desc *(*of_find_gpio_quirk)(struct device_node *np, enum of_gpio_flags *of_flags); static const of_find_gpio_quirk of_find_gpio_quirks[] = { of_find_gpio_rename, +#if IS_ENABLED(CONFIG_SND_SOC_MT2701_CS42448) of_find_mt2701_gpio, +#endif of_find_trigger_gpio, NULL }; From 0eaf298143684da68a61b2633121b3deff47b267 Mon Sep 17 00:00:00 2001 From: Christophe JAILLET Date: Sun, 14 Dec 2025 10:31:40 +0100 Subject: [PATCH 03/59] gpio: Constify struct configfs_item_operations and configfs_group_operations 'struct configfs_item_operations' and 'configfs_group_operations' are not modified in these drivers. Constifying these structures moves some data to a read-only section, so increases overall security, especially when the structure holds some function pointers. On a x86_64, with allmodconfig, as an example: Before: ====== text data bss dec hex filename 43935 11632 384 55951 da8f drivers/gpio/gpio-aggregator.o After: ===== text data bss dec hex filename 44191 11376 384 55951 da8f drivers/gpio/gpio-aggregator.o Signed-off-by: Christophe JAILLET Link: https://lore.kernel.org/r/ccb5155342ce6dbb89cfbad0687b448860d8e8f0.1765703044.git.christophe.jaillet@wanadoo.fr Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aggregator.c | 8 ++++---- drivers/gpio/gpio-sim.c | 16 ++++++++-------- drivers/gpio/gpio-virtuser.c | 8 ++++---- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/drivers/gpio/gpio-aggregator.c b/drivers/gpio/gpio-aggregator.c index 416f265d09d0..a4cd32674a96 100644 --- a/drivers/gpio/gpio-aggregator.c +++ b/drivers/gpio/gpio-aggregator.c @@ -1226,7 +1226,7 @@ gpio_aggregator_line_release(struct config_item *item) kfree(line); } -static struct configfs_item_operations gpio_aggregator_line_item_ops = { +static const struct configfs_item_operations gpio_aggregator_line_item_ops = { .release = gpio_aggregator_line_release, }; @@ -1247,7 +1247,7 @@ static void gpio_aggregator_device_release(struct config_item *item) gpio_aggregator_free(aggr); } -static struct configfs_item_operations gpio_aggregator_device_item_ops = { +static const struct configfs_item_operations gpio_aggregator_device_item_ops = { .release = gpio_aggregator_device_release, }; @@ -1292,7 +1292,7 @@ gpio_aggregator_device_make_group(struct config_group *group, const char *name) return &line->group; } -static struct configfs_group_operations gpio_aggregator_device_group_ops = { +static const struct configfs_group_operations gpio_aggregator_device_group_ops = { .make_group = gpio_aggregator_device_make_group, }; @@ -1328,7 +1328,7 @@ gpio_aggregator_make_group(struct config_group *group, const char *name) return &aggr->group; } -static struct configfs_group_operations gpio_aggregator_group_ops = { +static const struct configfs_group_operations gpio_aggregator_group_ops = { .make_group = gpio_aggregator_make_group, }; diff --git a/drivers/gpio/gpio-sim.c b/drivers/gpio/gpio-sim.c index a83f5238427c..437b4500f56b 100644 --- a/drivers/gpio/gpio-sim.c +++ b/drivers/gpio/gpio-sim.c @@ -1384,7 +1384,7 @@ static void gpio_sim_hog_config_item_release(struct config_item *item) kfree(hog); } -static struct configfs_item_operations gpio_sim_hog_config_item_ops = { +static const struct configfs_item_operations gpio_sim_hog_config_item_ops = { .release = gpio_sim_hog_config_item_release, }; @@ -1433,11 +1433,11 @@ static void gpio_sim_line_config_group_release(struct config_item *item) kfree(line); } -static struct configfs_item_operations gpio_sim_line_config_item_ops = { +static const struct configfs_item_operations gpio_sim_line_config_item_ops = { .release = gpio_sim_line_config_group_release, }; -static struct configfs_group_operations gpio_sim_line_config_group_ops = { +static const struct configfs_group_operations gpio_sim_line_config_group_ops = { .make_item = gpio_sim_line_config_make_hog_item, }; @@ -1494,11 +1494,11 @@ static void gpio_sim_bank_config_group_release(struct config_item *item) kfree(bank); } -static struct configfs_item_operations gpio_sim_bank_config_item_ops = { +static const struct configfs_item_operations gpio_sim_bank_config_item_ops = { .release = gpio_sim_bank_config_group_release, }; -static struct configfs_group_operations gpio_sim_bank_config_group_ops = { +static const struct configfs_group_operations gpio_sim_bank_config_group_ops = { .make_group = gpio_sim_bank_config_make_line_group, }; @@ -1549,11 +1549,11 @@ static void gpio_sim_device_config_group_release(struct config_item *item) kfree(dev); } -static struct configfs_item_operations gpio_sim_device_config_item_ops = { +static const struct configfs_item_operations gpio_sim_device_config_item_ops = { .release = gpio_sim_device_config_group_release, }; -static struct configfs_group_operations gpio_sim_device_config_group_ops = { +static const struct configfs_group_operations gpio_sim_device_config_group_ops = { .make_group = gpio_sim_device_config_make_bank_group, }; @@ -1589,7 +1589,7 @@ gpio_sim_config_make_device_group(struct config_group *group, const char *name) return &no_free_ptr(dev)->group; } -static struct configfs_group_operations gpio_sim_config_group_ops = { +static const struct configfs_group_operations gpio_sim_config_group_ops = { .make_group = gpio_sim_config_make_device_group, }; diff --git a/drivers/gpio/gpio-virtuser.c b/drivers/gpio/gpio-virtuser.c index 37f2ce20f1ae..090f5643afaf 100644 --- a/drivers/gpio/gpio-virtuser.c +++ b/drivers/gpio/gpio-virtuser.c @@ -1631,7 +1631,7 @@ static void gpio_virtuser_lookup_config_group_release(struct config_item *item) kfree(lookup); } -static struct configfs_item_operations gpio_virtuser_lookup_config_item_ops = { +static const struct configfs_item_operations gpio_virtuser_lookup_config_item_ops = { .release = gpio_virtuser_lookup_config_group_release, }; @@ -1692,11 +1692,11 @@ static void gpio_virtuser_device_config_group_release(struct config_item *item) kfree(dev); } -static struct configfs_item_operations gpio_virtuser_device_config_item_ops = { +static const struct configfs_item_operations gpio_virtuser_device_config_item_ops = { .release = gpio_virtuser_device_config_group_release, }; -static struct configfs_group_operations gpio_virtuser_device_config_group_ops = { +static const struct configfs_group_operations gpio_virtuser_device_config_group_ops = { .make_group = gpio_virtuser_make_lookup_group, }; @@ -1729,7 +1729,7 @@ gpio_virtuser_config_make_device_group(struct config_group *group, return &no_free_ptr(dev)->group; } -static struct configfs_group_operations gpio_virtuser_config_group_ops = { +static const struct configfs_group_operations gpio_virtuser_config_group_ops = { .make_group = gpio_virtuser_config_make_device_group, }; From 3203d8f573af87d8c967d36e8d5016ef306ff078 Mon Sep 17 00:00:00 2001 From: Rosen Penev Date: Tue, 16 Dec 2025 22:32:28 -0800 Subject: [PATCH 04/59] gpio: realtek-otto: add COMPILE_TEST Allows the buildbots to test compilation. Signed-off-by: Rosen Penev Link: https://lore.kernel.org/r/20251217063229.38175-3-rosenp@gmail.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index bd185482a7fd..fb6b479700d3 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -600,7 +600,7 @@ config GPIO_RDA config GPIO_REALTEK_OTTO tristate "Realtek Otto GPIO support" - depends on MACH_REALTEK_RTL + depends on MACH_REALTEK_RTL || COMPILE_TEST default MACH_REALTEK_RTL select GPIO_GENERIC select GPIOLIB_IRQCHIP From d19c36134fe14647873af5569329489502c174b9 Mon Sep 17 00:00:00 2001 From: Jan Remmet Date: Tue, 16 Dec 2025 08:39:33 +0100 Subject: [PATCH 05/59] Documentation: gpio: add TCAL6408 and TCAL6416 Checked datasheets, the offsets are identical to pcal6408 and pcal6416. Signed-off-by: Jan Remmet Link: https://lore.kernel.org/r/20251216-wip-jremmet-tcal6416rtw-v2-1-6516d98a9836@phytec.de Signed-off-by: Bartosz Golaszewski --- Documentation/driver-api/gpio/pca953x.rst | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Documentation/driver-api/gpio/pca953x.rst b/Documentation/driver-api/gpio/pca953x.rst index 4bd7cf1120cb..53f25fa03072 100644 --- a/Documentation/driver-api/gpio/pca953x.rst +++ b/Documentation/driver-api/gpio/pca953x.rst @@ -178,6 +178,8 @@ pcal9554b 8 yes 00 01 02 03 pcal6416 16 yes 00 02 04 06 pcal9535 16 yes 00 02 04 06 pcal9555a 16 yes 00 02 04 06 +tcal6408 8 yes 00 01 02 03 +tcal6416 16 yes 00 02 04 06 ========== ===== ========= ===== ====== ====== ========= These chips have several additional features: @@ -196,6 +198,8 @@ pcal9554b 40 42 43 44 45 46 4F pcal6416 40 44 46 48 4A 4C 4F pcal9535 40 44 46 48 4A 4C 4F pcal9555a 40 44 46 48 4A 4C 4F +tcal6408 40 42 43 44 45 46 4F +tcal6416 40 44 46 48 4A 4C 4F ========== ============ ======== ======= ======== ======== ========== ======== Currently the driver has support for the input latch, pull-up/pull-down @@ -332,6 +336,8 @@ Layouts: - pcal9554b - pcal9555a - pcal6524 + - tcal6408 + - tcal6416 2. base offset 0x30, bank 5 and 6, closely packed banks - pcal6534 @@ -390,6 +396,8 @@ enabled. - pcal9554b - pcal9555a - pcal6524 + - tcal6408 + - tcal6416 2. base offset 0x30, bank 2, closely packed banks - pcal6534 @@ -462,6 +470,8 @@ Layout: - pcal9535 - pcal9554b - pcal9555a + - tcal6408 + - tcal6416 `PCAL chips with extended interrupt and output configuration functions`_ can set this for each line individually. They have the same per-port out_conf @@ -505,6 +515,8 @@ bits drive strength - pcal9554b - pcal9555a - pcal6524 + - tcal6408 + - tcal6416 2. base offset 0x30, bank 0 and 1, closely packed banks - pcal6534 From 9b5f506ff6c11e82574e7f6aa763c92ddb3afc57 Mon Sep 17 00:00:00 2001 From: Jan Remmet Date: Tue, 16 Dec 2025 08:39:34 +0100 Subject: [PATCH 06/59] dt-bindings: gpio: gpio-pca95xx: Add tcal6408 and tcal6416 TCAL6408 and TCAL6416 supports latchable inputs and maskable interrupt. add compatibles ti,tcal6408 and ti,tcal6416 The TI variants has the same programming model as the NXP PCAL6408 and PCAL6416, but supports other supply voltages. Acked-by: Krzysztof Kozlowski Signed-off-by: Jan Remmet Link: https://lore.kernel.org/r/20251216-wip-jremmet-tcal6416rtw-v2-2-6516d98a9836@phytec.de Signed-off-by: Bartosz Golaszewski --- Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml b/Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml index 12134c737ad8..4f955f855e1a 100644 --- a/Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml +++ b/Documentation/devicetree/bindings/gpio/gpio-pca95xx.yaml @@ -74,6 +74,8 @@ properties: - ti,tca9538 - ti,tca9539 - ti,tca9554 + - ti,tcal6408 + - ti,tcal6416 reg: maxItems: 1 From a30a9cb9bca4296d25f253619883e7013b6be158 Mon Sep 17 00:00:00 2001 From: Jan Remmet Date: Tue, 16 Dec 2025 08:39:35 +0100 Subject: [PATCH 07/59] gpio: pca953x: Add support for TCAL6408 TCAL6416 TCAL6408 and TCAL6416 supports latchable inputs and maskable interrupt. Tested on a TCAL6416, checked datasheets for the TCAL6408. They use the same programming model ad the NXP PCAL64xx, but support a lower supply power (1.08V to 3.6V) compared to PCAL (1.65V to 5.5V) Datasheet: https://www.ti.com/lit/ds/symlink/tcal6408.pdf Datasheet: https://www.ti.com/lit/ds/symlink/tcal6416.pdf Signed-off-by: Jan Remmet Link: https://lore.kernel.org/r/20251216-wip-jremmet-tcal6416rtw-v2-3-6516d98a9836@phytec.de Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 4 ++-- drivers/gpio/gpio-pca953x.c | 6 ++++++ 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index fb6b479700d3..c33f9305ab97 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -1193,11 +1193,11 @@ config GPIO_PCA953X 8 bits: max7310, max7315, pca6107, pca9534, pca9538, pca9554, pca9556, pca9557, pca9574, tca6408, tca9554, xra1202, - pcal6408, pcal9554b, tca9538 + pcal6408, pcal9554b, tca9538, tcal6408 16 bits: max7312, max7313, pca9535, pca9539, pca9555, pca9575, tca6416, pca6416, pcal6416, pcal9535, pcal9555a, max7318, - tca9539 + tca9539, tcal6416 18 bits: tca6418 diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c index 0a3916cc2772..dd0e09961bc9 100644 --- a/drivers/gpio/gpio-pca953x.c +++ b/drivers/gpio/gpio-pca953x.c @@ -126,6 +126,9 @@ static const struct i2c_device_id pca953x_id[] = { { "tca9539", 16 | PCA953X_TYPE | PCA_INT, }, { "tca9554", 8 | PCA953X_TYPE | PCA_INT, }, { "xra1202", 8 | PCA953X_TYPE }, + + { "tcal6408", 8 | PCA953X_TYPE | PCA_LATCH_INT, }, + { "tcal6416", 16 | PCA953X_TYPE | PCA_LATCH_INT, }, { } }; MODULE_DEVICE_TABLE(i2c, pca953x_id); @@ -1444,6 +1447,9 @@ static const struct of_device_id pca953x_dt_ids[] = { { .compatible = "ti,tca9538", .data = OF_953X( 8, PCA_INT), }, { .compatible = "ti,tca9539", .data = OF_953X(16, PCA_INT), }, + { .compatible = "ti,tcal6408", .data = OF_953X( 8, PCA_LATCH_INT), }, + { .compatible = "ti,tcal6416", .data = OF_953X(16, PCA_LATCH_INT), }, + { .compatible = "onnn,cat9554", .data = OF_953X( 8, PCA_INT), }, { .compatible = "onnn,pca9654", .data = OF_953X( 8, PCA_INT), }, { .compatible = "onnn,pca9655", .data = OF_953X(16, PCA_INT), }, From 6774a66d0e103d0e3e4c0f37dbd61946ec83edf0 Mon Sep 17 00:00:00 2001 From: Bartosz Golaszewski Date: Mon, 15 Dec 2025 16:46:24 +0100 Subject: [PATCH 08/59] gpio: swnode: compare the "undefined" swnode by its address, not name We know the address of the underlying remote software node referenced by the GPIO property (if it is a software node). We don't need to compare its name, we can compare its address which is more precise anyway. Reviewed-by: Charles Keepax Tested-by: Charles Keepax Link: https://lore.kernel.org/r/20251215154624.67099-1-bartosz.golaszewski@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib-swnode.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/drivers/gpio/gpiolib-swnode.c b/drivers/gpio/gpiolib-swnode.c index b44f35d68459..54bad9e88fe5 100644 --- a/drivers/gpio/gpiolib-swnode.c +++ b/drivers/gpio/gpiolib-swnode.c @@ -18,19 +18,18 @@ #include #include +#include #include "gpiolib.h" #include "gpiolib-swnode.h" -#define GPIOLIB_SWNODE_UNDEFINED_NAME "swnode-gpio-undefined" - static struct gpio_device *swnode_get_gpio_device(struct fwnode_handle *fwnode) { const struct software_node *gdev_node; struct gpio_device *gdev; gdev_node = to_software_node(fwnode); - if (!gdev_node || !gdev_node->name) + if (!gdev_node) goto fwnode_lookup; /* @@ -38,7 +37,7 @@ static struct gpio_device *swnode_get_gpio_device(struct fwnode_handle *fwnode) * primarily used as a key for internal chip selects in SPI bindings. */ if (IS_ENABLED(CONFIG_GPIO_SWNODE_UNDEFINED) && - !strcmp(gdev_node->name, GPIOLIB_SWNODE_UNDEFINED_NAME)) + gdev_node == &swnode_gpio_undefined) return ERR_PTR(-ENOENT); fwnode_lookup: @@ -139,9 +138,7 @@ int swnode_gpio_count(const struct fwnode_handle *fwnode, const char *con_id) * A special node that identifies undefined GPIOs, this is primarily used as * a key for internal chip selects in SPI bindings. */ -const struct software_node swnode_gpio_undefined = { - .name = GPIOLIB_SWNODE_UNDEFINED_NAME, -}; +const struct software_node swnode_gpio_undefined = { }; EXPORT_SYMBOL_NS_GPL(swnode_gpio_undefined, "GPIO_SWNODE"); static int __init swnode_gpio_init(void) From f48b5e8bc2e1344f588cc730082aed6ccc5a6b3e Mon Sep 17 00:00:00 2001 From: Stafford Horne Date: Wed, 17 Dec 2025 08:08:27 +0000 Subject: [PATCH 09/59] dt-bindings: gpio-mmio: Add compatible string for opencores,gpio In FPGA Development boards with GPIOs we use the opencores gpio verilog rtl. This is compatible with the gpio-mmio. Add the compatible string to allow as below. Example: gpio0: gpio@91000000 { compatible = "opencores,gpio", "brcm,bcm6345-gpio"; reg = <0x91000000 0x1>, <0x91000001 0x1>; reg-names = "dat", "dirout"; gpio-controller; #gpio-cells = <2>; status = "okay"; }; Link: https://opencores.org/projects/gpio Signed-off-by: Stafford Horne Acked-by: Conor Dooley Link: https://lore.kernel.org/r/20251217080843.70621-2-shorne@gmail.com Signed-off-by: Bartosz Golaszewski --- .../devicetree/bindings/gpio/gpio-mmio.yaml | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml b/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml index b4d55bf6a285..6fcf5fd2cb66 100644 --- a/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml +++ b/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml @@ -18,11 +18,16 @@ description: properties: compatible: - enum: - - brcm,bcm6345-gpio - - ni,169445-nand-gpio - - wd,mbl-gpio # Western Digital MyBook Live memory-mapped GPIO controller - - intel,ixp4xx-expansion-bus-mmio-gpio + oneOf: + - enum: + - brcm,bcm6345-gpio + - ni,169445-nand-gpio + - wd,mbl-gpio # Western Digital MyBook Live memory-mapped GPIO controller + - intel,ixp4xx-expansion-bus-mmio-gpio + - items: + - enum: + - opencores,gpio + - const: brcm,bcm6345-gpio big-endian: true From 47d8cb678081d12704d52ed42b625e96f38470e0 Mon Sep 17 00:00:00 2001 From: Rosen Penev Date: Wed, 17 Dec 2025 12:23:31 -0800 Subject: [PATCH 10/59] gpio: realtek-otto: use larger type for dev_flags MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix a build failure on 64-bit systems uncovered by enabling COMPILE_TEST: drivers/gpio/gpio-realtek-otto.c: In function ‘realtek_gpio_probe’: drivers/gpio/gpio-realtek-otto.c:375:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast] 375 | dev_flags = (unsigned int) device_get_match_data(dev); | ^ Fixes: 3203d8f573af ("gpio: realtek-otto: add COMPILE_TEST") Reported-by: kernel test robot Closes: https://lore.kernel.org/oe-kbuild-all/202512180532.2ykNwYAm-lkp@intel.com/ Signed-off-by: Rosen Penev Link: https://lore.kernel.org/r/20251217202331.9449-1-rosenp@gmail.com [Bartosz: tweaked commit message, changed the cast, added tags] Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-realtek-otto.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/gpio/gpio-realtek-otto.c b/drivers/gpio/gpio-realtek-otto.c index de527f4fc6c2..4cf91528f547 100644 --- a/drivers/gpio/gpio-realtek-otto.c +++ b/drivers/gpio/gpio-realtek-otto.c @@ -359,8 +359,7 @@ static int realtek_gpio_probe(struct platform_device *pdev) { struct gpio_generic_chip_config config; struct device *dev = &pdev->dev; - unsigned long gen_gc_flags; - unsigned int dev_flags; + unsigned long gen_gc_flags, dev_flags; struct gpio_irq_chip *girq; struct realtek_gpio_ctrl *ctrl; struct resource *res; @@ -372,7 +371,7 @@ static int realtek_gpio_probe(struct platform_device *pdev) if (!ctrl) return -ENOMEM; - dev_flags = (unsigned int) device_get_match_data(dev); + dev_flags = (uintptr_t)device_get_match_data(dev); ngpios = REALTEK_GPIO_MAX; device_property_read_u32(dev, "ngpios", &ngpios); From cecf10b700e06a2f2e2b638b1f680e1ae7f343ac Mon Sep 17 00:00:00 2001 From: Krzysztof Kozlowski Date: Fri, 19 Dec 2025 13:13:12 +0100 Subject: [PATCH 11/59] gpio: aspeed: Simplify with device_get_match_data() Driver's probe function matches against driver's of_device_id table, where each entry has non-NULL match data, so of_match_node() can be simplified with device_get_match_data(). Signed-off-by: Krzysztof Kozlowski Link: https://lore.kernel.org/r/20251219-gpio-of-match-v3-1-6b84194a02a8@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/drivers/gpio/gpio-aspeed.c b/drivers/gpio/gpio-aspeed.c index cbdf781994dc..9115e56a1626 100644 --- a/drivers/gpio/gpio-aspeed.c +++ b/drivers/gpio/gpio-aspeed.c @@ -1302,7 +1302,6 @@ MODULE_DEVICE_TABLE(of, aspeed_gpio_of_table); static int aspeed_gpio_probe(struct platform_device *pdev) { - const struct of_device_id *gpio_id; struct gpio_irq_chip *girq; struct aspeed_gpio *gpio; int rc, irq, i, banks, err; @@ -1320,8 +1319,8 @@ static int aspeed_gpio_probe(struct platform_device *pdev) raw_spin_lock_init(&gpio->lock); - gpio_id = of_match_node(aspeed_gpio_of_table, pdev->dev.of_node); - if (!gpio_id) + gpio->config = device_get_match_data(&pdev->dev); + if (!gpio->config) return -EINVAL; gpio->clk = devm_clk_get_enabled(&pdev->dev, NULL); @@ -1331,8 +1330,6 @@ static int aspeed_gpio_probe(struct platform_device *pdev) gpio->clk = NULL; } - gpio->config = gpio_id->data; - if (!gpio->config->llops->reg_bit_set || !gpio->config->llops->reg_bit_get || !gpio->config->llops->reg_bank_get) return -EINVAL; From da7c18a457c7a32c4ed1e1e326837d9d7cb4483c Mon Sep 17 00:00:00 2001 From: Krzysztof Kozlowski Date: Fri, 19 Dec 2025 13:13:13 +0100 Subject: [PATCH 12/59] gpio: creg-snps: Simplify with device_get_match_data() Driver's probe function matches against driver's of_device_id table, where each entry has non-NULL match data, so of_match_node() can be simplified with device_get_match_data(). Signed-off-by: Krzysztof Kozlowski Link: https://lore.kernel.org/r/20251219-gpio-of-match-v3-2-6b84194a02a8@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-creg-snps.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/drivers/gpio/gpio-creg-snps.c b/drivers/gpio/gpio-creg-snps.c index f8ea961fa1de..157ab90f5ba8 100644 --- a/drivers/gpio/gpio-creg-snps.c +++ b/drivers/gpio/gpio-creg-snps.c @@ -134,7 +134,6 @@ static const struct of_device_id creg_gpio_ids[] = { static int creg_gpio_probe(struct platform_device *pdev) { - const struct of_device_id *match; struct device *dev = &pdev->dev; struct creg_gpio *hcg; u32 ngpios; @@ -148,8 +147,7 @@ static int creg_gpio_probe(struct platform_device *pdev) if (IS_ERR(hcg->regs)) return PTR_ERR(hcg->regs); - match = of_match_node(creg_gpio_ids, pdev->dev.of_node); - hcg->layout = match->data; + hcg->layout = device_get_match_data(dev); if (!hcg->layout) return -EINVAL; From 48befae0d6eee275c3e30d1cd45f39d6ba011e19 Mon Sep 17 00:00:00 2001 From: Krzysztof Kozlowski Date: Fri, 19 Dec 2025 13:13:14 +0100 Subject: [PATCH 13/59] gpio: zynq: Simplify with device_get_match_data() Driver's probe function matches against driver's of_device_id table, where each entry has non-NULL match data, so of_match_node() can be simplified with device_get_match_data(). While changing the error message, switch to dev_err_probe() so error path is a bit simpler. Signed-off-by: Krzysztof Kozlowski Link: https://lore.kernel.org/r/20251219-gpio-of-match-v3-3-6b84194a02a8@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-zynq.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c index 97780c57ab56..571e366624d2 100644 --- a/drivers/gpio/gpio-zynq.c +++ b/drivers/gpio/gpio-zynq.c @@ -903,18 +903,16 @@ static int zynq_gpio_probe(struct platform_device *pdev) struct zynq_gpio *gpio; struct gpio_chip *chip; struct gpio_irq_chip *girq; - const struct of_device_id *match; gpio = devm_kzalloc(&pdev->dev, sizeof(*gpio), GFP_KERNEL); if (!gpio) return -ENOMEM; - match = of_match_node(zynq_gpio_of_match, pdev->dev.of_node); - if (!match) { - dev_err(&pdev->dev, "of_match_node() failed\n"); - return -EINVAL; - } - gpio->p_data = match->data; + gpio->p_data = device_get_match_data(&pdev->dev); + if (!gpio->p_data) + return dev_err_probe(&pdev->dev, -EINVAL, + "device_get_match_data() failed\n"); + platform_set_drvdata(pdev, gpio); gpio->base_addr = devm_platform_ioremap_resource(pdev, 0); From 2a7618ba8698874e9871a8ec5453e0068e94d9e5 Mon Sep 17 00:00:00 2001 From: Jonas Jelonek Date: Sat, 27 Dec 2025 18:01:33 +0000 Subject: [PATCH 14/59] dt-bindings: gpio: add gpio-line-mux controller Add dt-schema for a gpio-line-mux controller which exposes virtual GPIOs for a shared GPIO controlled by a multiplexer, e.g. a gpio-mux. The gpio-line-mux controller is a gpio-controller, thus has mostly the same semantics. However, it requires a mux-control to be specified upon which it will operate. Signed-off-by: Jonas Jelonek Reviewed-by: Conor Dooley Reviewed-by: Linus Walleij Link: https://lore.kernel.org/r/20251227180134.1262138-2-jelonek.jonas@gmail.com Signed-off-by: Bartosz Golaszewski --- .../bindings/gpio/gpio-line-mux.yaml | 107 ++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 Documentation/devicetree/bindings/gpio/gpio-line-mux.yaml diff --git a/Documentation/devicetree/bindings/gpio/gpio-line-mux.yaml b/Documentation/devicetree/bindings/gpio/gpio-line-mux.yaml new file mode 100644 index 000000000000..f49c05249ca7 --- /dev/null +++ b/Documentation/devicetree/bindings/gpio/gpio-line-mux.yaml @@ -0,0 +1,107 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/gpio/gpio-line-mux.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: GPIO line mux + +maintainers: + - Jonas Jelonek + +description: | + A GPIO controller to provide virtual GPIOs for a 1-to-many input-only mapping + backed by a single shared GPIO and a multiplexer. A simple illustrated + example is: + + +----- A + IN / + <-----o------- B + / |\ + | | +----- C + | | \ + | | +--- D + | | + M1 M0 + + MUX CONTROL + + M1 M0 IN + 0 0 A + 0 1 B + 1 0 C + 1 1 D + + This can be used in case a real GPIO is connected to multiple inputs and + controlled by a multiplexer, and another subsystem/driver does not work + directly with the multiplexer subsystem. + +properties: + compatible: + const: gpio-line-mux + + gpio-controller: true + + "#gpio-cells": + const: 2 + + gpio-line-mux-states: + description: Mux states corresponding to the virtual GPIOs. + $ref: /schemas/types.yaml#/definitions/uint32-array + + gpio-line-names: true + + mux-controls: + maxItems: 1 + description: + Phandle to the multiplexer to control access to the GPIOs. + + ngpios: false + + muxed-gpios: + maxItems: 1 + description: + GPIO which is the '1' in 1-to-many and is shared by the virtual GPIOs + and controlled via the mux. + +required: + - compatible + - gpio-controller + - gpio-line-mux-states + - mux-controls + - muxed-gpios + +additionalProperties: false + +examples: + - | + #include + #include + + sfp_gpio_mux: mux-controller-1 { + compatible = "gpio-mux"; + mux-gpios = <&gpio0 0 GPIO_ACTIVE_HIGH>, + <&gpio0 1 GPIO_ACTIVE_HIGH>; + #mux-control-cells = <0>; + idle-state = ; + }; + + sfp1_gpio: sfp-gpio-1 { + compatible = "gpio-line-mux"; + gpio-controller; + #gpio-cells = <2>; + + mux-controls = <&sfp_gpio_mux>; + muxed-gpios = <&gpio0 2 GPIO_ACTIVE_HIGH>; + + gpio-line-mux-states = <0>, <1>, <3>; + }; + + sfp1: sfp-p1 { + compatible = "sff,sfp"; + + i2c-bus = <&sfp1_i2c>; + los-gpios = <&sfp1_gpio 0 GPIO_ACTIVE_HIGH>; + mod-def0-gpios = <&sfp1_gpio 1 GPIO_ACTIVE_LOW>; + tx-fault-gpios = <&sfp1_gpio 2 GPIO_ACTIVE_HIGH>; + }; From 2b03d9a40cd1fea42fd65d2b66df80edc0f374c8 Mon Sep 17 00:00:00 2001 From: Jonas Jelonek Date: Sat, 27 Dec 2025 18:01:34 +0000 Subject: [PATCH 15/59] gpio: add gpio-line-mux driver Add a new driver which provides a 1-to-many mapping for a single real GPIO using a multiplexer. Each virtual GPIO corresponds to a multiplexer state which, if set for the multiplexer, connects the real GPIO to the corresponding virtual GPIO. This can help in various usecases. One practical case is the special hardware design of the Realtek-based XS1930-10 switch from Zyxel. It features two SFP+ ports/cages whose signals are wired directly to the switch SoC. Although Realtek SoCs are short on GPIOs, there are usually enough the fit the SFP signals without any hacks. However, Zyxel did some weird design and connected RX_LOS, MOD_ABS and TX_FAULT of one SFP cage onto a single GPIO line controlled by a multiplexer (the same for the other SFP cage). The single multiplexer controls the lines for both SFP and depending on the state, the designated 'signal GPIO lines' are connected to one of the three SFP signals. Because the SFP core/driver doesn't support multiplexer but needs single GPIOs for each of the signals, this driver fills the gap between both. It registers a gpio_chip, provides multiple virtual GPIOs and sets the backing multiplexer accordingly. Due to several practical issues, this is input-only and doesn't support IRQs. Signed-off-by: Jonas Jelonek Reviewed-by: Thomas Richard Reviewed-by: Linus Walleij Link: https://lore.kernel.org/r/20251227180134.1262138-3-jelonek.jonas@gmail.com Signed-off-by: Bartosz Golaszewski --- MAINTAINERS | 6 ++ drivers/gpio/Kconfig | 9 +++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-line-mux.c | 126 +++++++++++++++++++++++++++++++++++ 4 files changed, 142 insertions(+) create mode 100644 drivers/gpio/gpio-line-mux.c diff --git a/MAINTAINERS b/MAINTAINERS index 5b11839cba9d..8056ef0ffbf0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -10774,6 +10774,12 @@ S: Maintained F: Documentation/devicetree/bindings/leds/irled/gpio-ir-tx.yaml F: drivers/media/rc/gpio-ir-tx.c +GPIO LINE MUX +M: Jonas Jelonek +S: Maintained +F: Documentation/devicetree/bindings/gpio/gpio-line-mux.yaml +F: drivers/gpio/gpio-line-mux.c + GPIO MOCKUP DRIVER M: Bamvor Jian Zhang L: linux-gpio@vger.kernel.org diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index c33f9305ab97..2efa58f10781 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -1994,6 +1994,15 @@ config GPIO_LATCH Say yes here to enable a driver for GPIO multiplexers based on latches connected to other GPIOs. +config GPIO_LINE_MUX + tristate "GPIO line mux driver" + depends on OF_GPIO + select MULTIPLEXER + help + Say Y here to support the GPIO line mux, which can provide virtual + GPIOs backed by a shared real GPIO and a multiplexer in a 1-to-many + fashion. + config GPIO_MOCKUP tristate "GPIO Testing Driver (DEPRECATED)" select IRQ_SIM diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index 2421a8fd3733..36fa7c52d240 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -90,6 +90,7 @@ obj-$(CONFIG_GPIO_IXP4XX) += gpio-ixp4xx.o obj-$(CONFIG_GPIO_JANZ_TTL) += gpio-janz-ttl.o obj-$(CONFIG_GPIO_KEMPLD) += gpio-kempld.o obj-$(CONFIG_GPIO_LATCH) += gpio-latch.o +obj-$(CONFIG_GPIO_LINE_MUX) += gpio-line-mux.o obj-$(CONFIG_GPIO_LJCA) += gpio-ljca.o obj-$(CONFIG_GPIO_LOGICVC) += gpio-logicvc.o obj-$(CONFIG_GPIO_LOONGSON1) += gpio-loongson1.o diff --git a/drivers/gpio/gpio-line-mux.c b/drivers/gpio/gpio-line-mux.c new file mode 100644 index 000000000000..a4f384306218 --- /dev/null +++ b/drivers/gpio/gpio-line-mux.c @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * GPIO line mux which acts as virtual gpiochip and provides a 1-to-many + * mapping between virtual GPIOs and a real GPIO + multiplexer. + * + * Copyright (c) 2025 Jonas Jelonek + */ + +#include +#include +#include +#include +#include +#include + +#define MUX_SELECT_DELAY_US 100 + +struct gpio_lmux { + struct gpio_chip gc; + struct mux_control *mux; + struct gpio_desc *muxed_gpio; + + u32 num_gpio_mux_states; + unsigned int gpio_mux_states[] __counted_by(num_gpio_mux_states); +}; + +static int gpio_lmux_gpio_get(struct gpio_chip *gc, unsigned int offset) +{ + struct gpio_lmux *glm = gpiochip_get_data(gc); + int ret; + + if (offset > gc->ngpio) + return -EINVAL; + + ret = mux_control_select_delay(glm->mux, glm->gpio_mux_states[offset], + MUX_SELECT_DELAY_US); + if (ret < 0) + return ret; + + ret = gpiod_get_raw_value_cansleep(glm->muxed_gpio); + mux_control_deselect(glm->mux); + return ret; +} + +static int gpio_lmux_gpio_set(struct gpio_chip *gc, unsigned int offset, + int value) +{ + return -EOPNOTSUPP; +} + +static int gpio_lmux_gpio_get_direction(struct gpio_chip *gc, + unsigned int offset) +{ + return GPIO_LINE_DIRECTION_IN; +} + +static int gpio_lmux_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct gpio_lmux *glm; + unsigned int ngpio; + size_t size; + int ret; + + ngpio = device_property_count_u32(dev, "gpio-line-mux-states"); + if (!ngpio) + return -EINVAL; + + size = struct_size(glm, gpio_mux_states, ngpio); + glm = devm_kzalloc(dev, size, GFP_KERNEL); + if (!glm) + return -ENOMEM; + + glm->gc.base = -1; + glm->gc.can_sleep = true; + glm->gc.fwnode = dev_fwnode(dev); + glm->gc.label = dev_name(dev); + glm->gc.ngpio = ngpio; + glm->gc.owner = THIS_MODULE; + glm->gc.parent = dev; + + glm->gc.get = gpio_lmux_gpio_get; + glm->gc.set = gpio_lmux_gpio_set; + glm->gc.get_direction = gpio_lmux_gpio_get_direction; + + glm->mux = devm_mux_control_get(dev, NULL); + if (IS_ERR(glm->mux)) + return dev_err_probe(dev, PTR_ERR(glm->mux), + "could not get mux controller\n"); + + glm->muxed_gpio = devm_gpiod_get(dev, "muxed", GPIOD_IN); + if (IS_ERR(glm->muxed_gpio)) + return dev_err_probe(dev, PTR_ERR(glm->muxed_gpio), + "could not get muxed-gpio\n"); + + glm->num_gpio_mux_states = ngpio; + ret = device_property_read_u32_array(dev, "gpio-line-mux-states", + &glm->gpio_mux_states[0], ngpio); + if (ret) + return dev_err_probe(dev, ret, "could not get mux states\n"); + + ret = devm_gpiochip_add_data(dev, &glm->gc, glm); + if (ret) + return dev_err_probe(dev, ret, "failed to add gpiochip\n"); + + return 0; +} + +static const struct of_device_id gpio_lmux_of_match[] = { + { .compatible = "gpio-line-mux" }, + { } +}; +MODULE_DEVICE_TABLE(of, gpio_lmux_of_match); + +static struct platform_driver gpio_lmux_driver = { + .driver = { + .name = "gpio-line-mux", + .of_match_table = gpio_lmux_of_match, + }, + .probe = gpio_lmux_probe, +}; +module_platform_driver(gpio_lmux_driver); + +MODULE_AUTHOR("Jonas Jelonek "); +MODULE_DESCRIPTION("GPIO line mux driver"); +MODULE_LICENSE("GPL"); From 9d8107579ce4f2369ea3f670585710c30b14a4b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20Draszik?= Date: Wed, 17 Dec 2025 11:45:06 +0000 Subject: [PATCH 16/59] gpio: max77759: drop use of irqd_get_trigger_type MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit irqd_get_trigger_type() is meant for cases where the driver needs to know the configured IRQ trigger type and e.g. wants to change its behaviour accordingly. Furthermore, platform support code, e.g. DT handling, will configure the hardware based on that, and drivers don't need to pass the trigger type into request_irq() and friends. Drop the use from this driver, as it doesn't need to know the trigger type. Signed-off-by: André Draszik Link: https://lore.kernel.org/r/20251217-max77759-gpio-irq-trigger-v1-1-5738953c1172@linaro.org Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-max77759.c | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/drivers/gpio/gpio-max77759.c b/drivers/gpio/gpio-max77759.c index 5e48eb03e7b3..3bf9f23d1532 100644 --- a/drivers/gpio/gpio-max77759.c +++ b/drivers/gpio/gpio-max77759.c @@ -435,8 +435,6 @@ static int max77759_gpio_probe(struct platform_device *pdev) int irq; struct gpio_irq_chip *girq; int ret; - unsigned long irq_flags; - struct irq_data *irqd; chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL); if (!chip) @@ -486,13 +484,9 @@ static int max77759_gpio_probe(struct platform_device *pdev) return dev_err_probe(&pdev->dev, ret, "Failed to add GPIO chip\n"); - irq_flags = IRQF_ONESHOT | IRQF_SHARED; - irqd = irq_get_irq_data(irq); - if (irqd) - irq_flags |= irqd_get_trigger_type(irqd); - ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, - max77759_gpio_irqhandler, irq_flags, + max77759_gpio_irqhandler, + IRQF_ONESHOT | IRQF_SHARED, dev_name(&pdev->dev), chip); if (ret < 0) return dev_err_probe(&pdev->dev, ret, From 98d78c06f54da101c1f2eb79af378cee9e07e102 Mon Sep 17 00:00:00 2001 From: Bartosz Golaszewski Date: Fri, 2 Jan 2026 10:33:49 +0100 Subject: [PATCH 17/59] gpio: swnode: restore the name of the undefined software node Commit 6774a66d0e10 ("gpio: swnode: compare the "undefined" swnode by its address, not name") switched to comparing the software nodes by address instead of names but it's still useful to keep the name of the node to expose the relevant information over sysfs. Restore the human-readable name. Suggested-by: Andy Shevchenko Closes: https://lore.kernel.org/all/aVFsjSIwrBw7tFLU@smile.fi.intel.com/ Reviewed-by: Andy Shevchenko Link: https://lore.kernel.org/r/20260102093349.17822-1-bartosz.golaszewski@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib-swnode.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/drivers/gpio/gpiolib-swnode.c b/drivers/gpio/gpiolib-swnode.c index 54bad9e88fe5..21478b45c127 100644 --- a/drivers/gpio/gpiolib-swnode.c +++ b/drivers/gpio/gpiolib-swnode.c @@ -138,7 +138,9 @@ int swnode_gpio_count(const struct fwnode_handle *fwnode, const char *con_id) * A special node that identifies undefined GPIOs, this is primarily used as * a key for internal chip selects in SPI bindings. */ -const struct software_node swnode_gpio_undefined = { }; +const struct software_node swnode_gpio_undefined = { + .name = "swnode-gpio-undefined", +}; EXPORT_SYMBOL_NS_GPL(swnode_gpio_undefined, "GPIO_SWNODE"); static int __init swnode_gpio_init(void) From 48033e4c677be4e3f131df454d44a5d1fb1b334f Mon Sep 17 00:00:00 2001 From: Yixun Lan Date: Tue, 6 Jan 2026 11:09:32 +0800 Subject: [PATCH 18/59] dt-bindings: gpio: spacemit: add compatible name for K3 SoC Add new compatible string for SpacemiT K3 SoC's GPIO controller. Acked-by: Krzysztof Kozlowski Signed-off-by: Yixun Lan Link: https://lore.kernel.org/r/20260106-02-k3-gpio-v3-1-4800c214810b@gentoo.org Signed-off-by: Bartosz Golaszewski --- Documentation/devicetree/bindings/gpio/spacemit,k1-gpio.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Documentation/devicetree/bindings/gpio/spacemit,k1-gpio.yaml b/Documentation/devicetree/bindings/gpio/spacemit,k1-gpio.yaml index 83e0b2d14c9f..24d22d95665f 100644 --- a/Documentation/devicetree/bindings/gpio/spacemit,k1-gpio.yaml +++ b/Documentation/devicetree/bindings/gpio/spacemit,k1-gpio.yaml @@ -19,7 +19,9 @@ properties: pattern: "^gpio@[0-9a-f]+$" compatible: - const: spacemit,k1-gpio + enum: + - spacemit,k1-gpio + - spacemit,k3-gpio reg: maxItems: 1 From da64eb51595bc6073b2fb69c2a3859bba93ed75a Mon Sep 17 00:00:00 2001 From: Yixun Lan Date: Tue, 6 Jan 2026 11:09:33 +0800 Subject: [PATCH 19/59] gpio: spacemit: Add GPIO support for K3 SoC SpacemiT K3 SoC has changed gpio register layout while comparing with previous generation, the register offset and bank offset need to be adjusted, introduce a compatible data to extend the driver to support this. Signed-off-by: Yixun Lan Link: https://lore.kernel.org/r/20260106-02-k3-gpio-v3-2-4800c214810b@gentoo.org Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-spacemit-k1.c | 163 +++++++++++++++++++++++--------- 1 file changed, 117 insertions(+), 46 deletions(-) diff --git a/drivers/gpio/gpio-spacemit-k1.c b/drivers/gpio/gpio-spacemit-k1.c index eb66a15c002f..8f570a1a4894 100644 --- a/drivers/gpio/gpio-spacemit-k1.c +++ b/drivers/gpio/gpio-spacemit-k1.c @@ -15,29 +15,37 @@ #include #include -/* register offset */ -#define SPACEMIT_GPLR 0x00 /* port level - R */ -#define SPACEMIT_GPDR 0x0c /* port direction - R/W */ -#define SPACEMIT_GPSR 0x18 /* port set - W */ -#define SPACEMIT_GPCR 0x24 /* port clear - W */ -#define SPACEMIT_GRER 0x30 /* port rising edge R/W */ -#define SPACEMIT_GFER 0x3c /* port falling edge R/W */ -#define SPACEMIT_GEDR 0x48 /* edge detect status - R/W1C */ -#define SPACEMIT_GSDR 0x54 /* (set) direction - W */ -#define SPACEMIT_GCDR 0x60 /* (clear) direction - W */ -#define SPACEMIT_GSRER 0x6c /* (set) rising edge detect enable - W */ -#define SPACEMIT_GCRER 0x78 /* (clear) rising edge detect enable - W */ -#define SPACEMIT_GSFER 0x84 /* (set) falling edge detect enable - W */ -#define SPACEMIT_GCFER 0x90 /* (clear) falling edge detect enable - W */ -#define SPACEMIT_GAPMASK 0x9c /* interrupt mask , 0 disable, 1 enable - R/W */ - #define SPACEMIT_NR_BANKS 4 #define SPACEMIT_NR_GPIOS_PER_BANK 32 #define to_spacemit_gpio_bank(x) container_of((x), struct spacemit_gpio_bank, gc) +#define to_spacemit_gpio_regs(gb) ((gb)->sg->data->offsets) + +enum spacemit_gpio_registers { + SPACEMIT_GPLR, /* port level - R */ + SPACEMIT_GPDR, /* port direction - R/W */ + SPACEMIT_GPSR, /* port set - W */ + SPACEMIT_GPCR, /* port clear - W */ + SPACEMIT_GRER, /* port rising edge R/W */ + SPACEMIT_GFER, /* port falling edge R/W */ + SPACEMIT_GEDR, /* edge detect status - R/W1C */ + SPACEMIT_GSDR, /* (set) direction - W */ + SPACEMIT_GCDR, /* (clear) direction - W */ + SPACEMIT_GSRER, /* (set) rising edge detect enable - W */ + SPACEMIT_GCRER, /* (clear) rising edge detect enable - W */ + SPACEMIT_GSFER, /* (set) falling edge detect enable - W */ + SPACEMIT_GCFER, /* (clear) falling edge detect enable - W */ + SPACEMIT_GAPMASK, /* interrupt mask , 0 disable, 1 enable - R/W */ + SPACEMIT_GCPMASK, /* interrupt mask for K3 */ +}; struct spacemit_gpio; +struct spacemit_gpio_data { + const unsigned int *offsets; + u32 bank_offsets[SPACEMIT_NR_BANKS]; +}; + struct spacemit_gpio_bank { struct gpio_generic_chip chip; struct spacemit_gpio *sg; @@ -49,9 +57,22 @@ struct spacemit_gpio_bank { struct spacemit_gpio { struct device *dev; + const struct spacemit_gpio_data *data; struct spacemit_gpio_bank sgb[SPACEMIT_NR_BANKS]; }; +static u32 spacemit_gpio_read(struct spacemit_gpio_bank *gb, + enum spacemit_gpio_registers reg) +{ + return readl(gb->base + to_spacemit_gpio_regs(gb)[reg]); +} + +static void spacemit_gpio_write(struct spacemit_gpio_bank *gb, + enum spacemit_gpio_registers reg, u32 val) +{ + writel(val, gb->base + to_spacemit_gpio_regs(gb)[reg]); +} + static u32 spacemit_gpio_bank_index(struct spacemit_gpio_bank *gb) { return (u32)(gb - gb->sg->sgb); @@ -63,10 +84,10 @@ static irqreturn_t spacemit_gpio_irq_handler(int irq, void *dev_id) unsigned long pending; u32 n, gedr; - gedr = readl(gb->base + SPACEMIT_GEDR); + gedr = spacemit_gpio_read(gb, SPACEMIT_GEDR); if (!gedr) return IRQ_NONE; - writel(gedr, gb->base + SPACEMIT_GEDR); + spacemit_gpio_write(gb, SPACEMIT_GEDR, gedr); pending = gedr & gb->irq_mask; if (!pending) @@ -82,7 +103,7 @@ static void spacemit_gpio_irq_ack(struct irq_data *d) { struct spacemit_gpio_bank *gb = irq_data_get_irq_chip_data(d); - writel(BIT(irqd_to_hwirq(d)), gb->base + SPACEMIT_GEDR); + spacemit_gpio_write(gb, SPACEMIT_GEDR, BIT(irqd_to_hwirq(d))); } static void spacemit_gpio_irq_mask(struct irq_data *d) @@ -91,13 +112,13 @@ static void spacemit_gpio_irq_mask(struct irq_data *d) u32 bit = BIT(irqd_to_hwirq(d)); gb->irq_mask &= ~bit; - writel(gb->irq_mask, gb->base + SPACEMIT_GAPMASK); + spacemit_gpio_write(gb, SPACEMIT_GAPMASK, gb->irq_mask); if (bit & gb->irq_rising_edge) - writel(bit, gb->base + SPACEMIT_GCRER); + spacemit_gpio_write(gb, SPACEMIT_GCRER, bit); if (bit & gb->irq_falling_edge) - writel(bit, gb->base + SPACEMIT_GCFER); + spacemit_gpio_write(gb, SPACEMIT_GCFER, bit); } static void spacemit_gpio_irq_unmask(struct irq_data *d) @@ -108,12 +129,12 @@ static void spacemit_gpio_irq_unmask(struct irq_data *d) gb->irq_mask |= bit; if (bit & gb->irq_rising_edge) - writel(bit, gb->base + SPACEMIT_GSRER); + spacemit_gpio_write(gb, SPACEMIT_GSRER, bit); if (bit & gb->irq_falling_edge) - writel(bit, gb->base + SPACEMIT_GSFER); + spacemit_gpio_write(gb, SPACEMIT_GSFER, bit); - writel(gb->irq_mask, gb->base + SPACEMIT_GAPMASK); + spacemit_gpio_write(gb, SPACEMIT_GAPMASK, gb->irq_mask); } static int spacemit_gpio_irq_set_type(struct irq_data *d, unsigned int type) @@ -123,18 +144,18 @@ static int spacemit_gpio_irq_set_type(struct irq_data *d, unsigned int type) if (type & IRQ_TYPE_EDGE_RISING) { gb->irq_rising_edge |= bit; - writel(bit, gb->base + SPACEMIT_GSRER); + spacemit_gpio_write(gb, SPACEMIT_GSRER, bit); } else { gb->irq_rising_edge &= ~bit; - writel(bit, gb->base + SPACEMIT_GCRER); + spacemit_gpio_write(gb, SPACEMIT_GCRER, bit); } if (type & IRQ_TYPE_EDGE_FALLING) { gb->irq_falling_edge |= bit; - writel(bit, gb->base + SPACEMIT_GSFER); + spacemit_gpio_write(gb, SPACEMIT_GSFER, bit); } else { gb->irq_falling_edge &= ~bit; - writel(bit, gb->base + SPACEMIT_GCFER); + spacemit_gpio_write(gb, SPACEMIT_GCFER, bit); } return 0; @@ -179,15 +200,16 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, struct device *dev = sg->dev; struct gpio_irq_chip *girq; void __iomem *dat, *set, *clr, *dirin, *dirout; - int ret, bank_base[] = { 0x0, 0x4, 0x8, 0x100 }; + int ret; - gb->base = regs + bank_base[index]; + gb->base = regs + sg->data->bank_offsets[index]; + gb->sg = sg; - dat = gb->base + SPACEMIT_GPLR; - set = gb->base + SPACEMIT_GPSR; - clr = gb->base + SPACEMIT_GPCR; - dirin = gb->base + SPACEMIT_GCDR; - dirout = gb->base + SPACEMIT_GSDR; + dat = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPLR]; + set = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPSR]; + clr = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPCR]; + dirin = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GCDR]; + dirout = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GSDR]; config = (struct gpio_generic_chip_config) { .dev = dev, @@ -206,8 +228,6 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, if (ret) return dev_err_probe(dev, ret, "failed to init gpio chip\n"); - gb->sg = sg; - gc->label = dev_name(dev); gc->request = gpiochip_generic_request; gc->free = gpiochip_generic_free; @@ -223,13 +243,13 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, gpio_irq_chip_set_chip(girq, &spacemit_gpio_chip); /* Disable Interrupt */ - writel(0, gb->base + SPACEMIT_GAPMASK); + spacemit_gpio_write(gb, SPACEMIT_GAPMASK, 0); /* Disable Edge Detection Settings */ - writel(0x0, gb->base + SPACEMIT_GRER); - writel(0x0, gb->base + SPACEMIT_GFER); + spacemit_gpio_write(gb, SPACEMIT_GRER, 0x0); + spacemit_gpio_write(gb, SPACEMIT_GFER, 0x0); /* Clear Interrupt */ - writel(0xffffffff, gb->base + SPACEMIT_GCRER); - writel(0xffffffff, gb->base + SPACEMIT_GCFER); + spacemit_gpio_write(gb, SPACEMIT_GCRER, 0xffffffff); + spacemit_gpio_write(gb, SPACEMIT_GCFER, 0xffffffff); ret = devm_request_threaded_irq(dev, irq, NULL, spacemit_gpio_irq_handler, @@ -260,6 +280,10 @@ static int spacemit_gpio_probe(struct platform_device *pdev) if (!sg) return -ENOMEM; + sg->data = of_device_get_match_data(dev); + if (!sg->data) + return dev_err_probe(dev, -EINVAL, "No available compatible data."); + regs = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(regs)) return PTR_ERR(regs); @@ -287,8 +311,55 @@ static int spacemit_gpio_probe(struct platform_device *pdev) return 0; } +static const unsigned int spacemit_gpio_k1_offsets[] = { + [SPACEMIT_GPLR] = 0x00, + [SPACEMIT_GPDR] = 0x0c, + [SPACEMIT_GPSR] = 0x18, + [SPACEMIT_GPCR] = 0x24, + [SPACEMIT_GRER] = 0x30, + [SPACEMIT_GFER] = 0x3c, + [SPACEMIT_GEDR] = 0x48, + [SPACEMIT_GSDR] = 0x54, + [SPACEMIT_GCDR] = 0x60, + [SPACEMIT_GSRER] = 0x6c, + [SPACEMIT_GCRER] = 0x78, + [SPACEMIT_GSFER] = 0x84, + [SPACEMIT_GCFER] = 0x90, + [SPACEMIT_GAPMASK] = 0x9c, + [SPACEMIT_GCPMASK] = 0xA8, +}; + +static const unsigned int spacemit_gpio_k3_offsets[] = { + [SPACEMIT_GPLR] = 0x0, + [SPACEMIT_GPDR] = 0x4, + [SPACEMIT_GPSR] = 0x8, + [SPACEMIT_GPCR] = 0xc, + [SPACEMIT_GRER] = 0x10, + [SPACEMIT_GFER] = 0x14, + [SPACEMIT_GEDR] = 0x18, + [SPACEMIT_GSDR] = 0x1c, + [SPACEMIT_GCDR] = 0x20, + [SPACEMIT_GSRER] = 0x24, + [SPACEMIT_GCRER] = 0x28, + [SPACEMIT_GSFER] = 0x2c, + [SPACEMIT_GCFER] = 0x30, + [SPACEMIT_GAPMASK] = 0x34, + [SPACEMIT_GCPMASK] = 0x38, +}; + +static const struct spacemit_gpio_data k1_gpio_data = { + .offsets = spacemit_gpio_k1_offsets, + .bank_offsets = { 0x0, 0x4, 0x8, 0x100 }, +}; + +static const struct spacemit_gpio_data k3_gpio_data = { + .offsets = spacemit_gpio_k3_offsets, + .bank_offsets = { 0x0, 0x40, 0x80, 0x100 }, +}; + static const struct of_device_id spacemit_gpio_dt_ids[] = { - { .compatible = "spacemit,k1-gpio" }, + { .compatible = "spacemit,k1-gpio", .data = &k1_gpio_data }, + { .compatible = "spacemit,k3-gpio", .data = &k3_gpio_data }, { /* sentinel */ } }; MODULE_DEVICE_TABLE(of, spacemit_gpio_dt_ids); @@ -296,12 +367,12 @@ MODULE_DEVICE_TABLE(of, spacemit_gpio_dt_ids); static struct platform_driver spacemit_gpio_driver = { .probe = spacemit_gpio_probe, .driver = { - .name = "k1-gpio", + .name = "spacemit-gpio", .of_match_table = spacemit_gpio_dt_ids, }, }; module_platform_driver(spacemit_gpio_driver); MODULE_AUTHOR("Yixun Lan "); -MODULE_DESCRIPTION("GPIO driver for SpacemiT K1 SoC"); +MODULE_DESCRIPTION("GPIO driver for SpacemiT K1/K3 SoC"); MODULE_LICENSE("GPL"); From 8ba379879aa3e8cef871fed4a509d4f0a6370e6c Mon Sep 17 00:00:00 2001 From: Ernest Van Hoecke Date: Wed, 7 Jan 2026 10:31:22 +0100 Subject: [PATCH 20/59] Documentation: gpio: pca953x: clarify interrupt source detection There are multiple design tradeoffs and considerations in how the PCA953x driver detects the source(s) of an interrupt. This driver supports PCAL variants with input latching, a feature that is constrained by the fact that the interrupt status and input port registers cannot be read atomically. These limits and the design decisions deserve an in-depth explanation. Update the documentation to clarify these hardware limits and describe how the driver determines pending interrupts, and how it makes use of the PCAL input latching. Signed-off-by: Ernest Van Hoecke Reviewed-by: Andy Shevchenko Link: https://lore.kernel.org/r/20260107093125.4053468-1-ernestvanhoecke@gmail.com Signed-off-by: Bartosz Golaszewski --- Documentation/driver-api/gpio/pca953x.rst | 75 +++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/Documentation/driver-api/gpio/pca953x.rst b/Documentation/driver-api/gpio/pca953x.rst index 53f25fa03072..fa4a57aa82a7 100644 --- a/Documentation/driver-api/gpio/pca953x.rst +++ b/Documentation/driver-api/gpio/pca953x.rst @@ -389,6 +389,13 @@ disabled. Currently the driver enables the latch for each line with interrupt enabled. +An interrupt status register records which pins triggered an interrupt. +However, the status register and the input port register must be read +separately; there is no atomic mechanism to read both simultaneously, so races +are possible. Refer to the chapter `Interrupt source detection`_ to understand +the implications of this and how the driver still makes use of the latching +feature. + 1. base offset 0x40, bank 2, bank offsets of 2^n - pcal6408 - pcal6416 @@ -523,6 +530,74 @@ bits drive strength Currently not supported by the driver. +Interrupt source detection +========================== + +When triggered by the GPIO expander's interrupt, the driver determines which +IRQs are pending by reading the input port register. + +To be able to filter on specific interrupt events for all compatible devices, +the driver keeps track of the previous input state of the lines, and emits an +IRQ only for the correct edge or level. This system works irrespective of the +number of enabled interrupts. Events will not be missed even if they occur +between the GPIO expander's interrupt and the actual I2C read. Edges could of +course be missed if the related signal level changes back to the value +previously saved by the driver before the I2C read. PCAL variants offer input +latching for that reason. + +PCAL input latching +------------------- + +The PCAL variants have an input latch and the driver enables this for all +interrupt-enabled lines. The interrupt is then only cleared when the input port +is read out. These variants provide an interrupt status register that records +which pins triggered an interrupt, but the status and input registers cannot be +read atomically. If another interrupt occurs on a different line after the +status register has been read but before the input port register is sampled, +that event will not be reflected in the earlier status snapshot, so relying +solely on the interrupt status register is insufficient. + +Thus, the PCAL variants also have to use the existing level-change logic. + +For short pulses, the first edge is captured when the input register is read, +but if the signal returns to its previous level before this read, the second +edge is not observed. As a result, successive pulses can produce identical +input values at read time and no level change is detected, causing interrupts +to be missed. Below timing diagram shows this situation where the top signal is +the input pin level and the bottom signal indicates the latched value:: + + ─────┐ ┌──*───────────────┐ ┌──*─────────────────┐ ┌──*─── + │ │ . │ │ . │ │ . + │ │ │ │ │ │ │ │ │ + └──*──┘ │ └──*──┘ │ └──*──┘ │ + Input │ │ │ │ │ │ + ▼ │ ▼ │ ▼ │ + IRQ │ IRQ │ IRQ │ + . . . + ─────┐ .┌──────────────┐ .┌────────────────┐ .┌── + │ │ │ │ │ │ + │ │ │ │ │ │ + └────────*┘ └────────*┘ └────────*┘ + Latched │ │ │ + ▼ ▼ ▼ + READ 0 READ 0 READ 0 + NO CHANGE NO CHANGE + +To deal with this, events indicated by the interrupt status register are merged +with events detected through the existing level-change logic. As a result: + +- short pulses, whose second edges are invisible, are detected via the + interrupt status register, and +- interrupts that occur between the status and input reads are still + caught by the generic level-change logic. + +Note that this is still best-effort: the status and input registers are read +separately, and short pulses on other lines may occur in between those reads. +Such pulses can still be latched as an interrupt without leaving an observable +level change at read time, and may not be attributable to a specific edge. This +does not reduce detection compared to the generic path, but reflects inherent +atomicity limitations. + Datasheets ========== From e034e058897a12bc856f8b22d1796964c742f732 Mon Sep 17 00:00:00 2001 From: Bartosz Golaszewski Date: Wed, 7 Jan 2026 09:58:33 +0100 Subject: [PATCH 21/59] gpio: line-mux: remove bits already handled by GPIO core GPIO core already handles checking the offset against the number of GPIOs as well as missing any of the GPIO chip callbacks. Remove the unnecessary bits. Also, the offset check was off-by-one as reported by Dan. Fixes: 2b03d9a40cd1 ("gpio: add gpio-line-mux driver") Reported-by: Dan Carpenter Closes: https://lore.kernel.org/all/aV4b6GAGz1zyf8Xy@stanley.mountain/ Tested-by: Jonas Jelonek Reviewed-by: Jonas Jelonek Link: https://lore.kernel.org/r/20260107085833.17338-1-bartosz.golaszewski@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-line-mux.c | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/drivers/gpio/gpio-line-mux.c b/drivers/gpio/gpio-line-mux.c index a4f384306218..62548fbd3ca0 100644 --- a/drivers/gpio/gpio-line-mux.c +++ b/drivers/gpio/gpio-line-mux.c @@ -29,9 +29,6 @@ static int gpio_lmux_gpio_get(struct gpio_chip *gc, unsigned int offset) struct gpio_lmux *glm = gpiochip_get_data(gc); int ret; - if (offset > gc->ngpio) - return -EINVAL; - ret = mux_control_select_delay(glm->mux, glm->gpio_mux_states[offset], MUX_SELECT_DELAY_US); if (ret < 0) @@ -42,12 +39,6 @@ static int gpio_lmux_gpio_get(struct gpio_chip *gc, unsigned int offset) return ret; } -static int gpio_lmux_gpio_set(struct gpio_chip *gc, unsigned int offset, - int value) -{ - return -EOPNOTSUPP; -} - static int gpio_lmux_gpio_get_direction(struct gpio_chip *gc, unsigned int offset) { @@ -80,7 +71,6 @@ static int gpio_lmux_probe(struct platform_device *pdev) glm->gc.parent = dev; glm->gc.get = gpio_lmux_gpio_get; - glm->gc.set = gpio_lmux_gpio_set; glm->gc.get_direction = gpio_lmux_gpio_get_direction; glm->mux = devm_mux_control_get(dev, NULL); From a88d9589125a4d2d1cc2e0e6ba794be30f4de44f Mon Sep 17 00:00:00 2001 From: Jose Javier Rodriguez Barbarin Date: Thu, 8 Jan 2026 14:48:43 +0100 Subject: [PATCH 22/59] gpio: menz127: drop unneeded MODULE_ALIAS Since commit 1f4ea4838b13 ("mcb: Add missing modpost build support") the MODULE_ALIAS() is redundant as the module alias is now automatically generated from the MODULE_DEVICE_TABLE(). Remove the explicit alias. No functional change intended. Reviewed-by: Jorge Sanjuan Garcia Signed-off-by: Jose Javier Rodriguez Barbarin Link: https://lore.kernel.org/r/20260108134843.25903-2-dev-josejavier.rodriguez@duagon.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-menz127.c | 1 - 1 file changed, 1 deletion(-) diff --git a/drivers/gpio/gpio-menz127.c b/drivers/gpio/gpio-menz127.c index 52b13c6ae496..f51e7517f551 100644 --- a/drivers/gpio/gpio-menz127.c +++ b/drivers/gpio/gpio-menz127.c @@ -223,5 +223,4 @@ module_mcb_driver(men_z127_driver); MODULE_AUTHOR("Andreas Werner "); MODULE_DESCRIPTION("MEN GPIO Controller"); MODULE_LICENSE("GPL v2"); -MODULE_ALIAS("mcb:16z127"); MODULE_IMPORT_NS("MCB"); From ea5b4c68e097412f2d3ca13314b672837718a446 Mon Sep 17 00:00:00 2001 From: Swark Yang Date: Fri, 9 Jan 2026 01:26:06 -0800 Subject: [PATCH 23/59] gpio: cadence: Add quirk for Axiado AX3000 platform On the Axiado AX3000 platform, pinmux and pin configuration (such as direction and output enable) are configured by the hardware/firmware at boot time before Linux boots. To prevent conflicts, introduce a platform-specific quirk triggered by the "axiado,ax3000-gpio" compatible string. When this quirk is active, the driver will skip its default initialization of pinmux configuration and direction settings during probe. Co-developed-by: Tzu-Hao Wei Signed-off-by: Tzu-Hao Wei Signed-off-by: Swark Yang Reviewed-by: Linus Walleij Link: https://lore.kernel.org/r/20260109-axiado-ax3000-cadence-gpio-support-v2-1-fc1e28edf68a@axiado.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-cadence.c | 56 +++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 11 deletions(-) diff --git a/drivers/gpio/gpio-cadence.c b/drivers/gpio/gpio-cadence.c index b75734ca22dd..85aef54d0aec 100644 --- a/drivers/gpio/gpio-cadence.c +++ b/drivers/gpio/gpio-cadence.c @@ -2,6 +2,7 @@ /* * Copyright 2017-2018 Cadence + * Copyright (C) 2025 Axiado Corporation. * * Authors: * Jan Kotas @@ -31,10 +32,23 @@ #define CDNS_GPIO_IRQ_VALUE 0x28 #define CDNS_GPIO_IRQ_ANY_EDGE 0x2c +struct cdns_gpio_quirks { + bool skip_init; +}; + struct cdns_gpio_chip { struct gpio_generic_chip gen_gc; void __iomem *regs; u32 bypass_orig; + const struct cdns_gpio_quirks *quirks; +}; + +static const struct cdns_gpio_quirks cdns_default_quirks = { + .skip_init = false, +}; + +static const struct cdns_gpio_quirks ax3000_gpio_quirks = { + .skip_init = true, }; static int cdns_gpio_request(struct gpio_chip *chip, unsigned int offset) @@ -141,6 +155,19 @@ static const struct irq_chip cdns_gpio_irqchip = { GPIOCHIP_IRQ_RESOURCE_HELPERS, }; +static const struct of_device_id cdns_of_ids[] = { + { + .compatible = "axiado,ax3000-gpio", + .data = &ax3000_gpio_quirks + }, + { + .compatible = "cdns,gpio-r1p02", + .data = &cdns_default_quirks + }, + { /* sentinel */ }, +}; +MODULE_DEVICE_TABLE(of, cdns_of_ids); + static int cdns_gpio_probe(struct platform_device *pdev) { struct gpio_generic_chip_config config = { }; @@ -165,6 +192,10 @@ static int cdns_gpio_probe(struct platform_device *pdev) return -EINVAL; } + cgpio->quirks = device_get_match_data(&pdev->dev); + if (!cgpio->quirks) + cgpio->quirks = &cdns_default_quirks; + /* * Set all pins as inputs by default, otherwise: * gpiochip_lock_as_irq: @@ -173,8 +204,15 @@ static int cdns_gpio_probe(struct platform_device *pdev) * so it needs to be changed before gpio_generic_chip_init() is called. */ dir_prev = ioread32(cgpio->regs + CDNS_GPIO_DIRECTION_MODE); - iowrite32(GENMASK(num_gpios - 1, 0), - cgpio->regs + CDNS_GPIO_DIRECTION_MODE); + + /* + * The AX3000 platform performs the required configuration at boot time + * before Linux boots, so this quirk disables pinmux initialization. + */ + if (!cgpio->quirks->skip_init) { + iowrite32(GENMASK(num_gpios - 1, 0), + cgpio->regs + CDNS_GPIO_DIRECTION_MODE); + } config.dev = &pdev->dev; config.sz = 4; @@ -240,9 +278,11 @@ static int cdns_gpio_probe(struct platform_device *pdev) /* * Enable gpio outputs, ignored for input direction */ - iowrite32(GENMASK(num_gpios - 1, 0), - cgpio->regs + CDNS_GPIO_OUTPUT_EN); - iowrite32(0, cgpio->regs + CDNS_GPIO_BYPASS_MODE); + if (!cgpio->quirks->skip_init) { + iowrite32(GENMASK(num_gpios - 1, 0), + cgpio->regs + CDNS_GPIO_OUTPUT_EN); + iowrite32(0, cgpio->regs + CDNS_GPIO_BYPASS_MODE); + } platform_set_drvdata(pdev, cgpio); return 0; @@ -260,12 +300,6 @@ static void cdns_gpio_remove(struct platform_device *pdev) iowrite32(cgpio->bypass_orig, cgpio->regs + CDNS_GPIO_BYPASS_MODE); } -static const struct of_device_id cdns_of_ids[] = { - { .compatible = "cdns,gpio-r1p02" }, - { /* sentinel */ }, -}; -MODULE_DEVICE_TABLE(of, cdns_of_ids); - static struct platform_driver cdns_gpio_driver = { .driver = { .name = "cdns-gpio", From 43f37d44f2b8a75a896e218bac1e43d75063f8d3 Mon Sep 17 00:00:00 2001 From: Tzu-Hao Wei Date: Fri, 9 Jan 2026 01:26:07 -0800 Subject: [PATCH 24/59] gpio: cadence: Add support for edge-triggered interrupts The Cadence GPIO controller (CDNS IP6508) supports edge-triggered interrupts (rising, falling, and both) via IRQ_TYPE, IRQ_VALUE, and IRQ_ANY_EDGE registers. This commit enables support for these modes in cdns_gpio_irq_set_type(). Although the interrupt status register is cleared on read and lacks per-pin acknowledgment, the driver already handles this safely by reading the ISR once and dispatching all pending interrupts immediately. This allows edge IRQs to be used reliably in controlled environments. Signed-off-by: Tzu-Hao Wei Reviewed-by: Linus Walleij Signed-off-by: Swark Yang Link: https://lore.kernel.org/r/20260109-axiado-ax3000-cadence-gpio-support-v2-2-fc1e28edf68a@axiado.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-cadence.c | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/drivers/gpio/gpio-cadence.c b/drivers/gpio/gpio-cadence.c index 85aef54d0aec..d7790fc35c22 100644 --- a/drivers/gpio/gpio-cadence.c +++ b/drivers/gpio/gpio-cadence.c @@ -98,6 +98,7 @@ static int cdns_gpio_irq_set_type(struct irq_data *d, unsigned int type) struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip); u32 int_value; u32 int_type; + u32 int_any; u32 mask = BIT(d->hwirq); int ret = 0; @@ -105,24 +106,35 @@ static int cdns_gpio_irq_set_type(struct irq_data *d, unsigned int type) int_value = ioread32(cgpio->regs + CDNS_GPIO_IRQ_VALUE) & ~mask; int_type = ioread32(cgpio->regs + CDNS_GPIO_IRQ_TYPE) & ~mask; - /* - * The GPIO controller doesn't have an ACK register. - * All interrupt statuses are cleared on a status register read. - * Don't support edge interrupts for now. + * Interrupt polarity and trigger behaviour is configured like this: + * + * (type, value) + * (0, 0) = Falling edge triggered + * (0, 1) = Rising edge triggered + * (1, 0) = Low level triggered + * (1, 1) = High level triggered */ + int_any = ioread32(cgpio->regs + CDNS_GPIO_IRQ_ANY_EDGE) & ~mask; if (type == IRQ_TYPE_LEVEL_HIGH) { int_type |= mask; int_value |= mask; } else if (type == IRQ_TYPE_LEVEL_LOW) { int_type |= mask; + } else if (type == IRQ_TYPE_EDGE_RISING) { + int_value |= mask; + } else if (type == IRQ_TYPE_EDGE_FALLING) { + /* edge trigger, int_value remains cleared for falling */ + } else if (type == IRQ_TYPE_EDGE_BOTH) { + int_any |= mask; } else { return -EINVAL; } iowrite32(int_value, cgpio->regs + CDNS_GPIO_IRQ_VALUE); iowrite32(int_type, cgpio->regs + CDNS_GPIO_IRQ_TYPE); + iowrite32(int_any, cgpio->regs + CDNS_GPIO_IRQ_ANY_EDGE); return ret; } From 568ea51e61f7da72ee290d24d6ee952586a3e168 Mon Sep 17 00:00:00 2001 From: Bartosz Golaszewski Date: Mon, 12 Jan 2026 10:36:51 +0100 Subject: [PATCH 25/59] gpio: shared: use device_is_compatible() for reset-gpio reset-gpio devices now can be identified with device_is_compatible() so use it instead of checking the device name string. Reviewed-by: Linus Walleij Link: https://lore.kernel.org/r/20260112093651.23639-1-bartosz.golaszewski@oss.qualcomm.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib-shared.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/drivers/gpio/gpiolib-shared.c b/drivers/gpio/gpiolib-shared.c index 17343fdc9758..fb8f779ed774 100644 --- a/drivers/gpio/gpiolib-shared.c +++ b/drivers/gpio/gpiolib-shared.c @@ -455,12 +455,7 @@ int gpio_shared_add_proxy_lookup(struct device *consumer, const char *con_id, list_for_each_entry(ref, &entry->refs, list) { guard(mutex)(&ref->lock); - /* - * FIXME: use device_is_compatible() once the reset-gpio - * drivers gains a compatible string which it currently - * does not have. - */ - if (!ref->fwnode && strstarts(dev_name(consumer), "reset.gpio.")) { + if (!ref->fwnode && device_is_compatible(consumer, "reset-gpio")) { if (!gpio_shared_dev_is_reset_gpio(consumer, entry, ref)) continue; } else if (!device_match_fwnode(consumer, ref->fwnode)) { From 4d08b3634fe824409e75696635fb27204b8d4720 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:17:17 +0200 Subject: [PATCH 26/59] dt-bindings: regulator: ROHM BD72720 The ROHM BD72720 is a new PMIC with 10 BUCk and 11 LDO regulators. The BD72720 is designed to support using the BUCK10 as a supply for the LDOs 1 to 4. When the BUCK10 is used for this, it can be set to a LDON_HEAD mode. In this mode, the BUCK10 voltage can't be controlled by software, but the voltage is adjusted by PMIC to match the LDO1 .. LDO4 voltages with a given offset. Offset can be 50mV .. 300mV and is changeable at 50mV steps. Add 'ldon-head-microvolt' property to denote a board which is designed to utilize the LDON_HEAD mode. All other properties are already existing. Add dt-binding doc for ROHM BD72720 regulators to make it usable. Signed-off-by: Matti Vaittinen Reviewed-by: Rob Herring (Arm) Link: https://patch.msgid.link/81cb38d0ae1b3fa426e40d5b0a93f69a0f374657.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- .../regulator/rohm,bd72720-regulator.yaml | 148 ++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 Documentation/devicetree/bindings/regulator/rohm,bd72720-regulator.yaml diff --git a/Documentation/devicetree/bindings/regulator/rohm,bd72720-regulator.yaml b/Documentation/devicetree/bindings/regulator/rohm,bd72720-regulator.yaml new file mode 100644 index 000000000000..5518082129bd --- /dev/null +++ b/Documentation/devicetree/bindings/regulator/rohm,bd72720-regulator.yaml @@ -0,0 +1,148 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/regulator/rohm,bd72720-regulator.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: ROHM BD72720 Power Management Integrated Circuit regulators + +maintainers: + - Matti Vaittinen + +description: | + This module is part of the ROHM BD72720 MFD device. For more details + see Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml. + + The regulator controller is represented as a sub-node of the PMIC node + on the device tree. + + Regulator nodes should be named to BUCK_ and LDO_. + The valid names for BD72720 regulator nodes are + buck1, buck2, buck3, buck4, buck5, buck6, buck7, buck8, buck9, buck10 + ldo1, ldo2, ldo3, ldo4, ldo5, ldo6, ldo7, ldo8, ldo9, ldo10, ldo11 + +patternProperties: + "^ldo([1-9]|1[0-1])$": + type: object + description: + Properties for single LDO regulator. + $ref: regulator.yaml# + + properties: + regulator-name: + pattern: "^ldo([1-9]|1[0-1])$" + + rohm,dvs-run-voltage: + description: + PMIC default "RUN" state voltage in uV. See below table for + LDOs which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-idle-voltage: + description: + PMIC default "IDLE" state voltage in uV. See below table for + LDOs which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-suspend-voltage: + description: + PMIC default "SUSPEND" state voltage in uV. See below table for + LDOs which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-lpsr-voltage: + description: + PMIC default "deep-idle" state voltage in uV. See below table for + LDOs which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + # Supported default DVS states: + # ldo | run | idle | suspend | lpsr + # -------------------------------------------------------------- + # 1, 2, 3, and 4 | supported | supported | supported | supported + # -------------------------------------------------------------- + # 5 - 11 | supported (*) + # -------------------------------------------------------------- + # + # (*) All states use same voltage but have own enable / disable + # settings. Voltage 0 can be specified for a state to make + # regulator disabled on that state. + + unevaluatedProperties: false + + "^buck([1-9]|10)$": + type: object + description: + Properties for single BUCK regulator. + $ref: regulator.yaml# + + properties: + regulator-name: + pattern: "^buck([1-9]|10)$" + + rohm,ldon-head-microvolt: + description: + Set this on boards where BUCK10 is used to supply LDOs 1-4. The bucki + voltage will be changed by the PMIC to follow the LDO output voltages + with the offset voltage given here. This will improve the LDO efficiency. + minimum: 50000 + maximum: 300000 + + rohm,dvs-run-voltage: + description: + PMIC default "RUN" state voltage in uV. See below table for + bucks which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-idle-voltage: + description: + PMIC default "IDLE" state voltage in uV. See below table for + bucks which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-suspend-voltage: + description: + PMIC default "SUSPEND" state voltage in uV. See below table for + bucks which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + rohm,dvs-lpsr-voltage: + description: + PMIC default "deep-idle" state voltage in uV. See below table for + bucks which support this. 0 means disabled. + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 0 + maximum: 3300000 + + # Supported default DVS states: + # buck | run | idle | suspend | lpsr + # -------------------------------------------------------------- + # 1, 2, 3, and 4 | supported | supported | supported | supported + # -------------------------------------------------------------- + # 5 - 10 | supported (*) + # -------------------------------------------------------------- + # + # (*) All states use same voltage but have own enable / disable + # settings. Voltage 0 can be specified for a state to make + # regulator disabled on that state. + + required: + - regulator-name + + unevaluatedProperties: false + +additionalProperties: false From dc74d1107f1506176c1f4f32dbef0417f3e678e1 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:17:38 +0200 Subject: [PATCH 27/59] dt-bindings: battery: Clarify trickle-charge The term 'trickle-charging' is used to describe a very slow charging phase, where electrons "trickle-in" the battery. There are two different use-cases for this type of charging. At least some Li-Ion batteries can benefit from very slow, constant current, pre-pre phase 'trickle-charging', if a battery is very empty. Some other batteries use top-off phase 'trickle-charging', which is different from the above case. The battery bindings use the term 'trickle-charge' without specifying which of the use-cases properties are addressing. This has already caused some confusion. Clarify that the 'trickle-charge-current-microamp' refers to the first one, the "pre-pre" -charging use-case. Suggested-by: Krzysztof Kozlowski Signed-off-by: Matti Vaittinen Reviewed-by: Krzysztof Kozlowski Reviewed-by: Linus Walleij Link: https://patch.msgid.link/e2794140343103245410c3301f8994e1babaeb96.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- .../devicetree/bindings/power/supply/battery.yaml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Documentation/devicetree/bindings/power/supply/battery.yaml b/Documentation/devicetree/bindings/power/supply/battery.yaml index 491488e7b970..bfb7b716ae13 100644 --- a/Documentation/devicetree/bindings/power/supply/battery.yaml +++ b/Documentation/devicetree/bindings/power/supply/battery.yaml @@ -64,7 +64,12 @@ properties: description: battery design capacity trickle-charge-current-microamp: - description: current for trickle-charge phase + description: current for trickle-charge phase. + Please note that the trickle-charging here, refers "wake-up" or + "pre-pre" -charging, for very empty batteries. Similar term is also + used for "maintenance" or "top-off" -charging of batteries (like + NiMh bq24400) - that is different and not controlled by this + property. precharge-current-microamp: description: current for pre-charge phase From a43309745a5ff3682f6a3d02459729824b5221e1 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:17:53 +0200 Subject: [PATCH 28/59] dt-bindings: battery: Add trickle-charge upper limit Some of the chargers for lithium-ion batteries use a trickle-charging as a first charging phase for very empty batteries, to "wake-up" the battery. Trickle-charging is a low current, constant current phase. After the voltage of the very empty battery has reached an upper limit for trickle charging, the pre-charge phase is started with a higher current. Allow defining the upper limit for trickle charging voltage, after which the charging should be changed to the pre-charging. Signed-off-by: Matti Vaittinen Reviewed-by: Linus Walleij Reviewed-by: Krzysztof Kozlowski Link: https://patch.msgid.link/9c3064ec7e32cda442336bf633fb93355ce6a97d.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- Documentation/devicetree/bindings/power/supply/battery.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Documentation/devicetree/bindings/power/supply/battery.yaml b/Documentation/devicetree/bindings/power/supply/battery.yaml index bfb7b716ae13..d1a2080557a0 100644 --- a/Documentation/devicetree/bindings/power/supply/battery.yaml +++ b/Documentation/devicetree/bindings/power/supply/battery.yaml @@ -71,6 +71,10 @@ properties: NiMh bq24400) - that is different and not controlled by this property. + tricklecharge-upper-limit-microvolt: + description: limit when to change to precharge from trickle charge + Trickle-charging here refers "wake-up" or "pre-pre" -charging. + precharge-current-microamp: description: current for pre-charge phase From 16056396b7709b0ee33d88329e9a41166bc8d6a0 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:18:11 +0200 Subject: [PATCH 29/59] dt-bindings: battery: Voltage drop properties ROHM has developed a so called "zero-correction" -algorithm to improve the fuel-gauging accuracy close to the point where battery is depleted. This relies on battery specific "VDR" (voltage drop rate) tables, which are measured from the battery, and which describe the voltage drop rate. More thorough explanation about the "zero correction" and "VDR" parameters is here: https://lore.kernel.org/all/676253b9-ff69-7891-1f26-a8b5bb5a421b@fi.rohmeurope.com/ Document the VDR zero-correction specific battery properties used by the BD71815, BD71828, BD72720 and some other ROHM chargers. (Note, charger drivers aren't upstream yet). Signed-off-by: Matti Vaittinen Reviewed-by: Rob Herring (Arm) Reviewed-by: Linus Walleij Link: https://patch.msgid.link/461f2840a03e0189ecd4f1a7c261014342ddee91.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- .../bindings/power/supply/battery.yaml | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/Documentation/devicetree/bindings/power/supply/battery.yaml b/Documentation/devicetree/bindings/power/supply/battery.yaml index d1a2080557a0..8ebf05d9497c 100644 --- a/Documentation/devicetree/bindings/power/supply/battery.yaml +++ b/Documentation/devicetree/bindings/power/supply/battery.yaml @@ -128,6 +128,21 @@ properties: - description: alert when battery temperature is lower than this value - description: alert when battery temperature is higher than this value + # The volt-drop* -properties describe voltage-drop for a battery, described + # as VDROP in: + # https://patentimages.storage.googleapis.com/6c/f5/17/c1d901c220f6a9/US20150032394A1.pdf + volt-drop-thresh-microvolt: + description: Threshold for starting the VDR correction + maximum: 48000000 + + volt-drop-soc-bp: + description: Table of capacity values matching the values in VDR tables. + The value should be given as basis points, 1/100 of a percent. + + volt-drop-temperatures-millicelsius: + description: An array containing the temperature in milli celsius, for each + of the VDR lookup table. + required: - compatible @@ -146,6 +161,13 @@ patternProperties: - description: battery capacity percent maximum: 100 + '^volt-drop-[0-9]-microvolt': + description: Table of the voltage drop rate (VDR) values. Each entry in the + table should match a capacity value in the volt-drop-soc table. + Furthermore, the values should be obtained for the temperature given in + volt-drop-temperatures-millicelsius table at index matching the + number in this table's name. + additionalProperties: false examples: From e816df1d3714d20c21a4fcdf3a5193ba12394642 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:18:27 +0200 Subject: [PATCH 30/59] dt-bindings: mfd: ROHM BD72720 The ROHM BD72720 is a power management IC integrating regulators, GPIOs, charger, LEDs, RTC and a clock gate. Add dt-binding doc for ROHM BD72720. Signed-off-by: Matti Vaittinen Reviewed-by: Krzysztof Kozlowski Reviewed-by: Linus Walleij Link: https://patch.msgid.link/44cd4fcb2834ed613dd2d958cf4a4a34b3a316ab.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- .../bindings/mfd/rohm,bd72720-pmic.yaml | 339 ++++++++++++++++++ 1 file changed, 339 insertions(+) create mode 100644 Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml diff --git a/Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml b/Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml new file mode 100644 index 000000000000..9f42097dfbac --- /dev/null +++ b/Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml @@ -0,0 +1,339 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/mfd/rohm,bd72720-pmic.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: ROHM BD72720 Power Management Integrated Circuit + +maintainers: + - Matti Vaittinen + +description: + BD72720 is a single-chip power management IC for battery-powered portable + devices. The BD72720 integrates 10 bucks and 11 LDOs, and a 3000 mA + switching charger. The IC also includes a Coulomb counter, a real-time + clock (RTC), GPIOs and a 32.768 kHz clock gate. + +# In addition to the properties found from the charger node, the ROHM BD72720 +# uses properties from a static battery node. Please see the: +# Documentation/devicetree/bindings/power/supply/battery.yaml +# +# Following properties are used +# when present: +# +# charge-full-design-microamp-hours: Battry capacity in mAh +# voltage-max-design-microvolt: Maximum voltage +# voltage-min-design-microvolt: Minimum voltage system is still operating. +# degrade-cycle-microamp-hours: Capacity lost due to aging at each full +# charge cycle. +# ocv-capacity-celsius: Array of OCV table temperatures. 1/table. +# ocv-capacity-table-: Table of OCV voltage/SOC pairs. Corresponds +# N.th temperature in ocv-capacity-celsius +# +# volt-drop-thresh-microvolt: Threshold for starting the VDR correction +# volt-drop-soc: Table of capacity values matching the +# values in VDR tables. +# +# volt-drop-temperatures-millicelsius: Temperatures corresponding to the volage +# drop values given in volt-drop-[0-9]-microvolt +# +# volt-drop-[0-9]-microvolt: VDR table for a temperature specified in +# volt-drop-temperatures-millicelsius +# +# VDR tables are (usually) determined for a specific battery by ROHM. +# The battery node would then be referred from the charger node: +# +# monitored-battery = <&battery>; + +properties: + compatible: + const: rohm,bd72720 + + reg: + description: + I2C slave address. + maxItems: 1 + + interrupts: + maxItems: 1 + + gpio-controller: true + + "#gpio-cells": + const: 2 + description: + The first cell is the pin number and the second cell is used to specify + flags. See the gpio binding document for more information. + + clocks: + maxItems: 1 + + "#clock-cells": + const: 0 + + clock-output-names: + const: bd71828-32k-out + + rohm,clkout-open-drain: + description: clk32kout mode. Set to 1 for "open-drain" or 0 for "cmos". + $ref: /schemas/types.yaml#/definitions/uint32 + maximum: 1 + + rohm,charger-sense-resistor-micro-ohms: + minimum: 10000 + maximum: 50000 + description: + BD72720 has a SAR ADC for measuring charging currents. External sense + resistor (RSENSE in data sheet) should be used. If some other but + 30 mOhm resistor is used the resistance value should be given here in + micro Ohms. + + regulators: + $ref: /schemas/regulator/rohm,bd72720-regulator.yaml + description: + List of child nodes that specify the regulators. + + leds: + $ref: /schemas/leds/rohm,bd71828-leds.yaml + + rohm,pin-fault_b: + $ref: /schemas/types.yaml#/definitions/string + description: + BD72720 has an OTP option to use fault_b-pin for different + purposes. Set this property accordingly. OTP options are + OTP0 - bi-directional FAULT_B or READY indicator depending on a + 'sub option' + OTP1 - GPO + OTP2 - Power sequencer output. + enum: + - faultb + - readyind + - gpo + - pwrseq + +patternProperties: + "^rohm,pin-dvs[0-1]$": + $ref: /schemas/types.yaml#/definitions/string + description: + BD72720 has 4 different OTP options to determine the use of dvs-pins. + OTP0 - regulator RUN state control. + OTP1 - GPI. + OTP2 - GPO. + OTP3 - Power sequencer output. + This property specifies the use of the pin. + enum: + - dvs-input + - gpi + - gpo + - pwrseq + + "^rohm,pin-exten[0-1]$": + $ref: /schemas/types.yaml#/definitions/string + description: BD72720 has an OTP option to use exten0-pin for different + purposes. Set this property accordingly. + OTP0 - GPO + OTP1 - Power sequencer output. + enum: + - gpo + - pwrseq + +required: + - compatible + - reg + - interrupts + - clocks + - "#clock-cells" + - regulators + - gpio-controller + - "#gpio-cells" + +additionalProperties: false + +examples: + - | + #include + #include + i2c { + #address-cells = <1>; + #size-cells = <0>; + pmic: pmic@4b { + compatible = "rohm,bd72720"; + reg = <0x4b>; + + interrupt-parent = <&gpio1>; + interrupts = <29 IRQ_TYPE_LEVEL_LOW>; + + clocks = <&osc 0>; + #clock-cells = <0>; + clock-output-names = "bd71828-32k-out"; + + gpio-controller; + #gpio-cells = <2>; + + rohm,pin-dvs0 = "gpi"; + rohm,pin-dvs1 = "gpi"; + rohm,pin-exten0 = "gpo"; + rohm,pin-exten1 = "gpo"; + rohm,pin-fault_b = "faultb"; + + rohm,charger-sense-resistor-micro-ohms = <10000>; + + regulators { + buck1 { + regulator-name = "buck1"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <2000000>; + regulator-ramp-delay = <2500>; + }; + buck2 { + regulator-name = "buck2"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <2000000>; + regulator-ramp-delay = <2500>; + }; + buck3 { + regulator-name = "buck3"; + regulator-min-microvolt = <1200000>; + regulator-max-microvolt = <2000000>; + }; + buck4 { + regulator-name = "buck4"; + regulator-min-microvolt = <1000000>; + regulator-max-microvolt = <1800000>; + }; + buck5 { + regulator-name = "buck5"; + regulator-min-microvolt = <2500000>; + regulator-max-microvolt = <3300000>; + }; + buck6 { + regulator-name = "buck6"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <2000000>; + regulator-ramp-delay = <2500>; + }; + buck7 { + regulator-name = "buck7"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <2000000>; + regulator-ramp-delay = <2500>; + }; + buck8 { + regulator-name = "buck8"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <1700000>; + regulator-ramp-delay = <2500>; + rohm,dvs-run-voltage = <1700000>; + rohm,dvs-idle-voltage = <1>; + rohm,dvs-suspend-voltage = <1>; + rohm,dvs-lpsr-voltage = <0>; + regulator-boot-on; + }; + buck9 { + regulator-name = "buck9"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <1700000>; + regulator-ramp-delay = <2500>; + rohm,dvs-run-voltage = <1700000>; + rohm,dvs-idle-voltage = <1>; + rohm,dvs-suspend-voltage = <1>; + rohm,dvs-lpsr-voltage = <0>; + regulator-boot-on; + }; + buck10 { + regulator-name = "buck10"; + regulator-min-microvolt = <500000>; + regulator-max-microvolt = <1700000>; + regulator-ramp-delay = <2500>; + rohm,dvs-run-voltage = <1700000>; + rohm,dvs-idle-voltage = <1>; + rohm,dvs-suspend-voltage = <1>; + rohm,dvs-lpsr-voltage = <0>; + regulator-boot-on; + }; + ldo1 { + regulator-name = "ldo1"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo2 { + regulator-name = "ldo2"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo3 { + regulator-name = "ldo3"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo4 { + regulator-name = "ldo4"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo5 { + regulator-name = "ldo5"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo6 { + regulator-name = "ldo6"; + regulator-min-microvolt = <1800000>; + regulator-max-microvolt = <1800000>; + }; + ldo7 { + regulator-name = "ldo7"; + regulator-min-microvolt = <800000>; + regulator-max-microvolt = <3300000>; + }; + ldo8 { + regulator-name = "ldo8"; + regulator-min-microvolt = <750000>; + regulator-max-microvolt = <3300000>; + rohm,dvs-suspend-voltage = <0>; + rohm,dvs-lpsr-voltage = <1>; + rohm,dvs-run-voltage = <750000>; + }; + ldo9 { + regulator-name = "ldo9"; + regulator-min-microvolt = <750000>; + regulator-max-microvolt = <3300000>; + rohm,dvs-suspend-voltage = <0>; + rohm,dvs-lpsr-voltage = <1>; + rohm,dvs-run-voltage = <750000>; + }; + ldo10 { + regulator-name = "ldo10"; + regulator-min-microvolt = <750000>; + regulator-max-microvolt = <3300000>; + rohm,dvs-suspend-voltage = <0>; + rohm,dvs-lpsr-voltage = <1>; + rohm,dvs-run-voltage = <750000>; + }; + ldo11 { + regulator-name = "ldo11"; + regulator-min-microvolt = <750000>; + regulator-max-microvolt = <3300000>; + rohm,dvs-suspend-voltage = <0>; + rohm,dvs-lpsr-voltage = <1>; + rohm,dvs-run-voltage = <750000>; + }; + }; + + leds { + compatible = "rohm,bd71828-leds"; + + led-1 { + rohm,led-compatible = "bd71828-grnled"; + function = LED_FUNCTION_INDICATOR; + color = ; + }; + led-2 { + rohm,led-compatible = "bd71828-ambled"; + function = LED_FUNCTION_CHARGING; + color = ; + }; + }; + }; + }; From 9144a761bf167d6e0ed827e5816e2ba68b2fc2f0 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:18:42 +0200 Subject: [PATCH 31/59] dt-bindings: leds: bd72720: Add BD72720 Add the ROHM BD72720 documentation to the binding documents. Signed-off-by: Matti Vaittinen Acked-by: Krzysztof Kozlowski Link: https://patch.msgid.link/b9854f77ee1dca8c99a9a9a198b79fbc76f8da67.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- .../devicetree/bindings/leds/rohm,bd71828-leds.yaml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Documentation/devicetree/bindings/leds/rohm,bd71828-leds.yaml b/Documentation/devicetree/bindings/leds/rohm,bd71828-leds.yaml index b7a3ef76cbf4..64cc40523e3d 100644 --- a/Documentation/devicetree/bindings/leds/rohm,bd71828-leds.yaml +++ b/Documentation/devicetree/bindings/leds/rohm,bd71828-leds.yaml @@ -10,11 +10,12 @@ maintainers: - Matti Vaittinen description: | - This module is part of the ROHM BD71828 MFD device. For more details - see Documentation/devicetree/bindings/mfd/rohm,bd71828-pmic.yaml. + This module is part of the ROHM BD71828 and BD72720 MFD device. For more + details see Documentation/devicetree/bindings/mfd/rohm,bd71828-pmic.yaml + and Documentation/devicetree/bindings/mfd/rohm,bd72720-pmic.yaml The LED controller is represented as a sub-node of the PMIC node on the device - tree. + tree. This should be located under "leds" - node in PMIC node. The device has two LED outputs referred as GRNLED and AMBLED in data-sheet. From 016e95b1473798f1e755a9e20f81391119ae7399 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:19:00 +0200 Subject: [PATCH 32/59] mfd: rohm-bd71828: Use regmap_reg_range() The regmap range tables tend to be somewhat verbose. Using the regmap_reg_range() can make the definitions slightly mode compact. Tidy the regmap range tables by using the regmap_reg_range(). Signed-off-by: Matti Vaittinen Link: https://patch.msgid.link/49607e65ca117b096a50c5784b760bf62553e29a.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/mfd/rohm-bd71828.c | 64 +++++++++++--------------------------- 1 file changed, 18 insertions(+), 46 deletions(-) diff --git a/drivers/mfd/rohm-bd71828.c b/drivers/mfd/rohm-bd71828.c index 84a64c3b9c9f..2a43005b67ee 100644 --- a/drivers/mfd/rohm-bd71828.c +++ b/drivers/mfd/rohm-bd71828.c @@ -157,55 +157,27 @@ static struct mfd_cell bd71828_mfd_cells[] = { }; static const struct regmap_range bd71815_volatile_ranges[] = { - { - .range_min = BD71815_REG_SEC, - .range_max = BD71815_REG_YEAR, - }, { - .range_min = BD71815_REG_CONF, - .range_max = BD71815_REG_BAT_TEMP, - }, { - .range_min = BD71815_REG_VM_IBAT_U, - .range_max = BD71815_REG_CC_CTRL, - }, { - .range_min = BD71815_REG_CC_STAT, - .range_max = BD71815_REG_CC_CURCD_L, - }, { - .range_min = BD71815_REG_VM_BTMP_MON, - .range_max = BD71815_REG_VM_BTMP_MON, - }, { - .range_min = BD71815_REG_INT_STAT, - .range_max = BD71815_REG_INT_UPDATE, - }, { - .range_min = BD71815_REG_VM_VSYS_U, - .range_max = BD71815_REG_REX_CTRL_1, - }, { - .range_min = BD71815_REG_FULL_CCNTD_3, - .range_max = BD71815_REG_CCNTD_CHG_2, - }, + regmap_reg_range(BD71815_REG_SEC, BD71815_REG_YEAR), + regmap_reg_range(BD71815_REG_CONF, BD71815_REG_BAT_TEMP), + regmap_reg_range(BD71815_REG_VM_IBAT_U, BD71815_REG_CC_CTRL), + regmap_reg_range(BD71815_REG_CC_STAT, BD71815_REG_CC_CURCD_L), + regmap_reg_range(BD71815_REG_VM_BTMP_MON, BD71815_REG_VM_BTMP_MON), + regmap_reg_range(BD71815_REG_INT_STAT, BD71815_REG_INT_UPDATE), + regmap_reg_range(BD71815_REG_VM_VSYS_U, BD71815_REG_REX_CTRL_1), + regmap_reg_range(BD71815_REG_FULL_CCNTD_3, BD71815_REG_CCNTD_CHG_2), }; static const struct regmap_range bd71828_volatile_ranges[] = { - { - .range_min = BD71828_REG_PS_CTRL_1, - .range_max = BD71828_REG_PS_CTRL_1, - }, { - .range_min = BD71828_REG_PS_CTRL_3, - .range_max = BD71828_REG_PS_CTRL_3, - }, { - .range_min = BD71828_REG_RTC_SEC, - .range_max = BD71828_REG_RTC_YEAR, - }, { - /* - * For now make all charger registers volatile because many - * needs to be and because the charger block is not that - * performance critical. - */ - .range_min = BD71828_REG_CHG_STATE, - .range_max = BD71828_REG_CHG_FULL, - }, { - .range_min = BD71828_REG_INT_MAIN, - .range_max = BD71828_REG_IO_STAT, - }, + regmap_reg_range(BD71828_REG_PS_CTRL_1, BD71828_REG_PS_CTRL_1), + regmap_reg_range(BD71828_REG_PS_CTRL_3, BD71828_REG_PS_CTRL_3), + regmap_reg_range(BD71828_REG_RTC_SEC, BD71828_REG_RTC_YEAR), + /* + * For now make all charger registers volatile because many + * needs to be and because the charger block is not that + * performance critical. + */ + regmap_reg_range(BD71828_REG_CHG_STATE, BD71828_REG_CHG_FULL), + regmap_reg_range(BD71828_REG_INT_MAIN, BD71828_REG_IO_STAT), }; static const struct regmap_access_table bd71815_volatile_regs = { From ea6806346080098b68674b933e76a76f0a49a79f Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:19:20 +0200 Subject: [PATCH 33/59] mfd: rohm-bd71828: Use standard file header format The MFD subsystem uses C-style comments also in the 'file header' section. Switch to this for the sake of the consistency. The header content is not changed. Suggested-by: Lee Jones Signed-off-by: Matti Vaittinen Link: https://patch.msgid.link/3cc6176eee16a7edc75c94d967a1de67be400e97.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/mfd/rohm-bd71828.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/drivers/mfd/rohm-bd71828.c b/drivers/mfd/rohm-bd71828.c index 2a43005b67ee..218945a8ec94 100644 --- a/drivers/mfd/rohm-bd71828.c +++ b/drivers/mfd/rohm-bd71828.c @@ -1,8 +1,9 @@ // SPDX-License-Identifier: GPL-2.0-only -// -// Copyright (C) 2019 ROHM Semiconductors -// -// ROHM BD71828/BD71815 PMIC driver +/* + * Copyright (C) 2019 ROHM Semiconductors + * + * ROHM BD71828/BD71815 PMIC driver + */ #include #include From af25277b1ddc6c65879247387d127c38c51ba9f0 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:19:35 +0200 Subject: [PATCH 34/59] mfd: rohm-bd71828: Support ROHM BD72720 The ROHM BD72720 is a power management IC which continues the BD71828 family of PMICs. Similarly to the BD71815 and BD71828, the BD72720 integrates regulators, charger, RTC, clock gate and GPIOs. The main difference to the earlier PMICs is that the BD72720 has two different I2C slave addresses. In addition to the registers behind the 'main I2C address', most of the charger (and to some extent LED) control is done via registers behind a 'secondary I2C slave address', 0x4c. Signed-off-by: Matti Vaittinen Link: https://patch.msgid.link/c7b3f1b25616a0add21cea38019e50a89873b6ac.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/mfd/Kconfig | 18 +- drivers/mfd/rohm-bd71828.c | 490 +++++++++++++++++++++++- include/linux/mfd/rohm-bd72720.h | 634 +++++++++++++++++++++++++++++++ include/linux/mfd/rohm-generic.h | 1 + 4 files changed, 1129 insertions(+), 14 deletions(-) create mode 100644 include/linux/mfd/rohm-bd72720.h diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index aace5766b38a..699f095f831e 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -2217,20 +2217,22 @@ config MFD_ROHM_BD718XX and emergency shut down as well as 32,768KHz clock output. config MFD_ROHM_BD71828 - tristate "ROHM BD71828 and BD71815 Power Management IC" + tristate "ROHM BD718[15/28/79], BD72720 and BD73900 PMICs" depends on I2C=y depends on OF select REGMAP_I2C select REGMAP_IRQ select MFD_CORE help - Select this option to get support for the ROHM BD71828 and BD71815 - Power Management ICs. BD71828GW and BD71815AGW are single-chip power - management ICs mainly for battery-powered portable devices. - The BD71828 integrates 7 buck converters and 7 LDOs. The BD71815 - has 5 bucks, 7 LDOs, and a boost for driving LEDs. Both ICs provide - also a single-cell linear charger, a Coulomb counter, a real-time - clock (RTC), GPIOs and a 32.768 kHz clock gate. + Select this option to get support for the ROHM BD71815, BD71828, + BD71879, BD72720 and BD73900 Power Management ICs (PMICs). These are + single-chip Power Management ICs (PMIC), mainly for battery-powered + portable devices. + The BD71815 has 5 bucks, 7 LDOs, and a boost for driving LEDs. + The BD718[28/79] have 7 buck converters and 7 LDOs. + The BD72720 and the BD73900 have 10 bucks and 11 LDOs. + All ICs provide a single-cell linear charger, a Coulomb counter, + a Real-Time Clock (RTC), GPIOs and a 32.768 kHz clock gate. config MFD_ROHM_BD957XMUF tristate "ROHM BD9576MUF and BD9573MUF Power Management ICs" diff --git a/drivers/mfd/rohm-bd71828.c b/drivers/mfd/rohm-bd71828.c index 218945a8ec94..e54152a03510 100644 --- a/drivers/mfd/rohm-bd71828.c +++ b/drivers/mfd/rohm-bd71828.c @@ -2,7 +2,7 @@ /* * Copyright (C) 2019 ROHM Semiconductors * - * ROHM BD71828/BD71815 PMIC driver + * ROHM BD718[15/28/79] and BD72720 PMIC driver */ #include @@ -14,12 +14,29 @@ #include #include #include +#include #include #include #include #include #include +#define BD72720_TYPED_IRQ_REG(_irq, _stat_offset, _mask, _type_offset) \ + [_irq] = { \ + .reg_offset = (_stat_offset), \ + .mask = (_mask), \ + { \ + .type_reg_offset = (_type_offset), \ + .type_reg_mask = BD72720_GPIO_IRQ_TYPE_MASK, \ + .type_rising_val = BD72720_GPIO_IRQ_TYPE_RISING, \ + .type_falling_val = BD72720_GPIO_IRQ_TYPE_FALLING, \ + .type_level_low_val = BD72720_GPIO_IRQ_TYPE_LOW, \ + .type_level_high_val = BD72720_GPIO_IRQ_TYPE_HIGH, \ + .types_supported = IRQ_TYPE_EDGE_BOTH | \ + IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW, \ + }, \ + } + static struct gpio_keys_button button = { .code = KEY_POWER, .gpio = -1, @@ -44,6 +61,12 @@ static const struct resource bd71828_rtc_irqs[] = { DEFINE_RES_IRQ_NAMED(BD71828_INT_RTC2, "bd70528-rtc-alm-2"), }; +static const struct resource bd72720_rtc_irqs[] = { + DEFINE_RES_IRQ_NAMED(BD72720_INT_RTC0, "bd70528-rtc-alm-0"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_RTC1, "bd70528-rtc-alm-1"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_RTC2, "bd70528-rtc-alm-2"), +}; + static const struct resource bd71815_power_irqs[] = { DEFINE_RES_IRQ_NAMED(BD71815_INT_DCIN_RMV, "bd71815-dcin-rmv"), DEFINE_RES_IRQ_NAMED(BD71815_INT_CLPS_OUT, "bd71815-dcin-clps-out"), @@ -157,6 +180,74 @@ static struct mfd_cell bd71828_mfd_cells[] = { }, }; +static const struct resource bd72720_power_irqs[] = { + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBUS_RMV, "bd72720_int_vbus_rmv"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBUS_DET, "bd72720_int_vbus_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBUS_MON_RES, "bd72720_int_vbus_mon_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBUS_MON_DET, "bd72720_int_vbus_mon_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_MON_RES, "bd72720_int_vsys_mon_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_MON_DET, "bd72720_int_vsys_mon_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_UV_RES, "bd72720_int_vsys_uv_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_UV_DET, "bd72720_int_vsys_uv_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_LO_RES, "bd72720_int_vsys_lo_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_LO_DET, "bd72720_int_vsys_lo_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_OV_RES, "bd72720_int_vsys_ov_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VSYS_OV_DET, "bd72720_int_vsys_ov_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_ILIM, "bd72720_int_bat_ilim"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CHG_DONE, "bd72720_int_chg_done"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_EXTEMP_TOUT, "bd72720_int_extemp_tout"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CHG_WDT_EXP, "bd72720_int_chg_wdt_exp"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_MNT_OUT, "bd72720_int_bat_mnt_out"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_MNT_IN, "bd72720_int_bat_mnt_in"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CHG_TRNS, "bd72720_int_chg_trns"), + + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_MON_RES, "bd72720_int_vbat_mon_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_MON_DET, "bd72720_int_vbat_mon_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_SHT_RES, "bd72720_int_vbat_sht_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_SHT_DET, "bd72720_int_vbat_sht_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_LO_RES, "bd72720_int_vbat_lo_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_LO_DET, "bd72720_int_vbat_lo_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_OV_RES, "bd72720_int_vbat_ov_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_VBAT_OV_DET, "bd72720_int_vbat_ov_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_RMV, "bd72720_int_bat_rmv"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_DET, "bd72720_int_bat_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_DBAT_DET, "bd72720_int_dbat_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_BAT_TEMP_TRNS, "bd72720_int_bat_temp_trns"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_LOBTMP_RES, "bd72720_int_lobtmp_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_LOBTMP_DET, "bd72720_int_lobtmp_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OVBTMP_RES, "bd72720_int_ovbtmp_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OVBTMP_DET, "bd72720_int_ovbtmp_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR1_RES, "bd72720_int_ocur1_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR1_DET, "bd72720_int_ocur1_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR2_RES, "bd72720_int_ocur2_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR2_DET, "bd72720_int_ocur2_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR3_RES, "bd72720_int_ocur3_res"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_OCUR3_DET, "bd72720_int_ocur3_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CC_MON1_DET, "bd72720_int_cc_mon1_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CC_MON2_DET, "bd72720_int_cc_mon2_det"), + DEFINE_RES_IRQ_NAMED(BD72720_INT_CC_MON3_DET, "bd72720_int_cc_mon3_det"), +}; + +static const struct mfd_cell bd72720_mfd_cells[] = { + { .name = "bd72720-pmic", }, + { .name = "bd72720-gpio", }, + { .name = "bd72720-led", }, + { .name = "bd72720-clk", }, + { + .name = "bd72720-power", + .resources = bd72720_power_irqs, + .num_resources = ARRAY_SIZE(bd72720_power_irqs), + }, { + .name = "bd72720-rtc", + .resources = bd72720_rtc_irqs, + .num_resources = ARRAY_SIZE(bd72720_rtc_irqs), + }, { + .name = "gpio-keys", + .platform_data = &bd71828_powerkey_data, + .pdata_size = sizeof(bd71828_powerkey_data), + }, +}; + static const struct regmap_range bd71815_volatile_ranges[] = { regmap_reg_range(BD71815_REG_SEC, BD71815_REG_YEAR), regmap_reg_range(BD71815_REG_CONF, BD71815_REG_BAT_TEMP), @@ -181,6 +272,91 @@ static const struct regmap_range bd71828_volatile_ranges[] = { regmap_reg_range(BD71828_REG_INT_MAIN, BD71828_REG_IO_STAT), }; +static const struct regmap_range bd72720_volatile_ranges_4b[] = { + regmap_reg_range(BD72720_REG_RESETSRC_1, BD72720_REG_RESETSRC_2), + regmap_reg_range(BD72720_REG_POWER_STATE, BD72720_REG_POWER_STATE), + /* The state indicator bit changes when new state is reached */ + regmap_reg_range(BD72720_REG_PS_CTRL_1, BD72720_REG_PS_CTRL_1), + regmap_reg_range(BD72720_REG_RCVNUM, BD72720_REG_RCVNUM), + regmap_reg_range(BD72720_REG_CONF, BD72720_REG_HALL_STAT), + regmap_reg_range(BD72720_REG_RTC_SEC, BD72720_REG_RTC_YEAR), + regmap_reg_range(BD72720_REG_INT_LVL1_STAT, BD72720_REG_INT_ETC2_SRC), +}; + +static const struct regmap_range bd72720_precious_ranges_4b[] = { + regmap_reg_range(BD72720_REG_INT_LVL1_STAT, BD72720_REG_INT_ETC2_STAT), +}; + +/* + * The BD72720 is an odd beast in that it contains two separate sets of + * registers, both starting from address 0x0. The twist is that these "pages" + * are behind different I2C slave addresses. Most of the registers are behind + * a slave address 0x4b, which will be used as the "main" address for this + * device. + * + * Most of the charger related registers are located behind slave address 0x4c. + * It is tempting to push the dealing with the charger registers and the extra + * 0x4c device in power-supply driver - but perhaps it's better for the sake of + * the cleaner re-use to deal with setting up all of the regmaps here. + * Furthermore, the LED stuff may need access to both of these devices. + * + * Instead of providing one of the regmaps to sub-devices in MFD platform data, + * we create one more 'wrapper regmap' with custom read/write operations. These + * custom accessors will select which of the 'real' regmaps to use, based on + * the register address. + * + * The register addresses are 8-bit, so we add offset 0x100 to the addresses + * behind the secondary slave 0x4c. The 'wrapper' regmap can then detect the + * correct slave address based on the register address and call regmap_write() + * and regmap_read() using correct 'real' regmap. This way the registers of + * both of the slaves can be accessed using one 'wrapper' regmap. + * + * NOTE: The added offsets mean that the defined addresses for slave 0x4c must + * be used through the 'wrapper' regmap because the offset must be stripped + * from the register addresses. The 0x4b can be accessed both indirectly using + * the 'wrapper' regmap, and directly using the 'real' regmap. + */ +#define BD72720_SECONDARY_I2C_SLAVE 0x4c +#define BD72720_SECONDARY_I2C_REG_OFFSET 0x100 + +struct bd72720_regmaps { + struct regmap *map1_4b; + struct regmap *map2_4c; +}; + +/* Translate the slave 0x4c wrapper register address to a real one */ +#define BD72720_REG_UNWRAP(reg) ((reg) - BD72720_SECONDARY_I2C_REG_OFFSET) + +/* Ranges given to 'real' 0x4c regmap must use unwrapped addresses. */ +#define BD72720_UNWRAP_REG_RANGE(startreg, endreg) \ + regmap_reg_range(BD72720_REG_UNWRAP(startreg), BD72720_REG_UNWRAP(endreg)) + +static const struct regmap_range bd72720_volatile_ranges_4c[] = { + /* Status information */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_CHG_STATE, BD72720_REG_CHG_EN), + /* + * Under certain circumstances, write to some bits may be + * ignored + */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_CHG_CTRL, BD72720_REG_CHG_CTRL), + /* + * TODO: Ensure this is used to advertise state, not (only?) to + * control it. + */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_VSYS_STATE_STAT, BD72720_REG_VSYS_STATE_STAT), + /* Measured data */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_VM_VBAT_U, BD72720_REG_VM_VF_L), + /* Self clearing bits */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_VM_VSYS_SA_MINMAX_CTRL, + BD72720_REG_VM_VSYS_SA_MINMAX_CTRL), + /* Counters, self clearing bits */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_CC_CURCD_U, BD72720_REG_CC_CTRL), + /* Self clearing bits */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_CC_CCNTD_CTRL, BD72720_REG_CC_CCNTD_CTRL), + /* Self clearing bits */ + BD72720_UNWRAP_REG_RANGE(BD72720_REG_IMPCHK_CTRL, BD72720_REG_IMPCHK_CTRL), +}; + static const struct regmap_access_table bd71815_volatile_regs = { .yes_ranges = &bd71815_volatile_ranges[0], .n_yes_ranges = ARRAY_SIZE(bd71815_volatile_ranges), @@ -191,6 +367,21 @@ static const struct regmap_access_table bd71828_volatile_regs = { .n_yes_ranges = ARRAY_SIZE(bd71828_volatile_ranges), }; +static const struct regmap_access_table bd72720_volatile_regs_4b = { + .yes_ranges = &bd72720_volatile_ranges_4b[0], + .n_yes_ranges = ARRAY_SIZE(bd72720_volatile_ranges_4b), +}; + +static const struct regmap_access_table bd72720_precious_regs_4b = { + .yes_ranges = &bd72720_precious_ranges_4b[0], + .n_yes_ranges = ARRAY_SIZE(bd72720_precious_ranges_4b), +}; + +static const struct regmap_access_table bd72720_volatile_regs_4c = { + .yes_ranges = &bd72720_volatile_ranges_4c[0], + .n_yes_ranges = ARRAY_SIZE(bd72720_volatile_ranges_4c), +}; + static const struct regmap_config bd71815_regmap = { .reg_bits = 8, .val_bits = 8, @@ -207,10 +398,79 @@ static const struct regmap_config bd71828_regmap = { .cache_type = REGCACHE_MAPLE, }; +static int regmap_write_wrapper(void *context, unsigned int reg, unsigned int val) +{ + struct bd72720_regmaps *maps = context; + + if (reg < BD72720_SECONDARY_I2C_REG_OFFSET) + return regmap_write(maps->map1_4b, reg, val); + + reg = BD72720_REG_UNWRAP(reg); + + return regmap_write(maps->map2_4c, reg, val); +} + +static int regmap_read_wrapper(void *context, unsigned int reg, unsigned int *val) +{ + struct bd72720_regmaps *maps = context; + + if (reg < BD72720_SECONDARY_I2C_REG_OFFSET) + return regmap_read(maps->map1_4b, reg, val); + + reg = BD72720_REG_UNWRAP(reg); + + return regmap_read(maps->map2_4c, reg, val); +} + +static const struct regmap_config bd72720_wrapper_map_config = { + .name = "wrap-map", + .reg_bits = 9, + .val_bits = 8, + .max_register = BD72720_REG_IMPCHK_CTRL, + /* + * We don't want to duplicate caches. It would be a bit faster to + * have the cache in this 'wrapper regmap', and not in the 'real + * regmaps' bd72720_regmap_4b and bd72720_regmap_4c below. This would + * require all the subdevices to use the wrapper-map in order to be + * able to benefit from the cache. + * Currently most of the sub-devices use only the same slave-address + * as this MFD driver. Now, because we don't add the offset to the + * registers belonging to this slave, those devices can use either the + * wrapper map, or the bd72720_regmap_4b directly. This means majority + * of our sub devices don't need to care which regmap they get using + * the dev_get_regmap(). This unifies the code between the BD72720 and + * those variants which don't have this 'multiple slave addresses' + * -hassle. + * So, for a small performance penalty, we simplify the code for the + * sub-devices by having the caches in the wrapped regmaps and not here. + */ + .cache_type = REGCACHE_NONE, + .reg_write = regmap_write_wrapper, + .reg_read = regmap_read_wrapper, +}; + +static const struct regmap_config bd72720_regmap_4b = { + .reg_bits = 8, + .val_bits = 8, + .volatile_table = &bd72720_volatile_regs_4b, + .precious_table = &bd72720_precious_regs_4b, + .max_register = BD72720_REG_INT_ETC2_SRC, + .cache_type = REGCACHE_MAPLE, +}; + +static const struct regmap_config bd72720_regmap_4c = { + .reg_bits = 8, + .val_bits = 8, + .volatile_table = &bd72720_volatile_regs_4c, + .max_register = BD72720_REG_UNWRAP(BD72720_REG_IMPCHK_CTRL), + .cache_type = REGCACHE_MAPLE, +}; + /* * Mapping of main IRQ register bits to sub-IRQ register offsets so that we can * access corect sub-IRQ registers based on bits that are set in main IRQ - * register. BD71815 and BD71828 have same sub-register-block offests. + * register. BD71815 and BD71828 have same sub-register-block offests, the + * BD72720 has a different one. */ static unsigned int bit0_offsets[] = {11}; /* RTC IRQ */ @@ -222,6 +482,15 @@ static unsigned int bit5_offsets[] = {3}; /* VSYS IRQ */ static unsigned int bit6_offsets[] = {1, 2}; /* DCIN IRQ */ static unsigned int bit7_offsets[] = {0}; /* BUCK IRQ */ +static unsigned int bd72720_bit0_offsets[] = {0, 1}; /* PS1 and PS2 */ +static unsigned int bd72720_bit1_offsets[] = {2, 3}; /* DVS1 and DVS2 */ +static unsigned int bd72720_bit2_offsets[] = {4}; /* VBUS */ +static unsigned int bd72720_bit3_offsets[] = {5}; /* VSYS */ +static unsigned int bd72720_bit4_offsets[] = {6}; /* CHG */ +static unsigned int bd72720_bit5_offsets[] = {7, 8}; /* BAT1 and BAT2 */ +static unsigned int bd72720_bit6_offsets[] = {9}; /* IBAT */ +static unsigned int bd72720_bit7_offsets[] = {10, 11}; /* ETC1 and ETC2 */ + static const struct regmap_irq_sub_irq_map bd718xx_sub_irq_offsets[] = { REGMAP_IRQ_MAIN_REG_OFFSET(bit0_offsets), REGMAP_IRQ_MAIN_REG_OFFSET(bit1_offsets), @@ -233,6 +502,17 @@ static const struct regmap_irq_sub_irq_map bd718xx_sub_irq_offsets[] = { REGMAP_IRQ_MAIN_REG_OFFSET(bit7_offsets), }; +static const struct regmap_irq_sub_irq_map bd72720_sub_irq_offsets[] = { + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit0_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit1_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit2_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit3_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit4_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit5_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit6_offsets), + REGMAP_IRQ_MAIN_REG_OFFSET(bd72720_bit7_offsets), +}; + static const struct regmap_irq bd71815_irqs[] = { REGMAP_IRQ_REG(BD71815_INT_BUCK1_OCP, 0, BD71815_INT_BUCK1_OCP_MASK), REGMAP_IRQ_REG(BD71815_INT_BUCK2_OCP, 0, BD71815_INT_BUCK2_OCP_MASK), @@ -406,6 +686,117 @@ static const struct regmap_irq bd71828_irqs[] = { REGMAP_IRQ_REG(BD71828_INT_RTC2, 11, BD71828_INT_RTC2_MASK), }; +static const struct regmap_irq bd72720_irqs[] = { + REGMAP_IRQ_REG(BD72720_INT_LONGPUSH, 0, BD72720_INT_LONGPUSH_MASK), + REGMAP_IRQ_REG(BD72720_INT_MIDPUSH, 0, BD72720_INT_MIDPUSH_MASK), + REGMAP_IRQ_REG(BD72720_INT_SHORTPUSH, 0, BD72720_INT_SHORTPUSH_MASK), + REGMAP_IRQ_REG(BD72720_INT_PUSH, 0, BD72720_INT_PUSH_MASK), + REGMAP_IRQ_REG(BD72720_INT_HALL_DET, 0, BD72720_INT_HALL_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_HALL_TGL, 0, BD72720_INT_HALL_TGL_MASK), + REGMAP_IRQ_REG(BD72720_INT_WDOG, 0, BD72720_INT_WDOG_MASK), + REGMAP_IRQ_REG(BD72720_INT_SWRESET, 0, BD72720_INT_SWRESET_MASK), + REGMAP_IRQ_REG(BD72720_INT_SEQ_DONE, 1, BD72720_INT_SEQ_DONE_MASK), + REGMAP_IRQ_REG(BD72720_INT_PGFAULT, 1, BD72720_INT_PGFAULT_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK1_DVS, 2, BD72720_INT_BUCK1_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK2_DVS, 2, BD72720_INT_BUCK2_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK3_DVS, 2, BD72720_INT_BUCK3_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK4_DVS, 2, BD72720_INT_BUCK4_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK5_DVS, 2, BD72720_INT_BUCK5_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK6_DVS, 2, BD72720_INT_BUCK6_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK7_DVS, 2, BD72720_INT_BUCK7_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK8_DVS, 2, BD72720_INT_BUCK8_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK9_DVS, 3, BD72720_INT_BUCK9_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_BUCK10_DVS, 3, BD72720_INT_BUCK10_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_LDO1_DVS, 3, BD72720_INT_LDO1_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_LDO2_DVS, 3, BD72720_INT_LDO2_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_LDO3_DVS, 3, BD72720_INT_LDO3_DVS_MASK), + REGMAP_IRQ_REG(BD72720_INT_LDO4_DVS, 3, BD72720_INT_LDO4_DVS_MASK), + + REGMAP_IRQ_REG(BD72720_INT_VBUS_RMV, 4, BD72720_INT_VBUS_RMV_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBUS_DET, 4, BD72720_INT_VBUS_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBUS_MON_RES, 4, BD72720_INT_VBUS_MON_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBUS_MON_DET, 4, BD72720_INT_VBUS_MON_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_MON_RES, 5, BD72720_INT_VSYS_MON_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_MON_DET, 5, BD72720_INT_VSYS_MON_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_UV_RES, 5, BD72720_INT_VSYS_UV_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_UV_DET, 5, BD72720_INT_VSYS_UV_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_LO_RES, 5, BD72720_INT_VSYS_LO_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_LO_DET, 5, BD72720_INT_VSYS_LO_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_OV_RES, 5, BD72720_INT_VSYS_OV_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VSYS_OV_DET, 5, BD72720_INT_VSYS_OV_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_ILIM, 6, BD72720_INT_BAT_ILIM_MASK), + REGMAP_IRQ_REG(BD72720_INT_CHG_DONE, 6, BD72720_INT_CHG_DONE_MASK), + REGMAP_IRQ_REG(BD72720_INT_EXTEMP_TOUT, 6, BD72720_INT_EXTEMP_TOUT_MASK), + REGMAP_IRQ_REG(BD72720_INT_CHG_WDT_EXP, 6, BD72720_INT_CHG_WDT_EXP_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_MNT_OUT, 6, BD72720_INT_BAT_MNT_OUT_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_MNT_IN, 6, BD72720_INT_BAT_MNT_IN_MASK), + REGMAP_IRQ_REG(BD72720_INT_CHG_TRNS, 6, BD72720_INT_CHG_TRNS_MASK), + + REGMAP_IRQ_REG(BD72720_INT_VBAT_MON_RES, 7, BD72720_INT_VBAT_MON_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_MON_DET, 7, BD72720_INT_VBAT_MON_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_SHT_RES, 7, BD72720_INT_VBAT_SHT_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_SHT_DET, 7, BD72720_INT_VBAT_SHT_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_LO_RES, 7, BD72720_INT_VBAT_LO_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_LO_DET, 7, BD72720_INT_VBAT_LO_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_OV_RES, 7, BD72720_INT_VBAT_OV_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VBAT_OV_DET, 7, BD72720_INT_VBAT_OV_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_RMV, 8, BD72720_INT_BAT_RMV_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_DET, 8, BD72720_INT_BAT_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_DBAT_DET, 8, BD72720_INT_DBAT_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_BAT_TEMP_TRNS, 8, BD72720_INT_BAT_TEMP_TRNS_MASK), + REGMAP_IRQ_REG(BD72720_INT_LOBTMP_RES, 8, BD72720_INT_LOBTMP_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_LOBTMP_DET, 8, BD72720_INT_LOBTMP_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_OVBTMP_RES, 8, BD72720_INT_OVBTMP_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_OVBTMP_DET, 8, BD72720_INT_OVBTMP_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR1_RES, 9, BD72720_INT_OCUR1_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR1_DET, 9, BD72720_INT_OCUR1_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR2_RES, 9, BD72720_INT_OCUR2_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR2_DET, 9, BD72720_INT_OCUR2_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR3_RES, 9, BD72720_INT_OCUR3_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_OCUR3_DET, 9, BD72720_INT_OCUR3_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_CC_MON1_DET, 10, BD72720_INT_CC_MON1_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_CC_MON2_DET, 10, BD72720_INT_CC_MON2_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_CC_MON3_DET, 10, BD72720_INT_CC_MON3_DET_MASK), +/* + * The GPIO1_IN and GPIO2_IN IRQs are generated from the PMIC's GPIO1 and GPIO2 + * pins. Eg, they may be wired to other devices which can then use the PMIC as + * an interrupt controller. The GPIO1 and GPIO2 can have the IRQ type + * specified. All of the types (falling, rising, and both edges as well as low + * and high levels) are supported. + */ + BD72720_TYPED_IRQ_REG(BD72720_INT_GPIO1_IN, 10, BD72720_INT_GPIO1_IN_MASK, 0), + BD72720_TYPED_IRQ_REG(BD72720_INT_GPIO2_IN, 10, BD72720_INT_GPIO2_IN_MASK, 1), + REGMAP_IRQ_REG(BD72720_INT_VF125_RES, 11, BD72720_INT_VF125_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VF125_DET, 11, BD72720_INT_VF125_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_VF_RES, 11, BD72720_INT_VF_RES_MASK), + REGMAP_IRQ_REG(BD72720_INT_VF_DET, 11, BD72720_INT_VF_DET_MASK), + REGMAP_IRQ_REG(BD72720_INT_RTC0, 11, BD72720_INT_RTC0_MASK), + REGMAP_IRQ_REG(BD72720_INT_RTC1, 11, BD72720_INT_RTC1_MASK), + REGMAP_IRQ_REG(BD72720_INT_RTC2, 11, BD72720_INT_RTC2_MASK), +}; + +static int bd72720_set_type_config(unsigned int **buf, unsigned int type, + const struct regmap_irq *irq_data, + int idx, void *irq_drv_data) +{ + const struct regmap_irq_type *t = &irq_data->type; + + /* + * The regmap IRQ ecpects IRQ_TYPE_EDGE_BOTH to be written to register + * as logical OR of the type_falling_val and type_rising_val. This is + * not how the BD72720 implements this configuration, hence we need + * to handle this specific case separately. + */ + if (type == IRQ_TYPE_EDGE_BOTH) { + buf[0][idx] &= ~t->type_reg_mask; + buf[0][idx] |= BD72720_GPIO_IRQ_TYPE_BOTH; + + return 0; + } + + return regmap_irq_set_type_config_simple(buf, type, irq_data, idx, irq_drv_data); +} + static const struct regmap_irq_chip bd71828_irq_chip = { .name = "bd71828_irq", .main_status = BD71828_REG_INT_MAIN, @@ -438,6 +829,28 @@ static const struct regmap_irq_chip bd71815_irq_chip = { .irq_reg_stride = 1, }; +static const unsigned int bd72720_irq_type_base[] = { BD72720_REG_GPIO1_CTRL }; + +static const struct regmap_irq_chip bd72720_irq_chip = { + .name = "bd72720_irq", + .main_status = BD72720_REG_INT_LVL1_STAT, + .irqs = &bd72720_irqs[0], + .num_irqs = ARRAY_SIZE(bd72720_irqs), + .status_base = BD72720_REG_INT_PS1_STAT, + .unmask_base = BD72720_REG_INT_PS1_EN, + .config_base = &bd72720_irq_type_base[0], + .num_config_bases = 1, + .num_config_regs = 2, + .set_type_config = bd72720_set_type_config, + .ack_base = BD72720_REG_INT_PS1_STAT, + .init_ack_masked = true, + .num_regs = 12, + .num_main_regs = 1, + .sub_reg_offsets = &bd72720_sub_irq_offsets[0], + .num_main_status_bits = 8, + .irq_reg_stride = 1, +}; + static int set_clk_mode(struct device *dev, struct regmap *regmap, int clkmode_reg) { @@ -484,11 +897,39 @@ static void bd71828_remove_poweroff(void *data) pm_power_off = NULL; } +static struct regmap *bd72720_do_regmaps(struct i2c_client *i2c) +{ + struct bd72720_regmaps *maps; + struct i2c_client *secondary_i2c; + + secondary_i2c = devm_i2c_new_dummy_device(&i2c->dev, i2c->adapter, + BD72720_SECONDARY_I2C_SLAVE); + if (IS_ERR(secondary_i2c)) { + dev_err_probe(&i2c->dev, PTR_ERR(secondary_i2c), "Failed to get secondary I2C\n"); + + return ERR_CAST(secondary_i2c); + } + + maps = devm_kzalloc(&i2c->dev, sizeof(*maps), GFP_KERNEL); + if (!maps) + return ERR_PTR(-ENOMEM); + + maps->map1_4b = devm_regmap_init_i2c(i2c, &bd72720_regmap_4b); + if (IS_ERR(maps->map1_4b)) + return maps->map1_4b; + + maps->map2_4c = devm_regmap_init_i2c(secondary_i2c, &bd72720_regmap_4c); + if (IS_ERR(maps->map2_4c)) + return maps->map2_4c; + + return devm_regmap_init(&i2c->dev, NULL, maps, &bd72720_wrapper_map_config); +} + static int bd71828_i2c_probe(struct i2c_client *i2c) { struct regmap_irq_chip_data *irq_data; int ret; - struct regmap *regmap; + struct regmap *regmap = NULL; const struct regmap_config *regmap_config; const struct regmap_irq_chip *irqchip; unsigned int chip_type; @@ -496,6 +937,7 @@ static int bd71828_i2c_probe(struct i2c_client *i2c) int cells; int button_irq; int clkmode_reg; + int main_lvl_mask_reg = 0, main_lvl_val = 0; if (!i2c->irq) { dev_err(&i2c->dev, "No IRQ configured\n"); @@ -527,15 +969,34 @@ static int bd71828_i2c_probe(struct i2c_client *i2c) */ button_irq = 0; break; + case ROHM_CHIP_TYPE_BD72720: + { + mfd = bd72720_mfd_cells; + cells = ARRAY_SIZE(bd72720_mfd_cells); + + regmap = bd72720_do_regmaps(i2c); + if (IS_ERR(regmap)) + return dev_err_probe(&i2c->dev, PTR_ERR(regmap), + "Failed to initialize Regmap\n"); + + irqchip = &bd72720_irq_chip; + clkmode_reg = BD72720_REG_OUT32K; + button_irq = BD72720_INT_SHORTPUSH; + main_lvl_mask_reg = BD72720_REG_INT_LVL1_EN; + main_lvl_val = BD72720_MASK_LVL1_EN_ALL; + break; + } default: dev_err(&i2c->dev, "Unknown device type"); return -EINVAL; } - regmap = devm_regmap_init_i2c(i2c, regmap_config); - if (IS_ERR(regmap)) - return dev_err_probe(&i2c->dev, PTR_ERR(regmap), + if (!regmap) { + regmap = devm_regmap_init_i2c(i2c, regmap_config); + if (IS_ERR(regmap)) + return dev_err_probe(&i2c->dev, PTR_ERR(regmap), "Failed to initialize Regmap\n"); + } ret = devm_regmap_add_irq_chip(&i2c->dev, regmap, i2c->irq, IRQF_ONESHOT, 0, irqchip, &irq_data); @@ -546,6 +1007,20 @@ static int bd71828_i2c_probe(struct i2c_client *i2c) dev_dbg(&i2c->dev, "Registered %d IRQs for chip\n", irqchip->num_irqs); + /* + * On some ICs the main IRQ register has corresponding mask register. + * This is not handled by the regmap IRQ. Let's enable all the main + * level IRQs here. Further writes to the main level MASK is not + * needed because masking is handled by the per IRQ 2.nd level MASK + * registers. 2.nd level masks are handled by the regmap IRQ. + */ + if (main_lvl_mask_reg) { + ret = regmap_write(regmap, main_lvl_mask_reg, main_lvl_val); + if (ret) { + return dev_err_probe(&i2c->dev, ret, + "Failed to enable main level IRQs\n"); + } + } if (button_irq) { ret = regmap_irq_get_virq(irq_data, button_irq); if (ret < 0) @@ -587,6 +1062,9 @@ static const struct of_device_id bd71828_of_match[] = { }, { .compatible = "rohm,bd71815", .data = (void *)ROHM_CHIP_TYPE_BD71815, + }, { + .compatible = "rohm,bd72720", + .data = (void *)ROHM_CHIP_TYPE_BD72720, }, { }, }; diff --git a/include/linux/mfd/rohm-bd72720.h b/include/linux/mfd/rohm-bd72720.h new file mode 100644 index 000000000000..ae7343bcab06 --- /dev/null +++ b/include/linux/mfd/rohm-bd72720.h @@ -0,0 +1,634 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright 2025 ROHM Semiconductors. + * + * Author: Matti Vaittinen + */ + +#ifndef _MFD_BD72720_H +#define _MFD_BD72720_H + +#include + +enum { + BD72720_BUCK1, + BD72720_BUCK2, + BD72720_BUCK3, + BD72720_BUCK4, + BD72720_BUCK5, + BD72720_BUCK6, + BD72720_BUCK7, + BD72720_BUCK8, + BD72720_BUCK9, + BD72720_BUCK10, + BD72720_BUCK11, + BD72720_LDO1, + BD72720_LDO2, + BD72720_LDO3, + BD72720_LDO4, + BD72720_LDO5, + BD72720_LDO6, + BD72720_LDO7, + BD72720_LDO8, + BD72720_LDO9, + BD72720_LDO10, + BD72720_LDO11, + BD72720_REGULATOR_AMOUNT, +}; + +/* BD72720 interrupts */ +#define BD72720_INT_LONGPUSH_MASK BIT(0) +#define BD72720_INT_MIDPUSH_MASK BIT(1) +#define BD72720_INT_SHORTPUSH_MASK BIT(2) +#define BD72720_INT_PUSH_MASK BIT(3) +#define BD72720_INT_HALL_DET_MASK BIT(4) +#define BD72720_INT_HALL_TGL_MASK BIT(5) +#define BD72720_INT_WDOG_MASK BIT(6) +#define BD72720_INT_SWRESET_MASK BIT(7) +#define BD72720_INT_SEQ_DONE_MASK BIT(0) +#define BD72720_INT_PGFAULT_MASK BIT(4) +#define BD72720_INT_BUCK1_DVS_MASK BIT(0) +#define BD72720_INT_BUCK2_DVS_MASK BIT(1) +#define BD72720_INT_BUCK3_DVS_MASK BIT(2) +#define BD72720_INT_BUCK4_DVS_MASK BIT(3) +#define BD72720_INT_BUCK5_DVS_MASK BIT(4) +#define BD72720_INT_BUCK6_DVS_MASK BIT(5) +#define BD72720_INT_BUCK7_DVS_MASK BIT(6) +#define BD72720_INT_BUCK8_DVS_MASK BIT(7) +#define BD72720_INT_BUCK9_DVS_MASK BIT(0) +#define BD72720_INT_BUCK10_DVS_MASK BIT(1) +#define BD72720_INT_LDO1_DVS_MASK BIT(4) +#define BD72720_INT_LDO2_DVS_MASK BIT(5) +#define BD72720_INT_LDO3_DVS_MASK BIT(6) +#define BD72720_INT_LDO4_DVS_MASK BIT(7) +#define BD72720_INT_VBUS_RMV_MASK BIT(0) +#define BD72720_INT_VBUS_DET_MASK BIT(1) +#define BD72720_INT_VBUS_MON_RES_MASK BIT(2) +#define BD72720_INT_VBUS_MON_DET_MASK BIT(3) +#define BD72720_INT_VSYS_MON_RES_MASK BIT(0) +#define BD72720_INT_VSYS_MON_DET_MASK BIT(1) +#define BD72720_INT_VSYS_UV_RES_MASK BIT(2) +#define BD72720_INT_VSYS_UV_DET_MASK BIT(3) +#define BD72720_INT_VSYS_LO_RES_MASK BIT(4) +#define BD72720_INT_VSYS_LO_DET_MASK BIT(5) +#define BD72720_INT_VSYS_OV_RES_MASK BIT(6) +#define BD72720_INT_VSYS_OV_DET_MASK BIT(7) +#define BD72720_INT_BAT_ILIM_MASK BIT(0) +#define BD72720_INT_CHG_DONE_MASK BIT(1) +#define BD72720_INT_EXTEMP_TOUT_MASK BIT(2) +#define BD72720_INT_CHG_WDT_EXP_MASK BIT(3) +#define BD72720_INT_BAT_MNT_OUT_MASK BIT(4) +#define BD72720_INT_BAT_MNT_IN_MASK BIT(5) +#define BD72720_INT_CHG_TRNS_MASK BIT(7) +#define BD72720_INT_VBAT_MON_RES_MASK BIT(0) +#define BD72720_INT_VBAT_MON_DET_MASK BIT(1) +#define BD72720_INT_VBAT_SHT_RES_MASK BIT(2) +#define BD72720_INT_VBAT_SHT_DET_MASK BIT(3) +#define BD72720_INT_VBAT_LO_RES_MASK BIT(4) +#define BD72720_INT_VBAT_LO_DET_MASK BIT(5) +#define BD72720_INT_VBAT_OV_RES_MASK BIT(6) +#define BD72720_INT_VBAT_OV_DET_MASK BIT(7) +#define BD72720_INT_BAT_RMV_MASK BIT(0) +#define BD72720_INT_BAT_DET_MASK BIT(1) +#define BD72720_INT_DBAT_DET_MASK BIT(2) +#define BD72720_INT_BAT_TEMP_TRNS_MASK BIT(3) +#define BD72720_INT_LOBTMP_RES_MASK BIT(4) +#define BD72720_INT_LOBTMP_DET_MASK BIT(5) +#define BD72720_INT_OVBTMP_RES_MASK BIT(6) +#define BD72720_INT_OVBTMP_DET_MASK BIT(7) +#define BD72720_INT_OCUR1_RES_MASK BIT(0) +#define BD72720_INT_OCUR1_DET_MASK BIT(1) +#define BD72720_INT_OCUR2_RES_MASK BIT(2) +#define BD72720_INT_OCUR2_DET_MASK BIT(3) +#define BD72720_INT_OCUR3_RES_MASK BIT(4) +#define BD72720_INT_OCUR3_DET_MASK BIT(5) +#define BD72720_INT_CC_MON1_DET_MASK BIT(0) +#define BD72720_INT_CC_MON2_DET_MASK BIT(1) +#define BD72720_INT_CC_MON3_DET_MASK BIT(2) +#define BD72720_INT_GPIO1_IN_MASK BIT(4) +#define BD72720_INT_GPIO2_IN_MASK BIT(5) +#define BD72720_INT_VF125_RES_MASK BIT(0) +#define BD72720_INT_VF125_DET_MASK BIT(1) +#define BD72720_INT_VF_RES_MASK BIT(2) +#define BD72720_INT_VF_DET_MASK BIT(3) +#define BD72720_INT_RTC0_MASK BIT(4) +#define BD72720_INT_RTC1_MASK BIT(5) +#define BD72720_INT_RTC2_MASK BIT(6) + +enum { + /* + * The IRQs excluding GPIO1 and GPIO2 are ordered in a same way as the + * respective IRQ bits in status and mask registers are ordered. + * + * The BD72720_INT_GPIO1_IN and BD72720_INT_GPIO2_IN are IRQs which can + * be used by other devices. Let's have GPIO1 and GPIO2 as first IRQs + * here so we can use the regmap-IRQ with standard device tree xlate + * while devices connected to the BD72720 IRQ input pins can refer to + * the first two interrupt numbers in their device tree. If we placed + * BD72720_INT_GPIO1_IN and BD72720_INT_GPIO2_IN after the CC_MON_DET + * interrupts (like they are in the registers), the devices using + * BD72720 as an IRQ parent should refer the interrupts starting with + * an offset which might not be trivial to understand. + */ + BD72720_INT_GPIO1_IN, + BD72720_INT_GPIO2_IN, + BD72720_INT_LONGPUSH, + BD72720_INT_MIDPUSH, + BD72720_INT_SHORTPUSH, + BD72720_INT_PUSH, + BD72720_INT_HALL_DET, + BD72720_INT_HALL_TGL, + BD72720_INT_WDOG, + BD72720_INT_SWRESET, + BD72720_INT_SEQ_DONE, + BD72720_INT_PGFAULT, + BD72720_INT_BUCK1_DVS, + BD72720_INT_BUCK2_DVS, + BD72720_INT_BUCK3_DVS, + BD72720_INT_BUCK4_DVS, + BD72720_INT_BUCK5_DVS, + BD72720_INT_BUCK6_DVS, + BD72720_INT_BUCK7_DVS, + BD72720_INT_BUCK8_DVS, + BD72720_INT_BUCK9_DVS, + BD72720_INT_BUCK10_DVS, + BD72720_INT_LDO1_DVS, + BD72720_INT_LDO2_DVS, + BD72720_INT_LDO3_DVS, + BD72720_INT_LDO4_DVS, + BD72720_INT_VBUS_RMV, + BD72720_INT_VBUS_DET, + BD72720_INT_VBUS_MON_RES, + BD72720_INT_VBUS_MON_DET, + BD72720_INT_VSYS_MON_RES, + BD72720_INT_VSYS_MON_DET, + BD72720_INT_VSYS_UV_RES, + BD72720_INT_VSYS_UV_DET, + BD72720_INT_VSYS_LO_RES, + BD72720_INT_VSYS_LO_DET, + BD72720_INT_VSYS_OV_RES, + BD72720_INT_VSYS_OV_DET, + BD72720_INT_BAT_ILIM, + BD72720_INT_CHG_DONE, + BD72720_INT_EXTEMP_TOUT, + BD72720_INT_CHG_WDT_EXP, + BD72720_INT_BAT_MNT_OUT, + BD72720_INT_BAT_MNT_IN, + BD72720_INT_CHG_TRNS, + BD72720_INT_VBAT_MON_RES, + BD72720_INT_VBAT_MON_DET, + BD72720_INT_VBAT_SHT_RES, + BD72720_INT_VBAT_SHT_DET, + BD72720_INT_VBAT_LO_RES, + BD72720_INT_VBAT_LO_DET, + BD72720_INT_VBAT_OV_RES, + BD72720_INT_VBAT_OV_DET, + BD72720_INT_BAT_RMV, + BD72720_INT_BAT_DET, + BD72720_INT_DBAT_DET, + BD72720_INT_BAT_TEMP_TRNS, + BD72720_INT_LOBTMP_RES, + BD72720_INT_LOBTMP_DET, + BD72720_INT_OVBTMP_RES, + BD72720_INT_OVBTMP_DET, + BD72720_INT_OCUR1_RES, + BD72720_INT_OCUR1_DET, + BD72720_INT_OCUR2_RES, + BD72720_INT_OCUR2_DET, + BD72720_INT_OCUR3_RES, + BD72720_INT_OCUR3_DET, + BD72720_INT_CC_MON1_DET, + BD72720_INT_CC_MON2_DET, + BD72720_INT_CC_MON3_DET, + BD72720_INT_VF125_RES, + BD72720_INT_VF125_DET, + BD72720_INT_VF_RES, + BD72720_INT_VF_DET, + BD72720_INT_RTC0, + BD72720_INT_RTC1, + BD72720_INT_RTC2, +}; + +/* + * BD72720 Registers: + * The BD72720 has two sets of registers behind two different I2C slave + * addresses. "Common" registers being behind 0x4b, the charger registers + * being behind 0x4c. + */ +/* Registers behind I2C slave 0x4b */ +enum { + BD72720_REG_PRODUCT_ID, + BD72720_REG_MANUFACTURER_ID, + BD72720_REG_PMIC_REV_NUM, + BD72720_REG_NVM_REV_NUM, + BD72720_REG_BOOTSRC = 0x10, + BD72720_REG_RESETSRC_1, + BD72720_REG_RESETSRC_2, + BD72720_REG_RESETSRC_3, + BD72720_REG_RESETSRC_4, + BD72720_REG_RESETSRC_5, + BD72720_REG_RESETSRC_6, + BD72720_REG_RESETSRC_7, + BD72720_REG_POWER_STATE, + BD72720_REG_PS_CFG, + BD72720_REG_PS_CTRL_1, + BD72720_REG_PS_CTRL_2, + BD72720_REG_RCVCFG, + BD72720_REG_RCVNUM, + BD72720_REG_CRDCFG, + BD72720_REG_REX_CTRL, + + BD72720_REG_BUCK1_ON, + BD72720_REG_BUCK1_MODE, + /* Deep idle vsel */ + BD72720_REG_BUCK1_VSEL_DI, + /* Idle vsel */ + BD72720_REG_BUCK1_VSEL_I, + /* Suspend vsel */ + BD72720_REG_BUCK1_VSEL_S, + /* Run boot vsel */ + BD72720_REG_BUCK1_VSEL_RB, + /* Run0 ... run3 vsel */ + BD72720_REG_BUCK1_VSEL_RB0, + BD72720_REG_BUCK1_VSEL_RB1, + BD72720_REG_BUCK1_VSEL_RB2, + BD72720_REG_BUCK1_VSEL_RB3, + + BD72720_REG_BUCK2_ON, + BD72720_REG_BUCK2_MODE, + BD72720_REG_BUCK2_VSEL_DI, + BD72720_REG_BUCK2_VSEL_I, + BD72720_REG_BUCK2_VSEL_S, + /* Run vsel */ + BD72720_REG_BUCK2_VSEL_R, + + BD72720_REG_BUCK3_ON, + BD72720_REG_BUCK3_MODE, + BD72720_REG_BUCK3_VSEL_DI, + BD72720_REG_BUCK3_VSEL_I, + BD72720_REG_BUCK3_VSEL_S, + BD72720_REG_BUCK3_VSEL_R, + + BD72720_REG_BUCK4_ON, + BD72720_REG_BUCK4_MODE, + BD72720_REG_BUCK4_VSEL_DI, + BD72720_REG_BUCK4_VSEL_I, + BD72720_REG_BUCK4_VSEL_S, + BD72720_REG_BUCK4_VSEL_R, + + BD72720_REG_BUCK5_ON, + BD72720_REG_BUCK5_MODE, + BD72720_REG_BUCK5_VSEL, + + BD72720_REG_BUCK6_ON, + BD72720_REG_BUCK6_MODE, + BD72720_REG_BUCK6_VSEL, + + BD72720_REG_BUCK7_ON, + BD72720_REG_BUCK7_MODE, + BD72720_REG_BUCK7_VSEL, + + BD72720_REG_BUCK8_ON, + BD72720_REG_BUCK8_MODE, + BD72720_REG_BUCK8_VSEL, + + BD72720_REG_BUCK9_ON, + BD72720_REG_BUCK9_MODE, + BD72720_REG_BUCK9_VSEL, + + BD72720_REG_BUCK10_ON, + BD72720_REG_BUCK10_MODE, + BD72720_REG_BUCK10_VSEL, + + BD72720_REG_LDO1_ON, + BD72720_REG_LDO1_MODE1, + BD72720_REG_LDO1_MODE2, + BD72720_REG_LDO1_VSEL_DI, + BD72720_REG_LDO1_VSEL_I, + BD72720_REG_LDO1_VSEL_S, + BD72720_REG_LDO1_VSEL_RB, + BD72720_REG_LDO1_VSEL_R0, + BD72720_REG_LDO1_VSEL_R1, + BD72720_REG_LDO1_VSEL_R2, + BD72720_REG_LDO1_VSEL_R3, + + BD72720_REG_LDO2_ON, + BD72720_REG_LDO2_MODE, + BD72720_REG_LDO2_VSEL_DI, + BD72720_REG_LDO2_VSEL_I, + BD72720_REG_LDO2_VSEL_S, + BD72720_REG_LDO2_VSEL_R, + + BD72720_REG_LDO3_ON, + BD72720_REG_LDO3_MODE, + BD72720_REG_LDO3_VSEL_DI, + BD72720_REG_LDO3_VSEL_I, + BD72720_REG_LDO3_VSEL_S, + BD72720_REG_LDO3_VSEL_R, + + BD72720_REG_LDO4_ON, + BD72720_REG_LDO4_MODE, + BD72720_REG_LDO4_VSEL_DI, + BD72720_REG_LDO4_VSEL_I, + BD72720_REG_LDO4_VSEL_S, + BD72720_REG_LDO4_VSEL_R, + + BD72720_REG_LDO5_ON, + BD72720_REG_LDO5_MODE, + BD72720_REG_LDO5_VSEL, + + BD72720_REG_LDO6_ON, + BD72720_REG_LDO6_MODE, + BD72720_REG_LDO6_VSEL, + + BD72720_REG_LDO7_ON, + BD72720_REG_LDO7_MODE, + BD72720_REG_LDO7_VSEL, + + BD72720_REG_LDO8_ON, + BD72720_REG_LDO8_MODE, + BD72720_REG_LDO8_VSEL, + + BD72720_REG_LDO9_ON, + BD72720_REG_LDO9_MODE, + BD72720_REG_LDO9_VSEL, + + BD72720_REG_LDO10_ON, + BD72720_REG_LDO10_MODE, + BD72720_REG_LDO10_VSEL, + + BD72720_REG_LDO11_ON, + BD72720_REG_LDO11_MODE, + BD72720_REG_LDO11_VSEL, + + BD72720_REG_GPIO1_ON = 0x8b, + BD72720_REG_GPIO2_ON, + BD72720_REG_GPIO3_ON, + BD72720_REG_GPIO4_ON, + BD72720_REG_GPIO5_ON, + + BD72720_REG_GPIO1_CTRL, + BD72720_REG_GPIO2_CTRL, +#define BD72720_GPIO_IRQ_TYPE_MASK GENMASK(6, 4) +#define BD72720_GPIO_IRQ_TYPE_FALLING 0x0 +#define BD72720_GPIO_IRQ_TYPE_RISING 0x1 +#define BD72720_GPIO_IRQ_TYPE_BOTH 0x2 +#define BD72720_GPIO_IRQ_TYPE_HIGH 0x3 +#define BD72720_GPIO_IRQ_TYPE_LOW 0x4 + BD72720_REG_GPIO3_CTRL, + BD72720_REG_GPIO4_CTRL, + BD72720_REG_GPIO5_CTRL, +#define BD72720_GPIO_DRIVE_MASK BIT(1) +#define BD72720_GPIO_HIGH BIT(0) + + BD72720_REG_EPDEN_CTRL, + BD72720_REG_GATECNT_CTRL, + BD72720_REG_LED_CTRL, + + BD72720_REG_PWRON_CFG1, + BD72720_REG_PWRON_CFG2, + + BD72720_REG_OUT32K, + BD72720_REG_CONF, + BD72720_REG_HALL_STAT, + + BD72720_REG_RTC_SEC = 0xa0, +#define BD72720_REG_RTC_START BD72720_REG_RTC_SEC + BD72720_REG_RTC_MIN, + BD72720_REG_RTC_HOUR, + BD72720_REG_RTC_WEEK, + BD72720_REG_RTC_DAY, + BD72720_REG_RTC_MON, + BD72720_REG_RTC_YEAR, + + BD72720_REG_RTC_ALM0_SEC, +#define BD72720_REG_RTC_ALM_START BD72720_REG_RTC_ALM0_SEC + BD72720_REG_RTC_ALM0_MIN, + BD72720_REG_RTC_ALM0_HOUR, + BD72720_REG_RTC_ALM0_WEEK, + BD72720_REG_RTC_ALM0_MON, + BD72720_REG_RTC_ALM0_YEAR, + + BD72720_REG_RTC_ALM1_SEC, + BD72720_REG_RTC_ALM1_MIN, + BD72720_REG_RTC_ALM1_HOUR, + BD72720_REG_RTC_ALM1_WEEK, + BD72720_REG_RTC_ALM1_MON, + BD72720_REG_RTC_ALM1_YEAR, + + BD72720_REG_RTC_ALM0_EN, + BD72720_REG_RTC_ALM1_EN, + BD72720_REG_RTC_ALM2, + + BD72720_REG_INT_LVL1_EN = 0xc0, +#define BD72720_MASK_LVL1_EN_ALL GENMASK(7, 0) + BD72720_REG_INT_PS1_EN, + BD72720_REG_INT_PS2_EN, + BD72720_REG_INT_DVS1_EN, + BD72720_REG_INT_DVS2_EN, + BD72720_REG_INT_VBUS_EN, + BD72720_REG_INT_VSYS_EN, + BD72720_REG_INT_CHG_EN, + BD72720_REG_INT_BAT1_EN, + BD72720_REG_INT_BAT2_EN, + BD72720_REG_INT_IBAT_EN, + BD72720_REG_INT_ETC1_EN, + BD72720_REG_INT_ETC2_EN, + + /* + * The _STAT registers inform IRQ line state, and are used to ack IRQ. + * The _SRC registers below indicate current state of the function + * connected to the line. + */ + BD72720_REG_INT_LVL1_STAT, + BD72720_REG_INT_PS1_STAT, + BD72720_REG_INT_PS2_STAT, + BD72720_REG_INT_DVS1_STAT, + BD72720_REG_INT_DVS2_STAT, + BD72720_REG_INT_VBUS_STAT, + BD72720_REG_INT_VSYS_STAT, + BD72720_REG_INT_CHG_STAT, + BD72720_REG_INT_BAT1_STAT, + BD72720_REG_INT_BAT2_STAT, + BD72720_REG_INT_IBAT_STAT, + BD72720_REG_INT_ETC1_STAT, + BD72720_REG_INT_ETC2_STAT, + + BD72720_REG_INT_LVL1_SRC, + BD72720_REG_INT_PS1_SRC, + BD72720_REG_INT_PS2_SRC, + BD72720_REG_INT_DVS1_SRC, + BD72720_REG_INT_DVS2_SRC, + BD72720_REG_INT_VBUS_SRC, +#define BD72720_MASK_DCIN_DET BIT(1) + BD72720_REG_INT_VSYS_SRC, + BD72720_REG_INT_CHG_SRC, + BD72720_REG_INT_BAT1_SRC, + BD72720_REG_INT_BAT2_SRC, + BD72720_REG_INT_IBAT_SRC, + BD72720_REG_INT_ETC1_SRC, + BD72720_REG_INT_ETC2_SRC, +}; + +/* Register masks */ +#define BD72720_MASK_DEEP_IDLE_EN BIT(0) +#define BD72720_MASK_IDLE_EN BIT(1) +#define BD72720_MASK_SUSPEND_EN BIT(2) +#define BD72720_MASK_RUN_B_EN BIT(3) +#define BD72720_MASK_RUN_0_EN BIT(4) +#define BD72720_MASK_RUN_1_EN BIT(5) +#define BD72720_MASK_RUN_2_EN BIT(6) +#define BD72720_MASK_RUN_3_EN BIT(7) + +#define BD72720_MASK_RAMP_UP_DELAY GENMASK(7, 6) +#define BD72720_MASK_BUCK_VSEL GENMASK(7, 0) +#define BD72720_MASK_LDO12346_VSEL GENMASK(6, 0) +#define BD72720_MASK_LDO_VSEL GENMASK(7, 0) + +#define BD72720_I2C4C_ADDR_OFFSET 0x100 + +/* Registers behind I2C slave 0x4c */ +enum { + BD72720_REG_CHG_STATE = BD72720_I2C4C_ADDR_OFFSET, + BD72720_REG_CHG_LAST_STATE, + BD72720_REG_CHG_VBUS_STAT, + BD72720_REG_CHG_VSYS_STAT, + BD72720_REG_CHG_BAT_TEMP_STAT, + BD72720_REG_CHG_WDT_STAT, + BD72720_REG_CHG_ILIM_STAT, + BD72720_REG_CHG_CHG_STAT, + BD72720_REG_CHG_EN, + BD72720_REG_CHG_INIT, + BD72720_REG_CHG_CTRL, + BD72720_REG_CHG_SET_1, + BD72720_REG_CHG_SET_2, + BD72720_REG_CHG_SET_3, + BD72720_REG_CHG_VPRE, + BD72720_REG_CHG_VBAT_1, + BD72720_REG_CHG_VBAT_2, + BD72720_REG_CHG_VBAT_3, + BD72720_REG_CHG_VBAT_4, + BD72720_REG_CHG_BAT_SET_1, + BD72720_REG_CHG_BAT_SET_2, + BD72720_REG_CHG_BAT_SET_3, + BD72720_REG_CHG_IPRE, + BD72720_REG_CHG_IFST_TERM, + BD72720_REG_CHG_VSYS_REG, + BD72720_REG_CHG_VBUS_SET, + BD72720_REG_CHG_WDT_PRE, + BD72720_REG_CHG_WDT_FST, + BD72720_REG_CHG_LED_CTRL, + BD72720_REG_CHG_CFG_1, + BD72720_REG_CHG_IFST_1, + BD72720_REG_CHG_IFST_2, + BD72720_REG_CHG_IFST_3, + BD72720_REG_CHG_IFST_4, + BD72720_REG_CHG_S_CFG_1, + BD72720_REG_CHG_S_CFG_2, + BD72720_REG_RS_VBUS, + BD72720_REG_RS_IBUS, + BD72720_REG_RS_VSYS, + BD72720_REG_VSYS_STATE_STAT, /* 0x27 + offset*/ + + BD72720_REG_VM_VBAT_U = BD72720_I2C4C_ADDR_OFFSET + 0x30, + BD72720_REG_VM_VBAT_L, + BD72720_REG_VM_OCV_PRE_U, + BD72720_REG_VM_OCV_PRE_L, + BD72720_REG_VM_OCV_PST_U, + BD72720_REG_VM_OCV_PST_L, + BD72720_REG_VM_OCV_PWRON_U, + BD72720_REG_VM_OCV_PWRON_L, + BD72720_REG_VM_DVBAT_IMP_U, + BD72720_REG_VM_DVBAT_IMP_L, + BD72720_REG_VM_SA_VBAT_U, + BD72720_REG_VM_SA_VBAT_L, + BD72720_REG_VM_SA_VBAT_MIN_U, + BD72720_REG_VM_SA_VBAT_MIN_L, + BD72720_REG_VM_SA_VBAT_MAX_U, + BD72720_REG_VM_SA_VBAT_MAX_L, + BD72720_REG_REX_SA_VBAT_U, + BD72720_REG_REX_SA_VBAT_L, + BD72720_REG_VM_VSYS_U, + BD72720_REG_VM_VSYS_L, + BD72720_REG_VM_SA_VSYS_U, + BD72720_REG_VM_SA_VSYS_L, + BD72720_REG_VM_SA_VSYS_MIN_U, + BD72720_REG_VM_SA_VSYS_MIN_L, + BD72720_REG_VM_SA_VSYS_MAX_U, + BD72720_REG_VM_SA_VSYS_MAX_L, + BD72720_REG_VM_SA2_VSYS_U, + BD72720_REG_VM_SA2_VSYS_L, + BD72720_REG_VM_VBUS_U, +#define BD72720_MASK_VDCIN_U GENMASK(3, 0) + BD72720_REG_VM_VBUS_L, + BD72720_REG_VM_BATID_U, + BD72720_REG_VM_BATID_L, + BD72720_REG_VM_BATID_NOLOAD_U, + BD72720_REG_VM_BATID_NOLOAD_L, + BD72720_REG_VM_BATID_OFS_U, + BD72720_REG_VM_BATID_OFS_L, + BD72720_REG_VM_VTH_U, + BD72720_REG_VM_VTH_L, + BD72720_REG_VM_VTH_CORR_U, + BD72720_REG_VM_VTH_CORR_L, + BD72720_REG_VM_BTMP_U, + BD72720_REG_VM_BTMP_L, + BD72720_REG_VM_BTMP_IMP_U, + BD72720_REG_VM_BTMP_IMP_L, + BD72720_REG_VM_VF_U, + BD72720_REG_VM_VF_L, + BD72720_REG_VM_BATID_TH_U, + BD72720_REG_VM_BATID_TH_L, + BD72720_REG_VM_BTMP_OV_THR, + BD72720_REG_VM_BTMP_OV_DUR, + BD72720_REG_VM_BTMP_LO_THR, + BD72720_REG_VM_BTMP_LO_DUR, + BD72720_REG_ALM_VBAT_TH_U, + BD72720_REG_ALM_VBAT_TH_L, + BD72720_REG_ALM_VSYS_TH, + BD72720_REG_ALM_VBUS_TH, + BD72720_REG_ALM_VF_TH, + BD72720_REG_VSYS_MAX, + BD72720_REG_VSYS_MIN, + BD72720_REG_VM_VSYS_SA_MINMAX_CTRL, + BD72720_REG_VM_SA_CFG, /* 0x6c + offset*/ + + BD72720_REG_CC_CURCD_U = BD72720_I2C4C_ADDR_OFFSET + 0x70, + BD72720_REG_CC_CURCD_L, + BD72720_REG_CC_CURCD_IMP_U, + BD72720_REG_CC_CURCD_IMP_L, + BD72720_REG_CC_SA_CURCD_U, + BD72720_REG_CC_SA_CURCD_L, + BD72720_REG_CC_OCUR_MON, + BD72720_REG_CC_CCNTD_3, + BD72720_REG_CC_CCNTD_2, + BD72720_REG_CC_CCNTD_1, + BD72720_REG_CC_CCNTD_0, + BD72720_REG_REX_CCNTD_3, + BD72720_REG_REX_CCNTD_2, + BD72720_REG_REX_CCNTD_1, + BD72720_REG_REX_CCNTD_0, + BD72720_REG_FULL_CCNTD_3, + BD72720_REG_FULL_CCNTD_2, + BD72720_REG_FULL_CCNTD_1, + BD72720_REG_FULL_CCNTD_0, + BD72720_REG_CCNTD_CHG_3, + BD72720_REG_CCNTD_CHG_2, + BD72720_REG_CC_STAT, + BD72720_REG_CC_CTRL, + BD72720_REG_CC_OCUR_THR_1, + BD72720_REG_CC_OCUR_THR_2, + BD72720_REG_CC_OCUR_THR_3, + BD72720_REG_REX_CURCD_TH, + BD72720_REG_CC_BATCAP1_TH_U, + BD72720_REG_CC_BATCAP1_TH_L, + BD72720_REG_CC_BATCAP2_TH_U, + BD72720_REG_CC_BATCAP2_TH_L, + BD72720_REG_CC_BATCAP3_TH_U, + BD72720_REG_CC_BATCAP3_TH_L, + BD72720_REG_CC_CCNTD_CTRL, + BD72720_REG_CC_SA_CFG, /* 0x92 + offset*/ + BD72720_REG_IMPCHK_CTRL = BD72720_I2C4C_ADDR_OFFSET + 0xa0, +}; + +#endif /* __LINUX_MFD_BD72720_H */ diff --git a/include/linux/mfd/rohm-generic.h b/include/linux/mfd/rohm-generic.h index 579e8dcfcca4..0a284919a6c3 100644 --- a/include/linux/mfd/rohm-generic.h +++ b/include/linux/mfd/rohm-generic.h @@ -16,6 +16,7 @@ enum rohm_chip_type { ROHM_CHIP_TYPE_BD71828, ROHM_CHIP_TYPE_BD71837, ROHM_CHIP_TYPE_BD71847, + ROHM_CHIP_TYPE_BD72720, ROHM_CHIP_TYPE_BD96801, ROHM_CHIP_TYPE_BD96802, ROHM_CHIP_TYPE_BD96805, From 8dc33b7c995e3e08087053b79cf919fba61e3669 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:19:53 +0200 Subject: [PATCH 35/59] regulator: bd71828: rename IC specific entities The new ROHM BD72720 PMIC has similarities with the BD71828. It makes sense to support the regulator control for both PMICs using the same driver. It is often more clear to have the IC specific functions and globals named starting with the chip-name. So, as a preparatory step, prefix the BD71828 specific functions and globals with the bd71828. It would be tempting to try also removing the chip ID from those functions which will be common for both PMICs. I have bad experiences on this as it tends to lead to problems when yet another IC is being supported with the same driver, and we will have some functions used for all, some for two of the three, and some for just one. At this point I used to start inventing wildcards like BD718XX or BD7272X. This approach is pretty much always failing as we tend to eventually have something like BD73900 - where all the wildcard stuff will break down. So, my approach these days is to: - keep the original chip-id prefix for anything that had it already (and avoid the churn). - use same prefix for all things that are used by multiple ICs - typically the chip-ID of the first chip. This typically matches also the driver and file names. - use specific chip-ID as a prefix for anything which is specific to just one chip. As a preparatory step to adding the BD72720, add bd71828 prefix to all commonly usable functions and globals. Signed-off-by: Matti Vaittinen Acked-by: Mark Brown Link: https://patch.msgid.link/df5c98c6392c3b52cd41e3d98d60b65a1585b2dd.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/regulator/bd71828-regulator.c | 32 +++++++++++++-------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/drivers/regulator/bd71828-regulator.c b/drivers/regulator/bd71828-regulator.c index 87de87793fa1..8c006bff89a8 100644 --- a/drivers/regulator/bd71828-regulator.c +++ b/drivers/regulator/bd71828-regulator.c @@ -28,7 +28,7 @@ struct bd71828_regulator_data { int reg_init_amnt; }; -static const struct reg_init buck1_inits[] = { +static const struct reg_init bd71828_buck1_inits[] = { /* * DVS Buck voltages can be changed by register values or via GPIO. * Use register accesses by default. @@ -40,7 +40,7 @@ static const struct reg_init buck1_inits[] = { }, }; -static const struct reg_init buck2_inits[] = { +static const struct reg_init bd71828_buck2_inits[] = { { .reg = BD71828_REG_PS_CTRL_1, .mask = BD71828_MASK_DVS_BUCK2_CTRL, @@ -48,7 +48,7 @@ static const struct reg_init buck2_inits[] = { }, }; -static const struct reg_init buck6_inits[] = { +static const struct reg_init bd71828_buck6_inits[] = { { .reg = BD71828_REG_PS_CTRL_1, .mask = BD71828_MASK_DVS_BUCK6_CTRL, @@ -56,7 +56,7 @@ static const struct reg_init buck6_inits[] = { }, }; -static const struct reg_init buck7_inits[] = { +static const struct reg_init bd71828_buck7_inits[] = { { .reg = BD71828_REG_PS_CTRL_1, .mask = BD71828_MASK_DVS_BUCK7_CTRL, @@ -102,9 +102,9 @@ static int buck_set_hw_dvs_levels(struct device_node *np, return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap); } -static int ldo6_parse_dt(struct device_node *np, - const struct regulator_desc *desc, - struct regulator_config *cfg) +static int bd71828_ldo6_parse_dt(struct device_node *np, + const struct regulator_desc *desc, + struct regulator_config *cfg) { int ret, i; uint32_t uv = 0; @@ -212,8 +212,8 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { */ .lpsr_on_mask = BD71828_MASK_LPSR_EN, }, - .reg_inits = buck1_inits, - .reg_init_amnt = ARRAY_SIZE(buck1_inits), + .reg_inits = bd71828_buck1_inits, + .reg_init_amnt = ARRAY_SIZE(bd71828_buck1_inits), }, { .desc = { @@ -253,8 +253,8 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT, .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, }, - .reg_inits = buck2_inits, - .reg_init_amnt = ARRAY_SIZE(buck2_inits), + .reg_inits = bd71828_buck2_inits, + .reg_init_amnt = ARRAY_SIZE(bd71828_buck2_inits), }, { .desc = { @@ -399,8 +399,8 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT, .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, }, - .reg_inits = buck6_inits, - .reg_init_amnt = ARRAY_SIZE(buck6_inits), + .reg_inits = bd71828_buck6_inits, + .reg_init_amnt = ARRAY_SIZE(bd71828_buck6_inits), }, { .desc = { @@ -440,8 +440,8 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT, .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, }, - .reg_inits = buck7_inits, - .reg_init_amnt = ARRAY_SIZE(buck7_inits), + .reg_inits = bd71828_buck7_inits, + .reg_init_amnt = ARRAY_SIZE(bd71828_buck7_inits), }, { .desc = { @@ -633,7 +633,7 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { * LDO6 only supports enable/disable for all states. * Voltage for LDO6 is fixed. */ - .of_parse_cb = ldo6_parse_dt, + .of_parse_cb = bd71828_ldo6_parse_dt, }, }, { .desc = { From f16a9d76a71df5038fc8e6dae44caa1e5e76b041 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:20:06 +0200 Subject: [PATCH 36/59] regulator: bd71828: Support ROHM BD72720 ROHM BD72720 is a power management IC which integrates 10 buck and 11 LDO regulators. This PMIC has plenty of commonalities with the BD71828 and BD71879. The BD72720 does also have similar 'run-level'-concept as the BD71828 had. It allows controlling the regulator's 'en masse', although only BUCK1 and LDO1 can utilize this in BD72720. Similar to BD71828, this 'en masse' -control is not supported by this driver. Support the voltage and enable/disable state control for the BD72720. Signed-off-by: Matti Vaittinen Reviewed-by: Mark Brown Link: https://patch.msgid.link/88b82128648516d9dbb173044042f2a7a5dfdf1c.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/regulator/Kconfig | 8 +- drivers/regulator/bd71828-regulator.c | 995 +++++++++++++++++++++++++- 2 files changed, 993 insertions(+), 10 deletions(-) diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig index d2335276cce5..003bd938c84a 100644 --- a/drivers/regulator/Kconfig +++ b/drivers/regulator/Kconfig @@ -241,13 +241,13 @@ config REGULATOR_BD71815 will be called bd71815-regulator. config REGULATOR_BD71828 - tristate "ROHM BD71828 Power Regulator" + tristate "ROHM BD71828, BD72720 and BD73900 Power Regulators" depends on MFD_ROHM_BD71828 select REGULATOR_ROHM help - This driver supports voltage regulators on ROHM BD71828 PMIC. - This will enable support for the software controllable buck - and LDO regulators. + This driver supports voltage regulators on ROHM BD71828, + BD71879, BD72720 and BD73900 PMICs. This will enable + support for the software controllable buck and LDO regulators. This driver can also be built as a module. If so, the module will be called bd71828-regulator. diff --git a/drivers/regulator/bd71828-regulator.c b/drivers/regulator/bd71828-regulator.c index 8c006bff89a8..c8f3343cfe23 100644 --- a/drivers/regulator/bd71828-regulator.c +++ b/drivers/regulator/bd71828-regulator.c @@ -3,12 +3,15 @@ // bd71828-regulator.c ROHM BD71828GW-DS1 regulator driver // +#include #include #include #include #include #include +#include #include +#include #include #include #include @@ -16,6 +19,7 @@ #include #include +#define BD72720_MASK_LDON_HEAD GENMASK(2, 0) struct reg_init { unsigned int reg; unsigned int mask; @@ -64,6 +68,26 @@ static const struct reg_init bd71828_buck7_inits[] = { }, }; +#define BD72720_MASK_DVS_BUCK1_CTRL BIT(4) +#define BD72720_MASK_DVS_LDO1_CTRL BIT(5) + +static const struct reg_init bd72720_buck1_inits[] = { + { + .reg = BD72720_REG_PS_CTRL_2, + .mask = BD72720_MASK_DVS_BUCK1_CTRL, + .val = 0, /* Disable "run-level" control */ + }, +}; + +static const struct reg_init bd72720_ldo1_inits[] = { + { + .reg = BD72720_REG_PS_CTRL_2, + .mask = BD72720_MASK_DVS_LDO1_CTRL, + .val = 0, /* Disable "run-level" control */ + }, +}; + +/* BD71828 Buck voltages */ static const struct linear_range bd71828_buck1267_volts[] = { REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250), REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0), @@ -84,13 +108,79 @@ static const struct linear_range bd71828_buck5_volts[] = { REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0), }; +/* BD71828 LDO voltages */ static const struct linear_range bd71828_ldo_volts[] = { REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000), REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0), }; +/* BD72720 Buck voltages */ +static const struct linear_range bd72720_buck1234_volts[] = { + REGULATOR_LINEAR_RANGE(500000, 0x00, 0xc0, 6250), + REGULATOR_LINEAR_RANGE(1700000, 0xc1, 0xff, 0), +}; + +static const struct linear_range bd72720_buck589_volts[] = { + REGULATOR_LINEAR_RANGE(500000, 0x00, 0x78, 10000), + REGULATOR_LINEAR_RANGE(1700000, 0x79, 0xff, 0), +}; + +static const struct linear_range bd72720_buck67_volts[] = { + REGULATOR_LINEAR_RANGE(1500000, 0x00, 0xb4, 10000), + REGULATOR_LINEAR_RANGE(3300000, 0xb5, 0xff, 0), +}; + +/* + * The BUCK10 on BD72720 has two modes of operation, depending on a LDON_HEAD + * setting. When LDON_HEAD is 0x0, the behaviour is as with other bucks, eg. + * voltage can be set to a values indicated below using the VSEL register. + * + * However, when LDON_HEAD is set to 0x1 ... 0x7, BUCK 10 voltage is, according + * to the data-sheet, "automatically adjusted following LDON_HEAD setting and + * clamped to BUCK10_VID setting". + * + * Again, reading the data-sheet shows a "typical connection" where the BUCK10 + * is used to supply the LDOs 1-4. My assumption is that in practice, this + * means that the BUCK10 voltage will be adjusted based on the maximum output + * of the LDO 1-4 (to minimize power loss). This makes sense. + * + * Auto-adjusting regulators aren't something I really like to model in the + * driver though - and, if the auto-adjustment works as intended, then there + * should really be no need to software to care about the buck10 voltages. + * If enable/disable control is still needed, we can implement buck10 as a + * regulator with only the enable/disable ops - and device-tree can be used + * to model the supply-relations. I believe this could allow the regulator + * framework to automagically disable the BUCK10 if all LDOs that are being + * supplied by it are disabled. + */ +static const struct linear_range bd72720_buck10_volts[] = { + REGULATOR_LINEAR_RANGE(500000, 0x00, 0xc0, 6250), + REGULATOR_LINEAR_RANGE(1700000, 0xc1, 0xff, 0), +}; + +/* BD72720 LDO voltages */ +static const struct linear_range bd72720_ldo1234_volts[] = { + REGULATOR_LINEAR_RANGE(500000, 0x00, 0x50, 6250), + REGULATOR_LINEAR_RANGE(1000000, 0x51, 0x7f, 0), +}; + +static const struct linear_range bd72720_ldo57891011_volts[] = { + REGULATOR_LINEAR_RANGE(750000, 0x00, 0xff, 10000), +}; + +static const struct linear_range bd72720_ldo6_volts[] = { + REGULATOR_LINEAR_RANGE(600000, 0x00, 0x78, 10000), + REGULATOR_LINEAR_RANGE(1800000, 0x79, 0x7f, 0), +}; + static const unsigned int bd71828_ramp_delay[] = { 2500, 5000, 10000, 20000 }; +/* + * BD72720 supports setting both the ramp-up and ramp-down values + * separately. Do we need to support ramp-down setting? + */ +static const unsigned int bd72720_ramp_delay[] = { 5000, 7500, 10000, 12500 }; + static int buck_set_hw_dvs_levels(struct device_node *np, const struct regulator_desc *desc, struct regulator_config *cfg) @@ -171,6 +261,24 @@ static const struct regulator_ops bd71828_ldo6_ops = { .is_enabled = regulator_is_enabled_regmap, }; +static const struct regulator_ops bd72720_regulator_ops = { + .enable = regulator_enable_regmap, + .disable = regulator_disable_regmap, + .is_enabled = regulator_is_enabled_regmap, + .list_voltage = regulator_list_voltage_linear_range, + .set_voltage_sel = regulator_set_voltage_sel_regmap, + .get_voltage_sel = regulator_get_voltage_sel_regmap, + .set_voltage_time_sel = regulator_set_voltage_time_sel, + .set_ramp_delay = regulator_set_ramp_delay_regmap, +}; + +static const struct regulator_ops bd72720_buck10_ldon_head_op = { + .enable = regulator_enable_regmap, + .disable = regulator_disable_regmap, + .is_enabled = regulator_is_enabled_regmap, + .set_ramp_delay = regulator_set_ramp_delay_regmap, +}; + static const struct bd71828_regulator_data bd71828_rdata[] = { { .desc = { @@ -677,22 +785,890 @@ static const struct bd71828_regulator_data bd71828_rdata[] = { }, }; +#define BD72720_BUCK10_DESC_INDEX 10 +#define BD72720_NUM_BUCK_VOLTS 0x100 +#define BD72720_NUM_LDO_VOLTS 0x100 +#define BD72720_NUM_LDO12346_VOLTS 0x80 + +static const struct bd71828_regulator_data bd72720_rdata[] = { + { + .desc = { + .name = "buck1", + .of_match = of_match_ptr("buck1"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK1, + .type = REGULATOR_VOLTAGE, + + /* + * The BD72720 BUCK1 and LDO1 support GPIO toggled + * sub-RUN states called RUN0, RUN1, RUN2 and RUN3. + * The "operating mode" (sub-RUN states or normal) + * can be changed by a register. + * + * When the sub-RUN states are used, the voltage and + * enable state depend on a state specific + * configuration. The voltage and enable configuration + * for BUCK1 and LDO1 can be defined for each sub-RUN + * state using BD72720_REG_[BUCK,LDO]1_VSEL_R[0,1,2,3] + * voltage selection registers and the bits + * BD72720_MASK_RUN_[0,1,2,3]_EN in the enable registers. + * The PMIC will change both the BUCK1 and LDO1 voltages + * to the states defined in these registers when + * "DVS GPIOs" are toggled. + * + * If RUN 0 .. RUN 4 states are to be used, the normal + * voltage configuration mechanisms do not apply + * and we should overwrite the ops and ignore the + * voltage setting/getting registers which are setup + * here. This is not supported for now. If you need + * this functionality, you may try merging functionality + * from a downstream driver: + * https://rohmsemiconductor.github.io/Linux-Kernel-PMIC-Drivers/BD72720/ + */ + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK1_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK1_VSEL_RB, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK1_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, /* Deep idle in data-sheet */ + .run_reg = BD72720_REG_BUCK1_VSEL_RB, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_reg = BD72720_REG_BUCK1_VSEL_I, + .idle_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_BUCK1_VSEL_S, + .suspend_mask = BD72720_MASK_BUCK_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_BUCK1_VSEL_DI, + .lpsr_mask = BD72720_MASK_BUCK_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + .reg_inits = bd72720_buck1_inits, + .reg_init_amnt = ARRAY_SIZE(bd72720_buck1_inits), + }, { + .desc = { + .name = "buck2", + .of_match = of_match_ptr("buck2"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK2, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK2_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK2_VSEL_R, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK2_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK2_VSEL_R, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_reg = BD72720_REG_BUCK2_VSEL_I, + .idle_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_BUCK2_VSEL_S, + .suspend_mask = BD72720_MASK_BUCK_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_BUCK2_VSEL_DI, + .lpsr_mask = BD72720_MASK_BUCK_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck3", + .of_match = of_match_ptr("buck3"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK3, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK3_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK3_VSEL_R, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK3_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK3_VSEL_R, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_reg = BD72720_REG_BUCK3_VSEL_I, + .idle_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_BUCK3_VSEL_S, + .suspend_mask = BD72720_MASK_BUCK_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_BUCK3_VSEL_DI, + .lpsr_mask = BD72720_MASK_BUCK_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck4", + .of_match = of_match_ptr("buck4"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK4, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK4_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK4_VSEL_R, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK4_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK4_VSEL_R, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_reg = BD72720_REG_BUCK4_VSEL_I, + .idle_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_BUCK4_VSEL_S, + .suspend_mask = BD72720_MASK_BUCK_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_BUCK4_VSEL_DI, + .lpsr_mask = BD72720_MASK_BUCK_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck5", + .of_match = of_match_ptr("buck5"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK5, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck589_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK5_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK5_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK5_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK5_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck6", + .of_match = of_match_ptr("buck6"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK6, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck67_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck67_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK6_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK6_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK6_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK6_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck7", + .of_match = of_match_ptr("buck7"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK7, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck67_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck67_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK7_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK7_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK7_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK7_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck8", + .of_match = of_match_ptr("buck8"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK8, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck589_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK8_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK8_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK8_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK8_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck9", + .of_match = of_match_ptr("buck9"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK9, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck589_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK9_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK9_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK9_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK9_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "buck10", + .of_match = of_match_ptr("buck10"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_BUCK10, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_buck10_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_buck10_volts), + .n_voltages = BD72720_NUM_BUCK_VOLTS, + .enable_reg = BD72720_REG_BUCK10_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_BUCK10_VSEL, + .vsel_mask = BD72720_MASK_BUCK_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_BUCK10_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_BUCK10_VSEL, + .run_mask = BD72720_MASK_BUCK_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo1", + .of_match = of_match_ptr("ldo1"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO1, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts), + .n_voltages = BD72720_NUM_LDO12346_VOLTS, + .enable_reg = BD72720_REG_LDO1_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO1_VSEL_RB, + .vsel_mask = BD72720_MASK_LDO12346_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO1_MODE1, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO1_VSEL_RB, + .run_mask = BD72720_MASK_LDO12346_VSEL, + .idle_reg = BD72720_REG_LDO1_VSEL_I, + .idle_mask = BD72720_MASK_LDO12346_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_LDO1_VSEL_S, + .suspend_mask = BD72720_MASK_LDO12346_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_LDO1_VSEL_DI, + .lpsr_mask = BD72720_MASK_LDO12346_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + .reg_inits = bd72720_ldo1_inits, + .reg_init_amnt = ARRAY_SIZE(bd72720_ldo1_inits), + }, { + .desc = { + .name = "ldo2", + .of_match = of_match_ptr("ldo2"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO2, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts), + .n_voltages = BD72720_NUM_LDO12346_VOLTS, + .enable_reg = BD72720_REG_LDO2_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO2_VSEL_R, + .vsel_mask = BD72720_MASK_LDO12346_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO2_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO2_VSEL_R, + .run_mask = BD72720_MASK_LDO12346_VSEL, + .idle_reg = BD72720_REG_LDO2_VSEL_I, + .idle_mask = BD72720_MASK_LDO12346_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_LDO2_VSEL_S, + .suspend_mask = BD72720_MASK_LDO12346_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_LDO2_VSEL_DI, + .lpsr_mask = BD72720_MASK_LDO12346_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo3", + .of_match = of_match_ptr("ldo3"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO3, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts), + .n_voltages = BD72720_NUM_LDO12346_VOLTS, + .enable_reg = BD72720_REG_LDO3_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO3_VSEL_R, + .vsel_mask = BD72720_MASK_LDO12346_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO3_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO3_VSEL_R, + .run_mask = BD72720_MASK_LDO12346_VSEL, + .idle_reg = BD72720_REG_LDO3_VSEL_I, + .idle_mask = BD72720_MASK_LDO12346_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_LDO3_VSEL_S, + .suspend_mask = BD72720_MASK_LDO12346_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_LDO3_VSEL_DI, + .lpsr_mask = BD72720_MASK_LDO12346_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo4", + .of_match = of_match_ptr("ldo4"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO4, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo1234_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts), + .n_voltages = BD72720_NUM_LDO12346_VOLTS, + .enable_reg = BD72720_REG_LDO4_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO4_VSEL_R, + .vsel_mask = BD72720_MASK_LDO12346_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO4_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO4_VSEL_R, + .run_mask = BD72720_MASK_LDO12346_VSEL, + .idle_reg = BD72720_REG_LDO4_VSEL_I, + .idle_mask = BD72720_MASK_LDO12346_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_reg = BD72720_REG_LDO4_VSEL_S, + .suspend_mask = BD72720_MASK_LDO12346_VSEL, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_reg = BD72720_REG_LDO4_VSEL_DI, + .lpsr_mask = BD72720_MASK_LDO12346_VSEL, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo5", + .of_match = of_match_ptr("ldo5"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO5, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO5_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO5_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO5_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO5_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo6", + .of_match = of_match_ptr("ldo6"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO6, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo6_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo6_volts), + .n_voltages = BD72720_NUM_LDO12346_VOLTS, + .enable_reg = BD72720_REG_LDO6_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO6_VSEL, + .vsel_mask = BD72720_MASK_LDO12346_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO6_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO6_VSEL, + .run_mask = BD72720_MASK_LDO12346_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo7", + .of_match = of_match_ptr("ldo7"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO7, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO7_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO7_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO7_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO7_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo8", + .of_match = of_match_ptr("ldo8"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO8, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO8_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO8_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO8_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO8_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo9", + .of_match = of_match_ptr("ldo9"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO9, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO9_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO9_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO9_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO9_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo10", + .of_match = of_match_ptr("ldo10"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO10, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO10_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO10_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO10_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO10_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, { + .desc = { + .name = "ldo11", + .of_match = of_match_ptr("ldo11"), + .regulators_node = of_match_ptr("regulators"), + .id = BD72720_LDO11, + .type = REGULATOR_VOLTAGE, + .ops = &bd72720_regulator_ops, + .linear_ranges = bd72720_ldo57891011_volts, + .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts), + .n_voltages = BD72720_NUM_LDO_VOLTS, + .enable_reg = BD72720_REG_LDO11_ON, + .enable_mask = BD72720_MASK_RUN_B_EN, + .vsel_reg = BD72720_REG_LDO11_VSEL, + .vsel_mask = BD72720_MASK_LDO_VSEL, + + .ramp_delay_table = bd72720_ramp_delay, + .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay), + .ramp_reg = BD72720_REG_LDO11_MODE, + .ramp_mask = BD72720_MASK_RAMP_UP_DELAY, + .owner = THIS_MODULE, + .of_parse_cb = buck_set_hw_dvs_levels, + }, + .dvs = { + .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | + ROHM_DVS_LEVEL_SUSPEND | + ROHM_DVS_LEVEL_LPSR, + .run_reg = BD72720_REG_LDO11_VSEL, + .run_mask = BD72720_MASK_LDO_VSEL, + .idle_on_mask = BD72720_MASK_IDLE_EN, + .suspend_on_mask = BD72720_MASK_SUSPEND_EN, + .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN, + }, + }, +}; + +static int bd72720_buck10_ldon_head_mode(struct device *dev, + struct device_node *npreg, + struct regmap *regmap, + struct regulator_desc *buck10_desc) +{ + struct device_node *np __free(device_node) = + of_get_child_by_name(npreg, "buck10"); + uint32_t ldon_head; + int ldon_val; + int ret; + + if (!np) { + dev_err(dev, "failed to find buck10 regulator node\n"); + return -ENODEV; + } + + ret = of_property_read_u32(np, "rohm,ldon-head-microvolt", &ldon_head); + if (ret == -EINVAL) + return 0; + if (ret) + return ret; + + /* + * LDON_HEAD mode means the BUCK10 is used to supply LDOs 1-4 and + * the BUCK 10 voltage is automatically set to follow LDO 1-4 + * settings. Thus the BUCK10 should not allow voltage [g/s]etting. + */ + buck10_desc->ops = &bd72720_buck10_ldon_head_op; + + ldon_val = ldon_head / 50000 + 1; + if (ldon_head > 300000) { + dev_warn(dev, "Unsupported LDON_HEAD, clamping to 300 mV\n"); + ldon_val = 7; + } + + return regmap_update_bits(regmap, BD72720_REG_LDO1_MODE2, + BD72720_MASK_LDON_HEAD, ldon_val); +} + +static int bd72720_dt_parse(struct device *dev, + struct regulator_desc *buck10_desc, + struct regmap *regmap) +{ + struct device_node *nproot __free(device_node) = + of_get_child_by_name(dev->parent->of_node, "regulators"); + + if (!nproot) { + dev_err(dev, "failed to find regulators node\n"); + return -ENODEV; + } + + return bd72720_buck10_ldon_head_mode(dev, nproot, regmap, buck10_desc); +} + static int bd71828_probe(struct platform_device *pdev) { - int i, j, ret; + int i, j, ret, num_regulators; struct regulator_config config = { .dev = pdev->dev.parent, }; + enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data; + struct bd71828_regulator_data *rdata; config.regmap = dev_get_regmap(pdev->dev.parent, NULL); if (!config.regmap) return -ENODEV; - for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) { - struct regulator_dev *rdev; - const struct bd71828_regulator_data *rd; + switch (chip) { + case ROHM_CHIP_TYPE_BD72720: + rdata = devm_kmemdup(&pdev->dev, bd72720_rdata, + sizeof(bd72720_rdata), GFP_KERNEL); + if (!rdata) + return -ENOMEM; - rd = &bd71828_rdata[i]; + ret = bd72720_dt_parse(&pdev->dev, &rdata[BD72720_BUCK10_DESC_INDEX].desc, + config.regmap); + if (ret) + return ret; + + num_regulators = ARRAY_SIZE(bd72720_rdata); + break; + + case ROHM_CHIP_TYPE_BD71828: + rdata = devm_kmemdup(&pdev->dev, bd71828_rdata, + sizeof(bd71828_rdata), GFP_KERNEL); + if (!rdata) + return -ENOMEM; + + num_regulators = ARRAY_SIZE(bd71828_rdata); + + break; + default: + return dev_err_probe(&pdev->dev, -EINVAL, + "Unsupported device\n"); + } + + for (i = 0; i < num_regulators; i++) { + struct regulator_dev *rdev; + struct bd71828_regulator_data *rd; + + rd = &rdata[i]; + + config.driver_data = rd; rdev = devm_regulator_register(&pdev->dev, &rd->desc, &config); if (IS_ERR(rdev)) @@ -714,12 +1690,20 @@ static int bd71828_probe(struct platform_device *pdev) return 0; } +static const struct platform_device_id bd71828_pmic_id[] = { + { "bd71828-pmic", ROHM_CHIP_TYPE_BD71828 }, + { "bd72720-pmic", ROHM_CHIP_TYPE_BD72720 }, + { }, +}; +MODULE_DEVICE_TABLE(platform, bd71828_pmic_id); + static struct platform_driver bd71828_regulator = { .driver = { .name = "bd71828-pmic", .probe_type = PROBE_PREFER_ASYNCHRONOUS, }, .probe = bd71828_probe, + .id_table = bd71828_pmic_id, }; module_platform_driver(bd71828_regulator); @@ -727,4 +1711,3 @@ module_platform_driver(bd71828_regulator); MODULE_AUTHOR("Matti Vaittinen "); MODULE_DESCRIPTION("BD71828 voltage regulator driver"); MODULE_LICENSE("GPL"); -MODULE_ALIAS("platform:bd71828-pmic"); From 6b367741e01430947f66ad863bfc1e57ad42b7bc Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:20:24 +0200 Subject: [PATCH 37/59] gpio: Support ROHM BD72720 gpios The ROHM BD72720 has 6 pins which may be configured as GPIOs. The GPIO1 ... GPIO5 and EPDEN pins. The configuration is done to OTP at the manufacturing, and it can't be read at runtime. The device-tree is required to tell the software which of the pins are used as GPIOs. Keep the pin mapping static regardless the OTP. This way the user-space can always access the BASE+N for GPIO(N+1) (N = 0 to 4), and BASE + 5 for the EPDEN pin. Do this by setting always the number of GPIOs to 6, and by using the valid-mask to invalidate the pins which aren't configured as GPIOs. First two pins can be set to be either input or output by OTP. Direction can't be changed by software. Rest of the pins can be set as outputs only. All of the pins support generating interrupts. Support the Input/Output state getting/setting and the output mode configuration (open-drain/push-pull). Signed-off-by: Matti Vaittinen Reviewed-by: Linus Walleij Acked-by: Bartosz Golaszewski Link: https://patch.msgid.link/22e095ca92f0677ca3d3a768ad749629fc3c2006.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/gpio/Kconfig | 9 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-bd72720.c | 281 ++++++++++++++++++++++++++++++++++++ 3 files changed, 291 insertions(+) create mode 100644 drivers/gpio/gpio-bd72720.c diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index bd185482a7fd..6b4df4db2f04 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -1317,6 +1317,15 @@ config GPIO_BD71828 This driver can also be built as a module. If so, the module will be called gpio-bd71828. +config GPIO_BD72720 + tristate "ROHM BD72720 and BD73900 PMIC GPIO support" + depends on MFD_ROHM_BD71828 + help + Support for GPIO on ROHM BD72720 and BD73900 PMICs. There are two + pins which can be configured to GPI or GPO, and three pins which can + be configured to GPO on the ROHM PMIC. The pin configuration is done + on OTP at manufacturing. + config GPIO_BD9571MWV tristate "ROHM BD9571 GPIO support" depends on MFD_BD9571MWV diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index 2421a8fd3733..e1d4c1ddd4d8 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -46,6 +46,7 @@ obj-$(CONFIG_GPIO_BCM_KONA) += gpio-bcm-kona.o obj-$(CONFIG_GPIO_BCM_XGS_IPROC) += gpio-xgs-iproc.o obj-$(CONFIG_GPIO_BD71815) += gpio-bd71815.o obj-$(CONFIG_GPIO_BD71828) += gpio-bd71828.o +obj-$(CONFIG_GPIO_BD72720) += gpio-bd72720.o obj-$(CONFIG_GPIO_BD9571MWV) += gpio-bd9571mwv.o obj-$(CONFIG_GPIO_BLZP1600) += gpio-blzp1600.o obj-$(CONFIG_GPIO_BRCMSTB) += gpio-brcmstb.o diff --git a/drivers/gpio/gpio-bd72720.c b/drivers/gpio/gpio-bd72720.c new file mode 100644 index 000000000000..6549dbf4c7ad --- /dev/null +++ b/drivers/gpio/gpio-bd72720.c @@ -0,0 +1,281 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Support to GPIOs on ROHM BD72720 and BD79300 + * Copyright 2025 ROHM Semiconductors. + * Author: Matti Vaittinen + */ + +#include +#include +#include +#include +#include +#include +#include + +#define BD72720_GPIO_OPEN_DRAIN 0 +#define BD72720_GPIO_CMOS BIT(1) +#define BD72720_INT_GPIO1_IN_SRC 4 +/* + * The BD72720 has several "one time programmable" (OTP) configurations which + * can be set at manufacturing phase. A set of these options allow using pins + * as GPIO. The OTP configuration can't be read at run-time, so drivers rely on + * device-tree to advertise the correct options. + * + * Both DVS[0,1] pins can be configured to be used for: + * - OTP0: regulator RUN state control + * - OTP1: GPI + * - OTP2: GPO + * - OTP3: Power sequencer output + * Data-sheet also states that these PINs can always be used for IRQ but the + * driver limits this by allowing them to be used for IRQs with OTP1 only. + * + * Pins GPIO_EXTEN0 (GPIO3), GPIO_EXTEN1 (GPIO4), GPIO_FAULT_B (GPIO5) have OTP + * options for a specific (non GPIO) purposes, but also an option to configure + * them to be used as a GPO. + * + * OTP settings can be separately configured for each pin. + * + * DT properties: + * "rohm,pin-dvs0" and "rohm,pin-dvs1" can be set to one of the values: + * "dvs-input", "gpi", "gpo". + * + * "rohm,pin-exten0", "rohm,pin-exten1" and "rohm,pin-fault_b" can be set to: + * "gpo" + */ + +enum bd72720_gpio_state { + BD72720_PIN_UNKNOWN, + BD72720_PIN_GPI, + BD72720_PIN_GPO, +}; + +enum { + BD72720_GPIO1, + BD72720_GPIO2, + BD72720_GPIO3, + BD72720_GPIO4, + BD72720_GPIO5, + BD72720_GPIO_EPDEN, + BD72720_NUM_GPIOS +}; + +struct bd72720_gpio { + /* chip.parent points the MFD which provides DT node and regmap */ + struct gpio_chip chip; + /* dev points to the platform device for devm and prints */ + struct device *dev; + struct regmap *regmap; + int gpio_is_input; +}; + +static int bd72720gpi_get(struct bd72720_gpio *bdgpio, unsigned int reg_offset) +{ + int ret, val, shift; + + ret = regmap_read(bdgpio->regmap, BD72720_REG_INT_ETC1_SRC, &val); + if (ret) + return ret; + + shift = BD72720_INT_GPIO1_IN_SRC + reg_offset; + + return (val >> shift) & 1; +} + +static int bd72720gpo_get(struct bd72720_gpio *bdgpio, + unsigned int offset) +{ + const int regs[] = { BD72720_REG_GPIO1_CTRL, BD72720_REG_GPIO2_CTRL, + BD72720_REG_GPIO3_CTRL, BD72720_REG_GPIO4_CTRL, + BD72720_REG_GPIO5_CTRL, BD72720_REG_EPDEN_CTRL }; + int ret, val; + + ret = regmap_read(bdgpio->regmap, regs[offset], &val); + if (ret) + return ret; + + return val & BD72720_GPIO_HIGH; +} + +static int bd72720gpio_get(struct gpio_chip *chip, unsigned int offset) +{ + struct bd72720_gpio *bdgpio = gpiochip_get_data(chip); + + if (BIT(offset) & bdgpio->gpio_is_input) + return bd72720gpi_get(bdgpio, offset); + + return bd72720gpo_get(bdgpio, offset); +} + +static int bd72720gpo_set(struct gpio_chip *chip, unsigned int offset, + int value) +{ + struct bd72720_gpio *bdgpio = gpiochip_get_data(chip); + const int regs[] = { BD72720_REG_GPIO1_CTRL, BD72720_REG_GPIO2_CTRL, + BD72720_REG_GPIO3_CTRL, BD72720_REG_GPIO4_CTRL, + BD72720_REG_GPIO5_CTRL, BD72720_REG_EPDEN_CTRL }; + + if (BIT(offset) & bdgpio->gpio_is_input) { + dev_dbg(bdgpio->dev, "pin %d not output.\n", offset); + return -EINVAL; + } + + if (value) + return regmap_set_bits(bdgpio->regmap, regs[offset], + BD72720_GPIO_HIGH); + + return regmap_clear_bits(bdgpio->regmap, regs[offset], + BD72720_GPIO_HIGH); +} + +static int bd72720_gpio_set_config(struct gpio_chip *chip, unsigned int offset, + unsigned long config) +{ + struct bd72720_gpio *bdgpio = gpiochip_get_data(chip); + const int regs[] = { BD72720_REG_GPIO1_CTRL, BD72720_REG_GPIO2_CTRL, + BD72720_REG_GPIO3_CTRL, BD72720_REG_GPIO4_CTRL, + BD72720_REG_GPIO5_CTRL, BD72720_REG_EPDEN_CTRL }; + + /* + * We can only set the output mode, which makes sense only when output + * OTP configuration is used. + */ + if (BIT(offset) & bdgpio->gpio_is_input) + return -ENOTSUPP; + + switch (pinconf_to_config_param(config)) { + case PIN_CONFIG_DRIVE_OPEN_DRAIN: + return regmap_update_bits(bdgpio->regmap, + regs[offset], + BD72720_GPIO_DRIVE_MASK, + BD72720_GPIO_OPEN_DRAIN); + case PIN_CONFIG_DRIVE_PUSH_PULL: + return regmap_update_bits(bdgpio->regmap, + regs[offset], + BD72720_GPIO_DRIVE_MASK, + BD72720_GPIO_CMOS); + default: + break; + } + + return -ENOTSUPP; +} + +static int bd72720gpo_direction_get(struct gpio_chip *chip, + unsigned int offset) +{ + struct bd72720_gpio *bdgpio = gpiochip_get_data(chip); + + if (BIT(offset) & bdgpio->gpio_is_input) + return GPIO_LINE_DIRECTION_IN; + + return GPIO_LINE_DIRECTION_OUT; +} + +static int bd72720_valid_mask(struct gpio_chip *gc, + unsigned long *valid_mask, + unsigned int ngpios) +{ + static const char * const properties[] = { + "rohm,pin-dvs0", "rohm,pin-dvs1", "rohm,pin-exten0", + "rohm,pin-exten1", "rohm,pin-fault_b" + }; + struct bd72720_gpio *g = gpiochip_get_data(gc); + const char *val; + int i, ret; + + *valid_mask = BIT(BD72720_GPIO_EPDEN); + + if (!gc->parent) + return 0; + + for (i = 0; i < ARRAY_SIZE(properties); i++) { + ret = fwnode_property_read_string(dev_fwnode(gc->parent), + properties[i], &val); + + if (ret) { + if (ret == -EINVAL) + continue; + + dev_err(g->dev, "pin %d (%s), bad configuration\n", i, + properties[i]); + + return ret; + } + + if (strcmp(val, "gpi") == 0) { + if (i != BD72720_GPIO1 && i != BD72720_GPIO2) { + dev_warn(g->dev, + "pin %d (%s) does not support INPUT mode", + i, properties[i]); + continue; + } + + *valid_mask |= BIT(i); + g->gpio_is_input |= BIT(i); + } else if (strcmp(val, "gpo") == 0) { + *valid_mask |= BIT(i); + } + } + + return 0; +} + +/* Template for GPIO chip */ +static const struct gpio_chip bd72720gpo_chip = { + .label = "bd72720", + .owner = THIS_MODULE, + .get = bd72720gpio_get, + .get_direction = bd72720gpo_direction_get, + .set = bd72720gpo_set, + .set_config = bd72720_gpio_set_config, + .init_valid_mask = bd72720_valid_mask, + .can_sleep = true, + .ngpio = BD72720_NUM_GPIOS, + .base = -1, +}; + +static int gpo_bd72720_probe(struct platform_device *pdev) +{ + struct bd72720_gpio *g; + struct device *parent, *dev; + + /* + * Bind devm lifetime to this platform device => use dev for devm. + * also the prints should originate from this device. + */ + dev = &pdev->dev; + /* The device-tree and regmap come from MFD => use parent for that */ + parent = dev->parent; + + g = devm_kzalloc(dev, sizeof(*g), GFP_KERNEL); + if (!g) + return -ENOMEM; + + g->chip = bd72720gpo_chip; + g->dev = dev; + g->chip.parent = parent; + g->regmap = dev_get_regmap(parent, NULL); + + return devm_gpiochip_add_data(dev, &g->chip, g); +} + +static const struct platform_device_id bd72720_gpio_id[] = { + { "bd72720-gpio" }, + { }, +}; +MODULE_DEVICE_TABLE(platform, bd72720_gpio_id); + +static struct platform_driver gpo_bd72720_driver = { + .driver = { + .name = "bd72720-gpio", + .probe_type = PROBE_PREFER_ASYNCHRONOUS, + }, + .probe = gpo_bd72720_probe, + .id_table = bd72720_gpio_id, +}; +module_platform_driver(gpo_bd72720_driver); + +MODULE_AUTHOR("Matti Vaittinen "); +MODULE_DESCRIPTION("GPIO interface for BD72720 and BD73900"); +MODULE_LICENSE("GPL"); From da4950b5911197813e62b2347caf3bd525cb35a2 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:20:37 +0200 Subject: [PATCH 38/59] clk: clk-bd718x7: Support BD72720 clk gate The BD72720 has similar simple clk gate as a few other ROHM PMICs. Add support for BD72720 clk gate. Signed-off-by: Matti Vaittinen Acked-by: Stephen Boyd Link: https://patch.msgid.link/742e76cd0b87e726818d4fddc534a29298697b6b.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/clk/Kconfig | 4 ++-- drivers/clk/clk-bd718x7.c | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index 3a1611008e48..619bd63a3c77 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -475,8 +475,8 @@ config COMMON_CLK_BD718XX tristate "Clock driver for 32K clk gates on ROHM PMICs" depends on MFD_ROHM_BD718XX || MFD_ROHM_BD71828 help - This driver supports ROHM BD71837, BD71847, BD71850, BD71815 - and BD71828 PMICs clock gates. + This driver supports ROHM BD71837, BD71847, BD71850, BD71815, + BD71828, and BD72720 PMICs clock gates. config COMMON_CLK_FIXED_MMIO bool "Clock driver for Memory Mapped Fixed values" diff --git a/drivers/clk/clk-bd718x7.c b/drivers/clk/clk-bd718x7.c index ac40b669d60b..1cae974e6d1d 100644 --- a/drivers/clk/clk-bd718x7.c +++ b/drivers/clk/clk-bd718x7.c @@ -19,7 +19,8 @@ #define BD71828_REG_OUT32K 0x4B /* BD71837 and BD71847 */ #define BD718XX_REG_OUT32K 0x2E - +/* BD72720 */ +#define BD72720_REG_OUT32K 0x9a /* * BD71837, BD71847, and BD71828 all use bit [0] to clk output control */ @@ -118,6 +119,10 @@ static int bd71837_clk_probe(struct platform_device *pdev) c->reg = BD71815_REG_OUT32K; c->mask = CLK_OUT_EN_MASK; break; + case ROHM_CHIP_TYPE_BD72720: + c->reg = BD72720_REG_OUT32K; + c->mask = CLK_OUT_EN_MASK; + break; default: dev_err(&pdev->dev, "Unknown clk chip\n"); return -EINVAL; @@ -146,6 +151,7 @@ static const struct platform_device_id bd718x7_clk_id[] = { { "bd71847-clk", ROHM_CHIP_TYPE_BD71847 }, { "bd71828-clk", ROHM_CHIP_TYPE_BD71828 }, { "bd71815-clk", ROHM_CHIP_TYPE_BD71815 }, + { "bd72720-clk", ROHM_CHIP_TYPE_BD72720 }, { }, }; MODULE_DEVICE_TABLE(platform, bd718x7_clk_id); @@ -161,6 +167,6 @@ static struct platform_driver bd71837_clk = { module_platform_driver(bd71837_clk); MODULE_AUTHOR("Matti Vaittinen "); -MODULE_DESCRIPTION("BD718(15/18/28/37/47/50) and chip clk driver"); +MODULE_DESCRIPTION("BD718(15/18/28/37/47/50) and BD72720 chip clk driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:bd718xx-clk"); From 0234e0033e62c1043b602e699580c843c4457486 Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:20:50 +0200 Subject: [PATCH 39/59] rtc: bd70528: Support BD72720 rtc The BD72720 has similar RTC block as a few other ROHM PMICs. Add support for BD72720 RTC. Signed-off-by: Matti Vaittinen Acked-by: Alexandre Belloni Link: https://patch.msgid.link/3241773f0f8e8d8e591a8e948495686cfdee4875.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/rtc/Kconfig | 3 ++- drivers/rtc/rtc-bd70528.c | 21 ++++++++++++++------- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index 50dc779f7f98..7ac18985e438 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -570,7 +570,8 @@ config RTC_DRV_BD70528 depends on MFD_ROHM_BD71828 help If you say Y here you will get support for the RTC - block on ROHM BD71815 and BD71828 Power Management IC. + block on ROHM BD71815, BD71828 and BD72720 Power + Management ICs. This driver can also be built as a module. If so, the module will be called rtc-bd70528. diff --git a/drivers/rtc/rtc-bd70528.c b/drivers/rtc/rtc-bd70528.c index 954ac4ef53e8..4c8599761b2e 100644 --- a/drivers/rtc/rtc-bd70528.c +++ b/drivers/rtc/rtc-bd70528.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -262,13 +263,13 @@ static int bd70528_probe(struct platform_device *pdev) /* * See also BD718XX_ALM_EN_OFFSET: - * This works for BD71828 and BD71815 as they have same offset - * between ALM0 start and ALM0_MASK. If new ICs are to be - * added this requires proper check as ALM0_MASK is not located - * at the end of ALM0 block - but after all ALM blocks so if - * amount of ALMs differ the offset to enable/disable is likely - * to be incorrect and enable/disable must be given as own - * reg address here. + * This works for BD71828, BD71815, and BD72720 as they all + * have same offset between the ALM0 start and the ALM0_MASK. + * If new ICs are to be added this requires proper check as + * the ALM0_MASK is not located at the end of ALM0 block - + * but after all ALM blocks. If amount of ALMs differ, the + * offset to enable/disable is likely to be incorrect and + * enable/disable must be given as own reg address here. */ bd_rtc->bd718xx_alm_block_start = BD71815_REG_RTC_ALM_START; hour_reg = BD71815_REG_HOUR; @@ -278,6 +279,11 @@ static int bd70528_probe(struct platform_device *pdev) bd_rtc->bd718xx_alm_block_start = BD71828_REG_RTC_ALM_START; hour_reg = BD71828_REG_RTC_HOUR; break; + case ROHM_CHIP_TYPE_BD72720: + bd_rtc->reg_time_start = BD72720_REG_RTC_START; + bd_rtc->bd718xx_alm_block_start = BD72720_REG_RTC_ALM_START; + hour_reg = BD72720_REG_RTC_HOUR; + break; default: dev_err(&pdev->dev, "Unknown chip\n"); return -ENOENT; @@ -337,6 +343,7 @@ static int bd70528_probe(struct platform_device *pdev) static const struct platform_device_id bd718x7_rtc_id[] = { { "bd71828-rtc", ROHM_CHIP_TYPE_BD71828 }, { "bd71815-rtc", ROHM_CHIP_TYPE_BD71815 }, + { "bd72720-rtc", ROHM_CHIP_TYPE_BD72720 }, { }, }; MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id); From de8f20afb00469c4fc0bb4191cdef7a95c2f847e Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:21:03 +0200 Subject: [PATCH 40/59] power: supply: bd71828: Support wider register addresses The BD71828 power-supply driver assumes register addresses to be 8-bit. The new BD72720 will use stacked register maps to hide paging which is done using secondary I2C slave address. This requires use of 9-bit register addresses in the power-supply driver (added offset 0x100 to the 8-bit hardware register addresses). The cost is slightly used memory consumption as the members in the struct pwr_regs will be changed from u8 to unsigned int, which means 3 byte increase / member / instance. This is currently 14 members (expected to possibly be increased when adding new variants / new functionality which may introduce new registers, but not expected to grow much) and 2 instances (will be 3 instances when BD72720 gets added). So, even if the number of registers grew to 50 it'd be 150 bytes / instance. Assuming we eventually supported 5 variants, it'd be 5 * 150 bytes, which stays very reasonable considering systems we are dealing with. As a side note, we can reduce the "wasted space / member / instance" from 3 bytes to 1 byte, by using u16 instead of the unsigned int if needed. I rather use unsigned int to be initially prepared for devices with 32 bit registers if there is no need to count bytes. Signed-off-by: Matti Vaittinen Reviewed-by: Sebastian Reichel Link: https://patch.msgid.link/57c87f7e2082a666f0adeafcd11f673c0af7d326.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/power/supply/bd71828-power.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/drivers/power/supply/bd71828-power.c b/drivers/power/supply/bd71828-power.c index f667baedeb77..ce73c0f48397 100644 --- a/drivers/power/supply/bd71828-power.c +++ b/drivers/power/supply/bd71828-power.c @@ -44,19 +44,19 @@ #define VBAT_LOW_TH 0x00D4 struct pwr_regs { - u8 vbat_avg; - u8 ibat; - u8 ibat_avg; - u8 btemp_vth; - u8 chg_state; - u8 bat_temp; - u8 dcin_stat; - u8 dcin_collapse_limit; - u8 chg_set1; - u8 chg_en; - u8 vbat_alm_limit_u; - u8 conf; - u8 vdcin; + unsigned int vbat_avg; + unsigned int ibat; + unsigned int ibat_avg; + unsigned int btemp_vth; + unsigned int chg_state; + unsigned int bat_temp; + unsigned int dcin_stat; + unsigned int dcin_collapse_limit; + unsigned int chg_set1; + unsigned int chg_en; + unsigned int vbat_alm_limit_u; + unsigned int conf; + unsigned int vdcin; }; static const struct pwr_regs pwr_regs_bd71828 = { From bcb5bb59b83642bb242aaf6b018bebb1325a50ba Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:21:19 +0200 Subject: [PATCH 41/59] power: supply: bd71828-power: Support ROHM BD72720 The ROHM BD72720 is a power management IC with a charger and coulomb counter block which is closely related to the charger / coulomb counter found from the BD71815, BD71828, BD71879 which are all supported by the bd71828-power driver. Due to the similarities it makes sense to support also the BD72720 with the same driver. Add basic support for the charger logic on ROHM BD72720. Signed-off-by: Matti Vaittinen Link: https://patch.msgid.link/fb74c0cab3dfe534135d26dbbb9c66699678c2de.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- drivers/power/supply/bd71828-power.c | 134 +++++++++++++++++++++++---- 1 file changed, 116 insertions(+), 18 deletions(-) diff --git a/drivers/power/supply/bd71828-power.c b/drivers/power/supply/bd71828-power.c index ce73c0f48397..438e220a9cb7 100644 --- a/drivers/power/supply/bd71828-power.c +++ b/drivers/power/supply/bd71828-power.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -51,12 +52,14 @@ struct pwr_regs { unsigned int chg_state; unsigned int bat_temp; unsigned int dcin_stat; + unsigned int dcin_online_mask; unsigned int dcin_collapse_limit; unsigned int chg_set1; unsigned int chg_en; unsigned int vbat_alm_limit_u; unsigned int conf; unsigned int vdcin; + unsigned int vdcin_himask; }; static const struct pwr_regs pwr_regs_bd71828 = { @@ -67,12 +70,14 @@ static const struct pwr_regs pwr_regs_bd71828 = { .chg_state = BD71828_REG_CHG_STATE, .bat_temp = BD71828_REG_BAT_TEMP, .dcin_stat = BD71828_REG_DCIN_STAT, + .dcin_online_mask = BD7182x_MASK_DCIN_DET, .dcin_collapse_limit = BD71828_REG_DCIN_CLPS, .chg_set1 = BD71828_REG_CHG_SET1, .chg_en = BD71828_REG_CHG_EN, .vbat_alm_limit_u = BD71828_REG_ALM_VBAT_LIMIT_U, .conf = BD71828_REG_CONF, .vdcin = BD71828_REG_VDCIN_U, + .vdcin_himask = BD7182x_MASK_VDCIN_U, }; static const struct pwr_regs pwr_regs_bd71815 = { @@ -85,6 +90,7 @@ static const struct pwr_regs pwr_regs_bd71815 = { .chg_state = BD71815_REG_CHG_STATE, .bat_temp = BD71815_REG_BAT_TEMP, .dcin_stat = BD71815_REG_DCIN_STAT, + .dcin_online_mask = BD7182x_MASK_DCIN_DET, .dcin_collapse_limit = BD71815_REG_DCIN_CLPS, .chg_set1 = BD71815_REG_CHG_SET1, .chg_en = BD71815_REG_CHG_SET1, @@ -92,6 +98,31 @@ static const struct pwr_regs pwr_regs_bd71815 = { .conf = BD71815_REG_CONF, .vdcin = BD71815_REG_VM_DCIN_U, + .vdcin_himask = BD7182x_MASK_VDCIN_U, +}; + +static struct pwr_regs pwr_regs_bd72720 = { + .vbat_avg = BD72720_REG_VM_SA_VBAT_U, + .ibat = BD72720_REG_CC_CURCD_U, + .ibat_avg = BD72720_REG_CC_SA_CURCD_U, + .btemp_vth = BD72720_REG_VM_BTMP_U, + /* + * Note, state 0x40 IMP_CHK. not documented + * on other variants but was still handled in + * existing code. No memory traces as to why. + */ + .chg_state = BD72720_REG_CHG_STATE, + .bat_temp = BD72720_REG_CHG_BAT_TEMP_STAT, + .dcin_stat = BD72720_REG_INT_VBUS_SRC, + .dcin_online_mask = BD72720_MASK_DCIN_DET, + .dcin_collapse_limit = -1, /* Automatic. Setting not supported */ + .chg_set1 = BD72720_REG_CHG_SET_1, + .chg_en = BD72720_REG_CHG_EN, + /* 15mV note in data-sheet */ + .vbat_alm_limit_u = BD72720_REG_ALM_VBAT_TH_U, + .conf = BD72720_REG_CONF, /* o XSTB, only PON. Seprate slave addr */ + .vdcin = BD72720_REG_VM_VBUS_U, /* 10 bits not 11 as with other ICs */ + .vdcin_himask = BD72720_MASK_VDCIN_U, }; struct bd71828_power { @@ -298,7 +329,7 @@ static int get_chg_online(struct bd71828_power *pwr, int *chg_online) dev_err(pwr->dev, "Failed to read DCIN status\n"); return ret; } - *chg_online = ((r & BD7182x_MASK_DCIN_DET) != 0); + *chg_online = ((r & pwr->regs->dcin_online_mask) != 0); return 0; } @@ -329,8 +360,8 @@ static int bd71828_bat_inserted(struct bd71828_power *pwr) ret = val & BD7182x_MASK_CONF_PON; if (ret) - regmap_update_bits(pwr->regmap, pwr->regs->conf, - BD7182x_MASK_CONF_PON, 0); + if (regmap_update_bits(pwr->regmap, pwr->regs->conf, BD7182x_MASK_CONF_PON, 0)) + dev_err(pwr->dev, "Failed to write CONF register\n"); return ret; } @@ -358,11 +389,13 @@ static int bd71828_init_hardware(struct bd71828_power *pwr) int ret; /* TODO: Collapse limit should come from device-tree ? */ - ret = regmap_write(pwr->regmap, pwr->regs->dcin_collapse_limit, - BD7182x_DCIN_COLLAPSE_DEFAULT); - if (ret) { - dev_err(pwr->dev, "Failed to write DCIN collapse limit\n"); - return ret; + if (pwr->regs->dcin_collapse_limit != (unsigned int)-1) { + ret = regmap_write(pwr->regmap, pwr->regs->dcin_collapse_limit, + BD7182x_DCIN_COLLAPSE_DEFAULT); + if (ret) { + dev_err(pwr->dev, "Failed to write DCIN collapse limit\n"); + return ret; + } } ret = pwr->bat_inserted(pwr); @@ -419,7 +452,7 @@ static int bd71828_charger_get_property(struct power_supply *psy, break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: ret = bd7182x_read16_himask(pwr, pwr->regs->vdcin, - BD7182x_MASK_VDCIN_U, &tmp); + pwr->regs->vdcin_himask, &tmp); if (ret) return ret; @@ -630,6 +663,9 @@ BD_ISR_AC(dcin_ovp_det, "DCIN OVER VOLTAGE", true) BD_ISR_DUMMY(dcin_mon_det, "DCIN voltage below threshold") BD_ISR_DUMMY(dcin_mon_res, "DCIN voltage above threshold") +BD_ISR_DUMMY(vbus_curr_limit, "VBUS current limited") +BD_ISR_DUMMY(vsys_ov_res, "VSYS over-voltage cleared") +BD_ISR_DUMMY(vsys_ov_det, "VSYS over-voltage") BD_ISR_DUMMY(vsys_uv_res, "VSYS under-voltage cleared") BD_ISR_DUMMY(vsys_uv_det, "VSYS under-voltage") BD_ISR_DUMMY(vsys_low_res, "'VSYS low' cleared") @@ -878,6 +914,51 @@ static int bd7182x_get_irqs(struct platform_device *pdev, BDIRQ("bd71828-temp-125-over", bd71828_temp_vf125_det), BDIRQ("bd71828-temp-125-under", bd71828_temp_vf125_res), }; + static const struct bd7182x_irq_res bd72720_irqs[] = { + BDIRQ("bd72720_int_vbus_rmv", BD_ISR_NAME(dcin_removed)), + BDIRQ("bd72720_int_vbus_det", bd7182x_dcin_detected), + BDIRQ("bd72720_int_vbus_mon_res", BD_ISR_NAME(dcin_mon_res)), + BDIRQ("bd72720_int_vbus_mon_det", BD_ISR_NAME(dcin_mon_det)), + BDIRQ("bd72720_int_vsys_mon_res", BD_ISR_NAME(vsys_mon_res)), + BDIRQ("bd72720_int_vsys_mon_det", BD_ISR_NAME(vsys_mon_det)), + BDIRQ("bd72720_int_vsys_uv_res", BD_ISR_NAME(vsys_uv_res)), + BDIRQ("bd72720_int_vsys_uv_det", BD_ISR_NAME(vsys_uv_det)), + BDIRQ("bd72720_int_vsys_lo_res", BD_ISR_NAME(vsys_low_res)), + BDIRQ("bd72720_int_vsys_lo_det", BD_ISR_NAME(vsys_low_det)), + BDIRQ("bd72720_int_vsys_ov_res", BD_ISR_NAME(vsys_ov_res)), + BDIRQ("bd72720_int_vsys_ov_det", BD_ISR_NAME(vsys_ov_det)), + BDIRQ("bd72720_int_bat_ilim", BD_ISR_NAME(vbus_curr_limit)), + BDIRQ("bd72720_int_chg_done", bd718x7_chg_done), + BDIRQ("bd72720_int_extemp_tout", BD_ISR_NAME(chg_wdg_temp)), + BDIRQ("bd72720_int_chg_wdt_exp", BD_ISR_NAME(chg_wdg)), + BDIRQ("bd72720_int_bat_mnt_out", BD_ISR_NAME(rechg_res)), + BDIRQ("bd72720_int_bat_mnt_in", BD_ISR_NAME(rechg_det)), + BDIRQ("bd72720_int_chg_trns", BD_ISR_NAME(chg_state_changed)), + + BDIRQ("bd72720_int_vbat_mon_res", BD_ISR_NAME(bat_mon_res)), + BDIRQ("bd72720_int_vbat_mon_det", BD_ISR_NAME(bat_mon)), + BDIRQ("bd72720_int_vbat_sht_res", BD_ISR_NAME(bat_short_res)), + BDIRQ("bd72720_int_vbat_sht_det", BD_ISR_NAME(bat_short)), + BDIRQ("bd72720_int_vbat_lo_res", BD_ISR_NAME(bat_low_res)), + BDIRQ("bd72720_int_vbat_lo_det", BD_ISR_NAME(bat_low)), + BDIRQ("bd72720_int_vbat_ov_res", BD_ISR_NAME(bat_ov_res)), + BDIRQ("bd72720_int_vbat_ov_det", BD_ISR_NAME(bat_ov)), + BDIRQ("bd72720_int_bat_rmv", BD_ISR_NAME(bat_removed)), + BDIRQ("bd72720_int_bat_det", BD_ISR_NAME(bat_det)), + BDIRQ("bd72720_int_dbat_det", BD_ISR_NAME(bat_dead)), + BDIRQ("bd72720_int_bat_temp_trns", BD_ISR_NAME(temp_transit)), + BDIRQ("bd72720_int_lobtmp_res", BD_ISR_NAME(temp_bat_low_res)), + BDIRQ("bd72720_int_lobtmp_det", BD_ISR_NAME(temp_bat_low)), + BDIRQ("bd72720_int_ovbtmp_res", BD_ISR_NAME(temp_bat_hi_res)), + BDIRQ("bd72720_int_ovbtmp_det", BD_ISR_NAME(temp_bat_hi)), + BDIRQ("bd72720_int_ocur1_res", BD_ISR_NAME(bat_oc1_res)), + BDIRQ("bd72720_int_ocur1_det", BD_ISR_NAME(bat_oc1)), + BDIRQ("bd72720_int_ocur2_res", BD_ISR_NAME(bat_oc2_res)), + BDIRQ("bd72720_int_ocur2_det", BD_ISR_NAME(bat_oc2)), + BDIRQ("bd72720_int_ocur3_res", BD_ISR_NAME(bat_oc3_res)), + BDIRQ("bd72720_int_ocur3_det", BD_ISR_NAME(bat_oc3)), + BDIRQ("bd72720_int_cc_mon2_det", BD_ISR_NAME(bat_cc_mon)), + }; int num_irqs; const struct bd7182x_irq_res *irqs; @@ -890,6 +971,10 @@ static int bd7182x_get_irqs(struct platform_device *pdev, irqs = &bd71815_irqs[0]; num_irqs = ARRAY_SIZE(bd71815_irqs); break; + case ROHM_CHIP_TYPE_BD72720: + irqs = &bd72720_irqs[0]; + num_irqs = ARRAY_SIZE(bd72720_irqs); + break; default: return -EINVAL; } @@ -958,21 +1043,27 @@ static int bd71828_power_probe(struct platform_device *pdev) struct power_supply_config ac_cfg = {}; struct power_supply_config bat_cfg = {}; int ret; - struct regmap *regmap; - - regmap = dev_get_regmap(pdev->dev.parent, NULL); - if (!regmap) { - dev_err(&pdev->dev, "No parent regmap\n"); - return -EINVAL; - } pwr = devm_kzalloc(&pdev->dev, sizeof(*pwr), GFP_KERNEL); if (!pwr) return -ENOMEM; - pwr->regmap = regmap; - pwr->dev = &pdev->dev; + /* + * The BD72720 MFD device registers two regmaps. Power-supply driver + * uses the "wrap-map", which provides access to both of the I2C slave + * addresses used by the BD72720 + */ pwr->chip_type = platform_get_device_id(pdev)->driver_data; + if (pwr->chip_type != ROHM_CHIP_TYPE_BD72720) + pwr->regmap = dev_get_regmap(pdev->dev.parent, NULL); + else + pwr->regmap = dev_get_regmap(pdev->dev.parent, "wrap-map"); + if (!pwr->regmap) { + dev_err(&pdev->dev, "No parent regmap\n"); + return -EINVAL; + } + + pwr->dev = &pdev->dev; switch (pwr->chip_type) { case ROHM_CHIP_TYPE_BD71828: @@ -985,6 +1076,12 @@ static int bd71828_power_probe(struct platform_device *pdev) pwr->get_temp = bd71815_get_temp; pwr->regs = &pwr_regs_bd71815; break; + case ROHM_CHIP_TYPE_BD72720: + pwr->bat_inserted = bd71828_bat_inserted; + pwr->regs = &pwr_regs_bd72720; + pwr->get_temp = bd71828_get_temp; + dev_dbg(pwr->dev, "Found ROHM BD72720\n"); + break; default: dev_err(pwr->dev, "Unknown PMIC\n"); return -EINVAL; @@ -1030,6 +1127,7 @@ static int bd71828_power_probe(struct platform_device *pdev) static const struct platform_device_id bd71828_charger_id[] = { { "bd71815-power", ROHM_CHIP_TYPE_BD71815 }, { "bd71828-power", ROHM_CHIP_TYPE_BD71828 }, + { "bd72720-power", ROHM_CHIP_TYPE_BD72720 }, { }, }; MODULE_DEVICE_TABLE(platform, bd71828_charger_id); From e39951f8ad500648b9ab132f8042d6e47da441cf Mon Sep 17 00:00:00 2001 From: Matti Vaittinen Date: Mon, 15 Dec 2025 15:21:37 +0200 Subject: [PATCH 42/59] MAINTAINERS: Add ROHM BD72720 PMIC Add the ROHM BD72720 PMIC driver files to be maintained by undersigned. Signed-off-by: Matti Vaittinen Link: https://patch.msgid.link/5ab04df42d8fddab4c2b0b86414314c6bb815ffd.1765804226.git.mazziesaccount@gmail.com Signed-off-by: Lee Jones --- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 5b11839cba9d..23bf05492d34 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22745,6 +22745,7 @@ S: Supported F: drivers/clk/clk-bd718x7.c F: drivers/gpio/gpio-bd71815.c F: drivers/gpio/gpio-bd71828.c +F: drivers/gpio/gpio-bd72720.c F: drivers/mfd/rohm-bd71828.c F: drivers/mfd/rohm-bd718x7.c F: drivers/mfd/rohm-bd9576.c @@ -22761,6 +22762,7 @@ F: drivers/watchdog/bd96801_wdt.c F: include/linux/mfd/rohm-bd71815.h F: include/linux/mfd/rohm-bd71828.h F: include/linux/mfd/rohm-bd718x7.h +F: include/linux/mfd/rohm-bd72720.h F: include/linux/mfd/rohm-bd957x.h F: include/linux/mfd/rohm-bd96801.h F: include/linux/mfd/rohm-bd96802.h From e05ef046ebb1ca879d885593130fa822ff664ca1 Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Tue, 13 Jan 2026 12:10:52 +0100 Subject: [PATCH 43/59] gpio: pca9570: Use devm_mutex_init() for mutex initialization Use devm_mutex_init() since it brings some benefits when CONFIG_DEBUG_MUTEXES is enabled. Reviewed-by: Linus Walleij Signed-off-by: Andy Shevchenko Link: https://lore.kernel.org/r/20260113111156.188051-2-andriy.shevchenko@linux.intel.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-pca9570.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/drivers/gpio/gpio-pca9570.c b/drivers/gpio/gpio-pca9570.c index c5a1287079a0..eae35135c71e 100644 --- a/drivers/gpio/gpio-pca9570.c +++ b/drivers/gpio/gpio-pca9570.c @@ -115,7 +115,9 @@ out: static int pca9570_probe(struct i2c_client *client) { + struct device *dev = &client->dev; struct pca9570 *gpio; + int ret; gpio = devm_kzalloc(&client->dev, sizeof(*gpio), GFP_KERNEL); if (!gpio) @@ -132,7 +134,9 @@ static int pca9570_probe(struct i2c_client *client) gpio->chip.ngpio = gpio->chip_data->ngpio; gpio->chip.can_sleep = true; - mutex_init(&gpio->lock); + ret = devm_mutex_init(dev, &gpio->lock); + if (ret) + return ret; /* Read the current output level */ pca9570_read(gpio, &gpio->out); From 053578d329e58cca98f084439e14cc2895c82b9c Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Tue, 13 Jan 2026 12:10:53 +0100 Subject: [PATCH 44/59] gpio: pca9570: Don't use "proxy" headers Update header inclusions to follow IWYU (Include What You Use) principle. Note that kernel.h is discouraged to be included as it's written at the top of that file. Reviewed-by: Linus Walleij Signed-off-by: Andy Shevchenko Link: https://lore.kernel.org/r/20260113111156.188051-3-andriy.shevchenko@linux.intel.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-pca9570.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/gpio/gpio-pca9570.c b/drivers/gpio/gpio-pca9570.c index eae35135c71e..a41837f1201b 100644 --- a/drivers/gpio/gpio-pca9570.c +++ b/drivers/gpio/gpio-pca9570.c @@ -9,11 +9,15 @@ * Andrew F. Davis */ +#include +#include +#include #include #include #include #include #include +#include #define SLG7XL45106_GPO_REG 0xDB From 4aa573002ba6884d392dbfce24c3ce057f2dbb6a Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Tue, 13 Jan 2026 12:10:54 +0100 Subject: [PATCH 45/59] gpio: pca9570: use lock guards Shrink the code by a couple lines and improve lock management by using lock guards from cleanup.h. Reviewed-by: Linus Walleij Signed-off-by: Andy Shevchenko Link: https://lore.kernel.org/r/20260113111156.188051-4-andriy.shevchenko@linux.intel.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-pca9570.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/drivers/gpio/gpio-pca9570.c b/drivers/gpio/gpio-pca9570.c index a41837f1201b..4a368803fb03 100644 --- a/drivers/gpio/gpio-pca9570.c +++ b/drivers/gpio/gpio-pca9570.c @@ -10,6 +10,7 @@ */ #include +#include #include #include #include @@ -98,7 +99,7 @@ static int pca9570_set(struct gpio_chip *chip, unsigned int offset, int value) u8 buffer; int ret; - mutex_lock(&gpio->lock); + guard(mutex)(&gpio->lock); buffer = gpio->out; if (value) @@ -108,13 +109,11 @@ static int pca9570_set(struct gpio_chip *chip, unsigned int offset, int value) ret = pca9570_write(gpio, buffer); if (ret) - goto out; + return ret; gpio->out = buffer; -out: - mutex_unlock(&gpio->lock); - return ret; + return 0; } static int pca9570_probe(struct i2c_client *client) From b2b8d247ad8ee1abe860598cae70e2dbe8a09128 Mon Sep 17 00:00:00 2001 From: Stafford Horne Date: Thu, 15 Jan 2026 15:09:57 +0000 Subject: [PATCH 46/59] dt-bindings: gpio-mmio: Correct opencores GPIO In commit f48b5e8bc2e1 ("dt-bindings: gpio-mmio: Add compatible string for opencores,gpio") we marked opencores,gpio to be allowed with brcm,bcm6345-gpio. This was wrong, opencores,gpio is not compatible with brcm,bcm6345-gpio. It has a different register map and is 8-bit vs Broadcom which is 32-bit. Change opencores,gpio to be a separate compatible string for MMIO GPIO. Also, as this change rewrote the entire enum, I took this opportunity to alphabetically sort the list. Fixes: f48b5e8bc2e1 ("dt-bindings: gpio-mmio: Add compatible string for opencores,gpio") Signed-off-by: Stafford Horne Reviewed-by: Geert Uytterhoeven Reviewed-by: Krzysztof Kozlowski Link: https://lore.kernel.org/r/20260115151014.3956805-2-shorne@gmail.com Signed-off-by: Bartosz Golaszewski --- .../devicetree/bindings/gpio/gpio-mmio.yaml | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml b/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml index 7ee40b9bc562..1b2d253b19c1 100644 --- a/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml +++ b/Documentation/devicetree/bindings/gpio/gpio-mmio.yaml @@ -18,16 +18,12 @@ description: properties: compatible: - oneOf: - - enum: - - brcm,bcm6345-gpio - - ni,169445-nand-gpio - - wd,mbl-gpio # Western Digital MyBook Live memory-mapped GPIO controller - - intel,ixp4xx-expansion-bus-mmio-gpio - - items: - - enum: - - opencores,gpio - - const: brcm,bcm6345-gpio + enum: + - brcm,bcm6345-gpio + - intel,ixp4xx-expansion-bus-mmio-gpio + - ni,169445-nand-gpio + - opencores,gpio + - wd,mbl-gpio # Western Digital MyBook Live memory-mapped GPIO controller big-endian: true From 3a6a36a3fc4e18e202eaf6c258553b5a17b91677 Mon Sep 17 00:00:00 2001 From: Stafford Horne Date: Thu, 15 Jan 2026 15:09:58 +0000 Subject: [PATCH 47/59] gpio: mmio: Add compatible for opencores GPIO On FPGA Development boards with GPIOs the OpenRISC architecture uses the opencores gpio verilog rtl. This is compatible with the gpio-mmio. Add the compatible string to allow probing this driver from the devicetree. Link: https://opencores.org/projects/gpio Signed-off-by: Stafford Horne Reviewed-by: Linus Walleij Reviewed-by: Geert Uytterhoeven Link: https://lore.kernel.org/r/20260115151014.3956805-3-shorne@gmail.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-mmio.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpio/gpio-mmio.c b/drivers/gpio/gpio-mmio.c index 5daf962b0323..edbcaad57d00 100644 --- a/drivers/gpio/gpio-mmio.c +++ b/drivers/gpio/gpio-mmio.c @@ -724,6 +724,7 @@ static const struct of_device_id gpio_mmio_of_match[] = { { .compatible = "wd,mbl-gpio" }, { .compatible = "ni,169445-nand-gpio" }, { .compatible = "intel,ixp4xx-expansion-bus-mmio-gpio" }, + { .compatible = "opencores,gpio" }, { } }; MODULE_DEVICE_TABLE(of, gpio_mmio_of_match); From 364713741ca19b8f6a506d073af1deff5b2d124a Mon Sep 17 00:00:00 2001 From: Stefan Kerkmann Date: Mon, 26 Jan 2026 15:27:47 +0100 Subject: [PATCH 48/59] gpiolib: introduce devm_fwnode_gpiod_get_optional() wrapper The helper makes it easier to handle optional GPIOs and simplifies the error handling code. Signed-off-by: Stefan Kerkmann Signed-off-by: Michael Tretter Reviewed-by: Matti Vaittinen Link: https://lore.kernel.org/r/20260126-gpio-devm_fwnode_gpiod_get_optional-v2-1-ec34f8e35077@pengutronix.de Signed-off-by: Bartosz Golaszewski --- include/linux/gpio/consumer.h | 36 +++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h index cafeb7a40ad1..0d8408582918 100644 --- a/include/linux/gpio/consumer.h +++ b/include/linux/gpio/consumer.h @@ -607,6 +607,42 @@ struct gpio_desc *devm_fwnode_gpiod_get(struct device *dev, flags, label); } +/** + * devm_fwnode_gpiod_get_optional - obtain an optional GPIO from firmware node + * @dev: GPIO consumer + * @fwnode: handle of the firmware node + * @con_id: function within the GPIO consumer + * @flags: GPIO initialization flags + * @label: label to attach to the requested GPIO + * + * This function can be used for drivers that get their configuration + * from opaque firmware. + * + * GPIO descriptors returned from this function are automatically disposed on + * driver detach. + * + * Returns: + * The GPIO descriptor corresponding to the optional function @con_id of device + * dev, NULL if no GPIO has been assigned to the requested function, or + * another IS_ERR() code if an error occurred while trying to acquire the GPIO. + */ +static inline +struct gpio_desc *devm_fwnode_gpiod_get_optional(struct device *dev, + struct fwnode_handle *fwnode, + const char *con_id, + enum gpiod_flags flags, + const char *label) +{ + struct gpio_desc *desc; + + desc = devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0, + flags, label); + if (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT) + return NULL; + + return desc; +} + struct acpi_gpio_params { unsigned int crs_entry_index; unsigned short line_index; From 09b174f1a554d69b9f69f3c6c115db12c1f6d29d Mon Sep 17 00:00:00 2001 From: Michael Tretter Date: Mon, 26 Jan 2026 15:27:48 +0100 Subject: [PATCH 49/59] regulator: bd71815: switch to devm_fwnode_gpiod_get_optional Use the devm_fwnode_gpiod_get_optional variant to simplify the error handling code. Reviewed-by: Matti Vaittinen Acked-by: Mark Brown Signed-off-by: Michael Tretter Link: https://lore.kernel.org/r/20260126-gpio-devm_fwnode_gpiod_get_optional-v2-2-ec34f8e35077@pengutronix.de Signed-off-by: Bartosz Golaszewski --- drivers/regulator/bd71815-regulator.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/drivers/regulator/bd71815-regulator.c b/drivers/regulator/bd71815-regulator.c index 8da57a7bb2f1..668714f35464 100644 --- a/drivers/regulator/bd71815-regulator.c +++ b/drivers/regulator/bd71815-regulator.c @@ -571,15 +571,12 @@ static int bd7181x_probe(struct platform_device *pdev) return -ENODEV; } - ldo4_en = devm_fwnode_gpiod_get(&pdev->dev, - dev_fwnode(pdev->dev.parent), - "rohm,vsel", GPIOD_ASIS, "ldo4-en"); - if (IS_ERR(ldo4_en)) { - ret = PTR_ERR(ldo4_en); - if (ret != -ENOENT) - return ret; - ldo4_en = NULL; - } + ldo4_en = devm_fwnode_gpiod_get_optional(&pdev->dev, + dev_fwnode(pdev->dev.parent), + "rohm,vsel", GPIOD_ASIS, + "ldo4-en"); + if (IS_ERR(ldo4_en)) + return PTR_ERR(ldo4_en); /* Disable to go to ship-mode */ ret = regmap_update_bits(regmap, BD71815_REG_PWRCTRL, RESTARTEN, 0); From e18533b023ec7a33488bcf33140ce69bbba2894f Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:26 +0800 Subject: [PATCH 50/59] gpio: aspeed-sgpio: Change the macro to support deferred probe Use module_platform_driver() to replace module_platform_driver_probe(). The former utilizes platform_driver_register(), which allows the driver to defer probing when it doesn't acquire the necessary resources due to probe order. In contrast, the latter uses __platform_driver_probe(), which includes the comment "Note that this is incompatible with deferred probing." Since our SGPIO driver requires access to the clock resource, the former is more suitable. Reviewed-by: Linus Walleij Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-1-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed-sgpio.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c index 7622f9e9f54a..318cd0e39741 100644 --- a/drivers/gpio/gpio-aspeed-sgpio.c +++ b/drivers/gpio/gpio-aspeed-sgpio.c @@ -516,7 +516,7 @@ static const struct of_device_id aspeed_sgpio_of_table[] = { MODULE_DEVICE_TABLE(of, aspeed_sgpio_of_table); -static int __init aspeed_sgpio_probe(struct platform_device *pdev) +static int aspeed_sgpio_probe(struct platform_device *pdev) { u32 nr_gpios, sgpio_freq, sgpio_clk_div, gpio_cnt_regval, pin_mask; const struct aspeed_sgpio_pdata *pdata; @@ -611,11 +611,12 @@ static int __init aspeed_sgpio_probe(struct platform_device *pdev) } static struct platform_driver aspeed_sgpio_driver = { + .probe = aspeed_sgpio_probe, .driver = { .name = KBUILD_MODNAME, .of_match_table = aspeed_sgpio_of_table, }, }; -module_platform_driver_probe(aspeed_sgpio_driver, aspeed_sgpio_probe); +module_platform_driver(aspeed_sgpio_driver); MODULE_DESCRIPTION("Aspeed Serial GPIO Driver"); From 5928e0d1f66112b49869c83ed8f1cc9db3df69e5 Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:27 +0800 Subject: [PATCH 51/59] gpio: aspeed-sgpio: Remove unused bank name field Drops the names array from the bank struct and its initializers, as it is unused in the driver. Reviewed-by: Linus Walleij Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-2-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed-sgpio.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c index 318cd0e39741..a96ed6d8a55d 100644 --- a/drivers/gpio/gpio-aspeed-sgpio.c +++ b/drivers/gpio/gpio-aspeed-sgpio.c @@ -43,7 +43,6 @@ struct aspeed_sgpio_bank { u16 rdata_reg; u16 irq_regs; u16 tolerance_regs; - const char names[4][3]; }; /* @@ -59,28 +58,24 @@ static const struct aspeed_sgpio_bank aspeed_sgpio_banks[] = { .rdata_reg = 0x0070, .irq_regs = 0x0004, .tolerance_regs = 0x0018, - .names = { "A", "B", "C", "D" }, }, { .val_regs = 0x001C, .rdata_reg = 0x0074, .irq_regs = 0x0020, .tolerance_regs = 0x0034, - .names = { "E", "F", "G", "H" }, }, { .val_regs = 0x0038, .rdata_reg = 0x0078, .irq_regs = 0x003C, .tolerance_regs = 0x0050, - .names = { "I", "J", "K", "L" }, }, { .val_regs = 0x0090, .rdata_reg = 0x007C, .irq_regs = 0x0094, .tolerance_regs = 0x00A8, - .names = { "M", "N", "O", "P" }, }, }; From a3d37e0cccf530a1bad377b3503d6af757f532c4 Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:28 +0800 Subject: [PATCH 52/59] gpio: aspeed-sgpio: Create llops to handle hardware access Add low-level operations (llops) to abstract the register access for SGPIO registers. With this abstraction layer, the driver can separate the hardware and software logic, making it easier to extend the driver to support different hardware register layouts. The llops abstraction changes the programming semantics from bitmask-based writes to a value-based interface. Instead of passing a pre-shifted bitmask to the caller, the driver now passes: - the GPIO offset, and - the value to be set (0 or 1), and the llops helpers are responsible for deriving the correct register and bit position internally. As a result, assignments such as: type0 = 1; type1 = 1; type2 = 1; do not represent a behavioral change. They indicate that the bit corresponding to the given GPIO offset should be set, with the actual bit manipulation handled by llops. Reviewed-by: Linus Walleij Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-3-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed-sgpio.c | 222 +++++++++++++++---------------- 1 file changed, 104 insertions(+), 118 deletions(-) diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c index a96ed6d8a55d..33a830ea7d28 100644 --- a/drivers/gpio/gpio-aspeed-sgpio.c +++ b/drivers/gpio/gpio-aspeed-sgpio.c @@ -27,6 +27,7 @@ struct aspeed_sgpio_pdata { const u32 pin_mask; + const struct aspeed_sgpio_llops *llops; }; struct aspeed_sgpio { @@ -36,6 +37,7 @@ struct aspeed_sgpio { raw_spinlock_t lock; void __iomem *base; int irq; + const struct aspeed_sgpio_pdata *pdata; }; struct aspeed_sgpio_bank { @@ -90,6 +92,15 @@ enum aspeed_sgpio_reg { reg_tolerance, }; +struct aspeed_sgpio_llops { + void (*reg_bit_set)(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg, bool val); + bool (*reg_bit_get)(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg); + int (*reg_bank_get)(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg); +}; + #define GPIO_VAL_VALUE 0x00 #define GPIO_IRQ_ENABLE 0x00 #define GPIO_IRQ_TYPE0 0x04 @@ -97,9 +108,9 @@ enum aspeed_sgpio_reg { #define GPIO_IRQ_TYPE2 0x0C #define GPIO_IRQ_STATUS 0x10 -static void __iomem *bank_reg(struct aspeed_sgpio *gpio, - const struct aspeed_sgpio_bank *bank, - const enum aspeed_sgpio_reg reg) +static void __iomem *aspeed_sgpio_g4_bank_reg(struct aspeed_sgpio *gpio, + const struct aspeed_sgpio_bank *bank, + const enum aspeed_sgpio_reg reg) { switch (reg) { case reg_val: @@ -165,14 +176,13 @@ static bool aspeed_sgpio_is_input(unsigned int offset) static int aspeed_sgpio_get(struct gpio_chip *gc, unsigned int offset) { struct aspeed_sgpio *gpio = gpiochip_get_data(gc); - const struct aspeed_sgpio_bank *bank = to_bank(offset); enum aspeed_sgpio_reg reg; int rc = 0; guard(raw_spinlock_irqsave)(&gpio->lock); reg = aspeed_sgpio_is_input(offset) ? reg_val : reg_rdata; - rc = !!(ioread32(bank_reg(gpio, bank, reg)) & GPIO_BIT(offset)); + rc = gpio->pdata->llops->reg_bit_get(gpio, offset, reg); return rc; } @@ -180,26 +190,11 @@ static int aspeed_sgpio_get(struct gpio_chip *gc, unsigned int offset) static int sgpio_set_value(struct gpio_chip *gc, unsigned int offset, int val) { struct aspeed_sgpio *gpio = gpiochip_get_data(gc); - const struct aspeed_sgpio_bank *bank = to_bank(offset); - void __iomem *addr_r, *addr_w; - u32 reg = 0; if (aspeed_sgpio_is_input(offset)) return -EINVAL; - /* Since this is an output, read the cached value from rdata, then - * update val. */ - addr_r = bank_reg(gpio, bank, reg_rdata); - addr_w = bank_reg(gpio, bank, reg_val); - - reg = ioread32(addr_r); - - if (val) - reg |= GPIO_BIT(offset); - else - reg &= ~GPIO_BIT(offset); - - iowrite32(reg, addr_w); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_val, val); return 0; } @@ -238,69 +233,34 @@ static int aspeed_sgpio_get_direction(struct gpio_chip *gc, unsigned int offset) return !!aspeed_sgpio_is_input(offset); } -static void irqd_to_aspeed_sgpio_data(struct irq_data *d, - struct aspeed_sgpio **gpio, - const struct aspeed_sgpio_bank **bank, - u32 *bit, int *offset) -{ - struct aspeed_sgpio *internal; - - *offset = irqd_to_hwirq(d); - internal = irq_data_get_irq_chip_data(d); - WARN_ON(!internal); - - *gpio = internal; - *bank = to_bank(*offset); - *bit = GPIO_BIT(*offset); -} static void aspeed_sgpio_irq_ack(struct irq_data *d) { - const struct aspeed_sgpio_bank *bank; - struct aspeed_sgpio *gpio; - void __iomem *status_addr; - int offset; - u32 bit; - - irqd_to_aspeed_sgpio_data(d, &gpio, &bank, &bit, &offset); - - status_addr = bank_reg(gpio, bank, reg_irq_status); + struct aspeed_sgpio *gpio = irq_data_get_irq_chip_data(d); + int offset = irqd_to_hwirq(d); guard(raw_spinlock_irqsave)(&gpio->lock); - iowrite32(bit, status_addr); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_irq_status, 1); } static void aspeed_sgpio_irq_set_mask(struct irq_data *d, bool set) { - const struct aspeed_sgpio_bank *bank; - struct aspeed_sgpio *gpio; - u32 reg, bit; - void __iomem *addr; - int offset; - - irqd_to_aspeed_sgpio_data(d, &gpio, &bank, &bit, &offset); - addr = bank_reg(gpio, bank, reg_irq_enable); + struct aspeed_sgpio *gpio = irq_data_get_irq_chip_data(d); + int offset = irqd_to_hwirq(d); /* Unmasking the IRQ */ if (set) - gpiochip_enable_irq(&gpio->chip, irqd_to_hwirq(d)); - - scoped_guard(raw_spinlock_irqsave, &gpio->lock) { - reg = ioread32(addr); - if (set) - reg |= bit; - else - reg &= ~bit; - - iowrite32(reg, addr); + gpiochip_enable_irq(&gpio->chip, offset); + scoped_guard(raw_spinlock_irqsave, &gpio->lock) + { + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_irq_enable, + set); } /* Masking the IRQ */ if (!set) - gpiochip_disable_irq(&gpio->chip, irqd_to_hwirq(d)); - - + gpiochip_disable_irq(&gpio->chip, offset); } static void aspeed_sgpio_irq_mask(struct irq_data *d) @@ -318,30 +278,25 @@ static int aspeed_sgpio_set_type(struct irq_data *d, unsigned int type) u32 type0 = 0; u32 type1 = 0; u32 type2 = 0; - u32 bit, reg; - const struct aspeed_sgpio_bank *bank; irq_flow_handler_t handler; - struct aspeed_sgpio *gpio; - void __iomem *addr; - int offset; - - irqd_to_aspeed_sgpio_data(d, &gpio, &bank, &bit, &offset); + struct aspeed_sgpio *gpio = irq_data_get_irq_chip_data(d); + int offset = irqd_to_hwirq(d); switch (type & IRQ_TYPE_SENSE_MASK) { case IRQ_TYPE_EDGE_BOTH: - type2 |= bit; + type2 = 1; fallthrough; case IRQ_TYPE_EDGE_RISING: - type0 |= bit; + type0 = 1; fallthrough; case IRQ_TYPE_EDGE_FALLING: handler = handle_edge_irq; break; case IRQ_TYPE_LEVEL_HIGH: - type0 |= bit; + type0 = 1; fallthrough; case IRQ_TYPE_LEVEL_LOW: - type1 |= bit; + type1 = 1; handler = handle_level_irq; break; default: @@ -349,20 +304,9 @@ static int aspeed_sgpio_set_type(struct irq_data *d, unsigned int type) } scoped_guard(raw_spinlock_irqsave, &gpio->lock) { - addr = bank_reg(gpio, bank, reg_irq_type0); - reg = ioread32(addr); - reg = (reg & ~bit) | type0; - iowrite32(reg, addr); - - addr = bank_reg(gpio, bank, reg_irq_type1); - reg = ioread32(addr); - reg = (reg & ~bit) | type1; - iowrite32(reg, addr); - - addr = bank_reg(gpio, bank, reg_irq_type2); - reg = ioread32(addr); - reg = (reg & ~bit) | type2; - iowrite32(reg, addr); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_irq_type0, type0); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_irq_type1, type1); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_irq_type2, type2); } irq_set_handler_locked(d, handler); @@ -381,9 +325,7 @@ static void aspeed_sgpio_irq_handler(struct irq_desc *desc) chained_irq_enter(ic, desc); for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) { - const struct aspeed_sgpio_bank *bank = &aspeed_sgpio_banks[i]; - - reg = ioread32(bank_reg(data, bank, reg_irq_status)); + reg = data->pdata->llops->reg_bank_get(data, i << 6, reg_irq_status); for_each_set_bit(p, ®, 32) generic_handle_domain_irq(gc->irq.domain, (i * 32 + p) * 2); @@ -394,12 +336,8 @@ static void aspeed_sgpio_irq_handler(struct irq_desc *desc) static void aspeed_sgpio_irq_print_chip(struct irq_data *d, struct seq_file *p) { - const struct aspeed_sgpio_bank *bank; - struct aspeed_sgpio *gpio; - u32 bit; - int offset; + struct aspeed_sgpio *gpio = irq_data_get_irq_chip_data(d); - irqd_to_aspeed_sgpio_data(d, &gpio, &bank, &bit, &offset); seq_puts(p, dev_name(gpio->dev)); } @@ -447,7 +385,7 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio, /* Apply default IRQ settings */ for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) { - bank = &aspeed_sgpio_banks[i]; + bank = &aspeed_sgpio_banks[i]; /* set falling or level-low irq */ iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type0)); /* trigger type is edge */ @@ -459,29 +397,78 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio, return 0; } +static void aspeed_sgpio_g4_reg_bit_set(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg, bool val) +{ + const struct aspeed_sgpio_bank *bank = to_bank(offset); + void __iomem *addr = aspeed_sgpio_g4_bank_reg(gpio, bank, reg); + u32 temp; + + if (reg == reg_val) { + /* Since this is an output, read the cached value from rdata, then update val. */ + addr = aspeed_sgpio_g4_bank_reg(gpio, bank, reg_rdata); + temp = ioread32(addr); + if (val) + temp |= GPIO_BIT(offset); + else + temp &= ~GPIO_BIT(offset); + + addr = aspeed_sgpio_g4_bank_reg(gpio, bank, reg_val); + iowrite32(temp, addr); + } else if (reg == reg_irq_status) { + if (val) + iowrite32(GPIO_BIT(offset), addr); + } else { + /* When setting other registers, we read from the register itself */ + temp = ioread32(addr); + if (val) + temp |= GPIO_BIT(offset); + else + temp &= ~GPIO_BIT(offset); + iowrite32(temp, addr); + } +} + +static bool aspeed_sgpio_g4_reg_bit_get(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg) +{ + const struct aspeed_sgpio_bank *bank = to_bank(offset); + void __iomem *addr = aspeed_sgpio_g4_bank_reg(gpio, bank, reg); + + return !!(ioread32(addr) & GPIO_BIT(offset)); +} + +static int aspeed_sgpio_g4_reg_bank_get(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg) +{ + const struct aspeed_sgpio_bank *bank = to_bank(offset); + void __iomem *addr = aspeed_sgpio_g4_bank_reg(gpio, bank, reg); + + if (reg == reg_irq_status) + return ioread32(addr); + else + return -EOPNOTSUPP; +} + +static const struct aspeed_sgpio_llops aspeed_sgpio_g4_llops = { + .reg_bit_set = aspeed_sgpio_g4_reg_bit_set, + .reg_bit_get = aspeed_sgpio_g4_reg_bit_get, + .reg_bank_get = aspeed_sgpio_g4_reg_bank_get, +}; + static const struct aspeed_sgpio_pdata ast2400_sgpio_pdata = { .pin_mask = GENMASK(9, 6), + .llops = &aspeed_sgpio_g4_llops, }; static int aspeed_sgpio_reset_tolerance(struct gpio_chip *chip, unsigned int offset, bool enable) { struct aspeed_sgpio *gpio = gpiochip_get_data(chip); - void __iomem *reg; - u32 val; - - reg = bank_reg(gpio, to_bank(offset), reg_tolerance); guard(raw_spinlock_irqsave)(&gpio->lock); - val = readl(reg); - - if (enable) - val |= GPIO_BIT(offset); - else - val &= ~GPIO_BIT(offset); - - writel(val, reg); + gpio->pdata->llops->reg_bit_set(gpio, offset, reg_tolerance, enable); return 0; } @@ -500,6 +487,7 @@ static int aspeed_sgpio_set_config(struct gpio_chip *chip, unsigned int offset, static const struct aspeed_sgpio_pdata ast2600_sgpiom_pdata = { .pin_mask = GENMASK(10, 6), + .llops = &aspeed_sgpio_g4_llops, }; static const struct of_device_id aspeed_sgpio_of_table[] = { @@ -514,7 +502,6 @@ MODULE_DEVICE_TABLE(of, aspeed_sgpio_of_table); static int aspeed_sgpio_probe(struct platform_device *pdev) { u32 nr_gpios, sgpio_freq, sgpio_clk_div, gpio_cnt_regval, pin_mask; - const struct aspeed_sgpio_pdata *pdata; struct aspeed_sgpio *gpio; unsigned long apb_freq; int rc; @@ -529,12 +516,11 @@ static int aspeed_sgpio_probe(struct platform_device *pdev) gpio->dev = &pdev->dev; - pdata = device_get_match_data(&pdev->dev); - if (!pdata) + gpio->pdata = device_get_match_data(&pdev->dev); + if (!gpio->pdata) return -EINVAL; - pin_mask = pdata->pin_mask; - + pin_mask = gpio->pdata->pin_mask; rc = device_property_read_u32(&pdev->dev, "ngpios", &nr_gpios); if (rc < 0) { dev_err(&pdev->dev, "Could not read ngpios property\n"); From 43090d6993341b977ca66f4c72e776e99f7ba996 Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:29 +0800 Subject: [PATCH 53/59] gpio: aspeed-sgpio: Convert IRQ functions to use llops callbacks Update aspeed_sgpio_irq_handler() and aspeed_sgpio_setup_irqs() to use the llops callbacks for register access instead of direct iowrite32(). This creates a unified hardware access layer, which is essential for supporting SoCs with different register layouts like the AST2700. Additionally, change the loop bounds to use ngpio instead of the static ARRAY_SIZE(aspeed_sgpio_banks). This allows the driver to adapt to the actual number of supported pins on the running SoC. Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-4-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed-sgpio.c | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c index 33a830ea7d28..b5270e11b153 100644 --- a/drivers/gpio/gpio-aspeed-sgpio.c +++ b/drivers/gpio/gpio-aspeed-sgpio.c @@ -319,12 +319,13 @@ static void aspeed_sgpio_irq_handler(struct irq_desc *desc) struct gpio_chip *gc = irq_desc_get_handler_data(desc); struct irq_chip *ic = irq_desc_get_chip(desc); struct aspeed_sgpio *data = gpiochip_get_data(gc); - unsigned int i, p; + unsigned int i, p, banks; unsigned long reg; chained_irq_enter(ic, desc); - for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) { + banks = DIV_ROUND_UP(gc->ngpio, 64); + for (i = 0; i < banks; i++) { reg = data->pdata->llops->reg_bank_get(data, i << 6, reg_irq_status); for_each_set_bit(p, ®, 32) @@ -355,7 +356,6 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio, struct platform_device *pdev) { int rc, i; - const struct aspeed_sgpio_bank *bank; struct gpio_irq_chip *irq; rc = platform_get_irq(pdev, 0); @@ -365,12 +365,11 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio, gpio->irq = rc; /* Disable IRQ and clear Interrupt status registers for all SGPIO Pins. */ - for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) { - bank = &aspeed_sgpio_banks[i]; + for (i = 0; i < gpio->chip.ngpio; i += 2) { /* disable irq enable bits */ - iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_enable)); + gpio->pdata->llops->reg_bit_set(gpio, i, reg_irq_enable, 0); /* clear status bits */ - iowrite32(0xffffffff, bank_reg(gpio, bank, reg_irq_status)); + gpio->pdata->llops->reg_bit_set(gpio, i, reg_irq_status, 1); } irq = &gpio->chip.irq; @@ -384,14 +383,13 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio, irq->num_parents = 1; /* Apply default IRQ settings */ - for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) { - bank = &aspeed_sgpio_banks[i]; + for (i = 0; i < gpio->chip.ngpio; i += 2) { /* set falling or level-low irq */ - iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type0)); + gpio->pdata->llops->reg_bit_set(gpio, i, reg_irq_type0, 0); /* trigger type is edge */ - iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type1)); + gpio->pdata->llops->reg_bit_set(gpio, i, reg_irq_type1, 0); /* single edge trigger */ - iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type2)); + gpio->pdata->llops->reg_bit_set(gpio, i, reg_irq_type2, 0); } return 0; From 149470018e678b8fd62225c01be67ce2f9b5b1f2 Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:30 +0800 Subject: [PATCH 54/59] dt-bindings: gpio: aspeed,sgpio: Support ast2700 The AST2700 is the 7th generation SoC from Aspeed, featuring two SGPIO master controllers: both with 256 serial inputs and outputs. Acked-by: Krzysztof Kozlowski Reviewed-by: Linus Walleij Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-5-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- Documentation/devicetree/bindings/gpio/aspeed,sgpio.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Documentation/devicetree/bindings/gpio/aspeed,sgpio.yaml b/Documentation/devicetree/bindings/gpio/aspeed,sgpio.yaml index 1046f0331c09..974185e3478f 100644 --- a/Documentation/devicetree/bindings/gpio/aspeed,sgpio.yaml +++ b/Documentation/devicetree/bindings/gpio/aspeed,sgpio.yaml @@ -10,7 +10,8 @@ maintainers: - Andrew Jeffery description: - This SGPIO controller is for ASPEED AST2400, AST2500 and AST2600 SoC, + This SGPIO controller is for ASPEED AST2400, AST2500, AST2600 and AST2700 SoC, + AST2700 have two sgpio master both with 256 pins, AST2600 have two sgpio master one with 128 pins another one with 80 pins, AST2500/AST2400 have one sgpio master with 80 pins. Each of the Serial GPIO pins can be programmed to support the following options @@ -27,6 +28,7 @@ properties: - aspeed,ast2400-sgpio - aspeed,ast2500-sgpio - aspeed,ast2600-sgpiom + - aspeed,ast2700-sgpiom reg: maxItems: 1 From 274ea0f1687a849ded4f92d10e4c0e77f37740c9 Mon Sep 17 00:00:00 2001 From: Billy Tsai Date: Fri, 23 Jan 2026 17:26:31 +0800 Subject: [PATCH 55/59] gpio: aspeed-sgpio: Support G7 Aspeed sgpiom controller In the 7th generation of the SoC from Aspeed, the control logic of the SGPIO controller has been updated to support per-pin control. Each pin now has its own 32-bit register, allowing for individual control of the pin's value, interrupt type, and other settings. Reviewed-by: Linus Walleij Signed-off-by: Billy Tsai Link: https://lore.kernel.org/r/20260123-upstream_sgpio-v2-6-69cfd1631400@aspeedtech.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-aspeed-sgpio.c | 110 ++++++++++++++++++++++++++++++- 1 file changed, 108 insertions(+), 2 deletions(-) diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c index b5270e11b153..4225261f61c8 100644 --- a/drivers/gpio/gpio-aspeed-sgpio.c +++ b/drivers/gpio/gpio-aspeed-sgpio.c @@ -19,7 +19,31 @@ #include #include -#define ASPEED_SGPIO_CTRL 0x54 +#define SGPIO_G7_IRQ_STS_BASE 0x40 +#define SGPIO_G7_IRQ_STS_OFFSET(x) (SGPIO_G7_IRQ_STS_BASE + (x) * 0x4) +#define SGPIO_G7_CTRL_REG_BASE 0x80 +#define SGPIO_G7_CTRL_REG_OFFSET(x) (SGPIO_G7_CTRL_REG_BASE + (x) * 0x4) +#define SGPIO_G7_OUT_DATA BIT(0) +#define SGPIO_G7_PARALLEL_OUT_DATA BIT(1) +#define SGPIO_G7_IRQ_EN BIT(2) +#define SGPIO_G7_IRQ_TYPE0 BIT(3) +#define SGPIO_G7_IRQ_TYPE1 BIT(4) +#define SGPIO_G7_IRQ_TYPE2 BIT(5) +#define SGPIO_G7_RST_TOLERANCE BIT(6) +#define SGPIO_G7_INPUT_MASK BIT(9) +#define SGPIO_G7_HW_BYPASS_EN BIT(10) +#define SGPIO_G7_HW_IN_SEL BIT(11) +#define SGPIO_G7_IRQ_STS BIT(12) +#define SGPIO_G7_IN_DATA BIT(13) +#define SGPIO_G7_PARALLEL_IN_DATA BIT(14) +#define SGPIO_G7_SERIAL_OUT_SEL GENMASK(17, 16) +#define SGPIO_G7_PARALLEL_OUT_SEL GENMASK(19, 18) +#define SELECT_FROM_CSR 0 +#define SELECT_FROM_PARALLEL_IN 1 +#define SELECT_FROM_SERIAL_IN 2 + +#define ASPEED_SGPIO_G4_CFG_OFFSET 0x54 +#define ASPEED_SGPIO_G7_CFG_OFFSET 0x0 #define ASPEED_SGPIO_CLK_DIV_MASK GENMASK(31, 16) #define ASPEED_SGPIO_ENABLE BIT(0) @@ -28,6 +52,7 @@ struct aspeed_sgpio_pdata { const u32 pin_mask; const struct aspeed_sgpio_llops *llops; + const u32 cfg_offset; }; struct aspeed_sgpio { @@ -135,6 +160,30 @@ static void __iomem *aspeed_sgpio_g4_bank_reg(struct aspeed_sgpio *gpio, } } +static u32 aspeed_sgpio_g7_reg_mask(const enum aspeed_sgpio_reg reg) +{ + switch (reg) { + case reg_val: + case reg_rdata: + return SGPIO_G7_OUT_DATA; + case reg_irq_enable: + return SGPIO_G7_IRQ_EN; + case reg_irq_type0: + return SGPIO_G7_IRQ_TYPE0; + case reg_irq_type1: + return SGPIO_G7_IRQ_TYPE1; + case reg_irq_type2: + return SGPIO_G7_IRQ_TYPE2; + case reg_irq_status: + return SGPIO_G7_IRQ_STS; + case reg_tolerance: + return SGPIO_G7_RST_TOLERANCE; + default: + WARN_ON_ONCE(1); + return 0; + } +} + #define GPIO_BANK(x) ((x) >> 6) #define GPIO_OFFSET(x) ((x) & GENMASK(5, 0)) #define GPIO_BIT(x) BIT(GPIO_OFFSET(x) >> 1) @@ -457,6 +506,7 @@ static const struct aspeed_sgpio_llops aspeed_sgpio_g4_llops = { static const struct aspeed_sgpio_pdata ast2400_sgpio_pdata = { .pin_mask = GENMASK(9, 6), .llops = &aspeed_sgpio_g4_llops, + .cfg_offset = ASPEED_SGPIO_G4_CFG_OFFSET, }; static int aspeed_sgpio_reset_tolerance(struct gpio_chip *chip, @@ -486,12 +536,68 @@ static int aspeed_sgpio_set_config(struct gpio_chip *chip, unsigned int offset, static const struct aspeed_sgpio_pdata ast2600_sgpiom_pdata = { .pin_mask = GENMASK(10, 6), .llops = &aspeed_sgpio_g4_llops, + .cfg_offset = ASPEED_SGPIO_G4_CFG_OFFSET, +}; + +static void aspeed_sgpio_g7_reg_bit_set(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg, bool val) +{ + u32 mask = aspeed_sgpio_g7_reg_mask(reg); + void __iomem *addr = gpio->base + SGPIO_G7_CTRL_REG_OFFSET(offset >> 1); + u32 write_val; + + if (mask) { + write_val = (ioread32(addr) & ~(mask)) | field_prep(mask, val); + iowrite32(write_val, addr); + } +} + +static bool aspeed_sgpio_g7_reg_bit_get(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg) +{ + u32 mask = aspeed_sgpio_g7_reg_mask(reg); + void __iomem *addr; + + addr = gpio->base + SGPIO_G7_CTRL_REG_OFFSET(offset >> 1); + if (reg == reg_val) + mask = SGPIO_G7_IN_DATA; + + if (mask) + return field_get(mask, ioread32(addr)); + else + return 0; +} + +static int aspeed_sgpio_g7_reg_bank_get(struct aspeed_sgpio *gpio, unsigned int offset, + const enum aspeed_sgpio_reg reg) +{ + void __iomem *addr; + + if (reg == reg_irq_status) { + addr = gpio->base + SGPIO_G7_IRQ_STS_OFFSET(offset >> 6); + return ioread32(addr); + } else { + return -EOPNOTSUPP; + } +} + +static const struct aspeed_sgpio_llops aspeed_sgpio_g7_llops = { + .reg_bit_set = aspeed_sgpio_g7_reg_bit_set, + .reg_bit_get = aspeed_sgpio_g7_reg_bit_get, + .reg_bank_get = aspeed_sgpio_g7_reg_bank_get, +}; + +static const struct aspeed_sgpio_pdata ast2700_sgpiom_pdata = { + .pin_mask = GENMASK(11, 6), + .llops = &aspeed_sgpio_g7_llops, + .cfg_offset = ASPEED_SGPIO_G7_CFG_OFFSET, }; static const struct of_device_id aspeed_sgpio_of_table[] = { { .compatible = "aspeed,ast2400-sgpio", .data = &ast2400_sgpio_pdata, }, { .compatible = "aspeed,ast2500-sgpio", .data = &ast2400_sgpio_pdata, }, { .compatible = "aspeed,ast2600-sgpiom", .data = &ast2600_sgpiom_pdata, }, + { .compatible = "aspeed,ast2700-sgpiom", .data = &ast2700_sgpiom_pdata, }, {} }; @@ -562,7 +668,7 @@ static int aspeed_sgpio_probe(struct platform_device *pdev) gpio_cnt_regval = ((nr_gpios / 8) << ASPEED_SGPIO_PINS_SHIFT) & pin_mask; iowrite32(FIELD_PREP(ASPEED_SGPIO_CLK_DIV_MASK, sgpio_clk_div) | gpio_cnt_regval | - ASPEED_SGPIO_ENABLE, gpio->base + ASPEED_SGPIO_CTRL); + ASPEED_SGPIO_ENABLE, gpio->base + gpio->pdata->cfg_offset); raw_spin_lock_init(&gpio->lock); From 4c4ff6e38768f2431ed153f110f2d1fcce848af8 Mon Sep 17 00:00:00 2001 From: Diogo Ivo Date: Tue, 27 Jan 2026 18:52:42 +0000 Subject: [PATCH 56/59] gpio: max77620: Implement .get_direction() callback Add support for reporting the current GPIO line direction by implementing the .get_direction() callback for the MAX77620 GPIO controller. Signed-off-by: Diogo Ivo Reviewed-by: Linus Walleij Link: https://patch.msgid.link/20260127-smaug-spi_flash-v1-1-5fd334415118@tecnico.ulisboa.pt Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-max77620.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/drivers/gpio/gpio-max77620.c b/drivers/gpio/gpio-max77620.c index 02eca400b307..e6c85411c695 100644 --- a/drivers/gpio/gpio-max77620.c +++ b/drivers/gpio/gpio-max77620.c @@ -132,6 +132,24 @@ static const struct irq_chip max77620_gpio_irqchip = { GPIOCHIP_IRQ_RESOURCE_HELPERS, }; +static int max77620_gpio_get_dir(struct gpio_chip *gc, unsigned int offset) +{ + struct max77620_gpio *mgpio = gpiochip_get_data(gc); + unsigned int val; + int ret; + + ret = regmap_read(mgpio->rmap, GPIO_REG_ADDR(offset), &val); + if (ret < 0) { + dev_err(mgpio->dev, "CNFG_GPIOx read failed: %d\n", ret); + return ret; + } + + if (val & MAX77620_CNFG_GPIO_DIR_MASK) + return GPIO_LINE_DIRECTION_IN; + else + return GPIO_LINE_DIRECTION_OUT; +} + static int max77620_gpio_dir_input(struct gpio_chip *gc, unsigned int offset) { struct max77620_gpio *mgpio = gpiochip_get_data(gc); @@ -308,6 +326,7 @@ static int max77620_gpio_probe(struct platform_device *pdev) mgpio->gpio_chip.label = pdev->name; mgpio->gpio_chip.parent = pdev->dev.parent; + mgpio->gpio_chip.get_direction = max77620_gpio_get_dir; mgpio->gpio_chip.direction_input = max77620_gpio_dir_input; mgpio->gpio_chip.get = max77620_gpio_get; mgpio->gpio_chip.direction_output = max77620_gpio_dir_output; From aa7e37fd770bafaaf856ab77735296955b93e377 Mon Sep 17 00:00:00 2001 From: Vivian Wang Date: Tue, 27 Jan 2026 10:58:49 +0800 Subject: [PATCH 57/59] gpio: spacemit-k1: Use PDR for pin direction, not SDR/CDR On the SpacemiT GPIO controller, the direction control register PDR is readable and writable [1]. Therefore, implement direction control by using PDR as dirout, and don't mark it as unreadable. The original implementation, using SDR as dirout and CDR as dirin, is not actually a supported configuration by gpio-mmio. The hardware supports changing the direction of some pins atomically by writing a value with the corresponding bits set to SDR (set as output) or to CDR (set as input). However, gpio-mmio does not actually handle this. Using only PDR as dirout to match the expectations of gpio-mmio. This also allows us to avoid clobbering potentially important GPIO direction configurations set by pre-Linux boot stages. Found while trying to add PCIe support to OrangePi RV2, where the regulator (controlled by GPIO 116) turns off on boot while some other GPIO pin in the same bank is touched, which is not desirable. Link: https://developer.spacemit.com/documentation?token=Rn9Kw3iFHirAMgkIpTAcV2Arnkf#18.4-gpio # [1] Fixes: d00553240ef8 ("gpio: spacemit: add support for K1 SoC") Signed-off-by: Vivian Wang Reviewed-by: Troy Mitchell Link: https://patch.msgid.link/20260127-gpio-spacemit-k1-pdr-v1-1-bb868a517dbc@iscas.ac.cn Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-spacemit-k1.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/drivers/gpio/gpio-spacemit-k1.c b/drivers/gpio/gpio-spacemit-k1.c index 8f570a1a4894..dbd2e81094b9 100644 --- a/drivers/gpio/gpio-spacemit-k1.c +++ b/drivers/gpio/gpio-spacemit-k1.c @@ -199,7 +199,7 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, struct gpio_chip *gc = &gb->chip.gc; struct device *dev = sg->dev; struct gpio_irq_chip *girq; - void __iomem *dat, *set, *clr, *dirin, *dirout; + void __iomem *dat, *set, *clr, *dirout; int ret; gb->base = regs + sg->data->bank_offsets[index]; @@ -208,8 +208,7 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, dat = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPLR]; set = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPSR]; clr = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPCR]; - dirin = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GCDR]; - dirout = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GSDR]; + dirout = gb->base + to_spacemit_gpio_regs(gb)[SPACEMIT_GPDR]; config = (struct gpio_generic_chip_config) { .dev = dev, @@ -218,9 +217,7 @@ static int spacemit_gpio_add_bank(struct spacemit_gpio *sg, .set = set, .clr = clr, .dirout = dirout, - .dirin = dirin, - .flags = GPIO_GENERIC_UNREADABLE_REG_SET | - GPIO_GENERIC_UNREADABLE_REG_DIR, + .flags = GPIO_GENERIC_UNREADABLE_REG_SET, }; /* This registers 32 GPIO lines per bank */ From b565717e1d50078b8f13f3f796e707d24a6f3fdc Mon Sep 17 00:00:00 2001 From: Prathamesh Shete Date: Wed, 28 Jan 2026 08:51:12 +0000 Subject: [PATCH 58/59] dt-bindings: gpio: Add Tegra264 support Extend the existing Tegra186 GPIO controller device tree bindings with support for the GPIO controller found on Tegra264. The number of pins is slightly different, but the programming model remains the same. Add a new header, include/dt-bindings/gpio/nvidia,tegra264-gpio.h, that defines port IDs as well as the TEGRA264_MAIN_GPIO() helper, both of which are used in conjunction to create a unique specifier for each pin. On Tegra, GPIO wake events are latched and routed via the PMC. Document the standard DT property, wakeup-parent, which is a phandle to the PMC interrupt controller that provides the parent wake interrupt domain for the GPIO controller. If the property is absent the driver falls back to a compatible-based lookup. Signed-off-by: Prathamesh Shete Acked-by: Thierry Reding Acked-by: Conor Dooley Link: https://patch.msgid.link/20260128085114.1137725-1-pshete@nvidia.com [Bartosz: fixed whitespace errors] Signed-off-by: Bartosz Golaszewski --- .../bindings/gpio/nvidia,tegra186-gpio.yaml | 22 +++++++ .../dt-bindings/gpio/nvidia,tegra264-gpio.h | 61 +++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 include/dt-bindings/gpio/nvidia,tegra264-gpio.h diff --git a/Documentation/devicetree/bindings/gpio/nvidia,tegra186-gpio.yaml b/Documentation/devicetree/bindings/gpio/nvidia,tegra186-gpio.yaml index 2bd620a1099b..17748dd1015d 100644 --- a/Documentation/devicetree/bindings/gpio/nvidia,tegra186-gpio.yaml +++ b/Documentation/devicetree/bindings/gpio/nvidia,tegra186-gpio.yaml @@ -86,6 +86,9 @@ properties: - nvidia,tegra234-gpio - nvidia,tegra234-gpio-aon - nvidia,tegra256-gpio + - nvidia,tegra264-gpio + - nvidia,tegra264-gpio-uphy + - nvidia,tegra264-gpio-aon reg-names: items: @@ -110,6 +113,10 @@ properties: ports, in the order the HW manual describes them. The number of entries required varies depending on compatible value. + wakeup-parent: + description: Phandle to the parent interrupt controller used for wake-up. On + Tegra, this typically references the PMC interrupt controller. + gpio-controller: true gpio-ranges: @@ -157,6 +164,8 @@ allOf: - nvidia,tegra194-gpio - nvidia,tegra234-gpio - nvidia,tegra256-gpio + - nvidia,tegra264-gpio + - nvidia,tegra264-gpio-uphy then: properties: interrupts: @@ -171,12 +180,25 @@ allOf: - nvidia,tegra186-gpio-aon - nvidia,tegra194-gpio-aon - nvidia,tegra234-gpio-aon + - nvidia,tegra264-gpio-aon then: properties: interrupts: minItems: 1 maxItems: 4 + - if: + properties: + compatible: + contains: + enum: + - nvidia,tegra264-gpio + - nvidia,tegra264-gpio-uphy + - nvidia,tegra264-gpio-aon + then: + required: + - wakeup-parent + required: - compatible - reg diff --git a/include/dt-bindings/gpio/nvidia,tegra264-gpio.h b/include/dt-bindings/gpio/nvidia,tegra264-gpio.h new file mode 100644 index 000000000000..25fb66f9710a --- /dev/null +++ b/include/dt-bindings/gpio/nvidia,tegra264-gpio.h @@ -0,0 +1,61 @@ +/* SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause */ +/* Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved. */ + +/* + * This header provides constants for binding nvidia,tegra264-gpio*. + * + * The first cell in Tegra's GPIO specifier is the GPIO ID. The macros below + * provide names for this. + * + * The second cell contains standard flag values specified in gpio.h. + */ + +#ifndef _DT_BINDINGS_GPIO_TEGRA264_GPIO_H +#define _DT_BINDINGS_GPIO_TEGRA264_GPIO_H + +#include + +/* GPIOs implemented by main GPIO controller */ +#define TEGRA264_MAIN_GPIO_PORT_T 0 +#define TEGRA264_MAIN_GPIO_PORT_U 1 +#define TEGRA264_MAIN_GPIO_PORT_V 2 +#define TEGRA264_MAIN_GPIO_PORT_W 3 +#define TEGRA264_MAIN_GPIO_PORT_AL 4 +#define TEGRA264_MAIN_GPIO_PORT_Y 5 +#define TEGRA264_MAIN_GPIO_PORT_Z 6 +#define TEGRA264_MAIN_GPIO_PORT_X 7 +#define TEGRA264_MAIN_GPIO_PORT_H 8 +#define TEGRA264_MAIN_GPIO_PORT_J 9 +#define TEGRA264_MAIN_GPIO_PORT_K 10 +#define TEGRA264_MAIN_GPIO_PORT_L 11 +#define TEGRA264_MAIN_GPIO_PORT_M 12 +#define TEGRA264_MAIN_GPIO_PORT_P 13 +#define TEGRA264_MAIN_GPIO_PORT_Q 14 +#define TEGRA264_MAIN_GPIO_PORT_R 15 +#define TEGRA264_MAIN_GPIO_PORT_S 16 +#define TEGRA264_MAIN_GPIO_PORT_F 17 +#define TEGRA264_MAIN_GPIO_PORT_G 18 + +#define TEGRA264_MAIN_GPIO(port, offset) \ + ((TEGRA264_MAIN_GPIO_PORT_##port * 8) + (offset)) + +/* GPIOs implemented by AON GPIO controller */ +#define TEGRA264_AON_GPIO_PORT_AA 0 +#define TEGRA264_AON_GPIO_PORT_BB 1 +#define TEGRA264_AON_GPIO_PORT_CC 2 +#define TEGRA264_AON_GPIO_PORT_DD 3 +#define TEGRA264_AON_GPIO_PORT_EE 4 + +#define TEGRA264_AON_GPIO(port, offset) \ + ((TEGRA264_AON_GPIO_PORT_##port * 8) + (offset)) + +#define TEGRA264_UPHY_GPIO_PORT_A 0 +#define TEGRA264_UPHY_GPIO_PORT_B 1 +#define TEGRA264_UPHY_GPIO_PORT_C 2 +#define TEGRA264_UPHY_GPIO_PORT_D 3 +#define TEGRA264_UPHY_GPIO_PORT_E 4 + +#define TEGRA264_UPHY_GPIO(port, offset) \ + ((TEGRA264_UPHY_GPIO_PORT_##port * 8) + (offset)) + +#endif From af9b4a56f0000fb11057e204ddfb05d72ba4dba0 Mon Sep 17 00:00:00 2001 From: Prathamesh Shete Date: Wed, 28 Jan 2026 08:51:13 +0000 Subject: [PATCH 59/59] gpio: tegra186: Add support for Tegra264 Extend the existing Tegra186 GPIO controller driver with support for the GPIO controller found on Tegra264. Use the "wakeup-parent" phandle from the GPIO device tree node to ensure the GPIO driver associates with the intended PMC device. Relying only on compatible-based lookup can select an unexpected PMC node, so fall back to compatible-based lookup when the phandle is not present. Signed-off-by: Prathamesh Shete Reviewed-by: Jon Hunter Acked-by: Thierry Reding Link: https://patch.msgid.link/20260128085114.1137725-2-pshete@nvidia.com Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-tegra186.c | 90 +++++++++++++++++++++++++++++++++++- 1 file changed, 88 insertions(+), 2 deletions(-) diff --git a/drivers/gpio/gpio-tegra186.c b/drivers/gpio/gpio-tegra186.c index b1498b59a921..9c874f07be75 100644 --- a/drivers/gpio/gpio-tegra186.c +++ b/drivers/gpio/gpio-tegra186.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2016-2025 NVIDIA Corporation + * Copyright (c) 2016-2026 NVIDIA Corporation * * Author: Thierry Reding * Dipen Patel @@ -21,6 +21,7 @@ #include #include #include +#include /* security registers */ #define TEGRA186_GPIO_CTL_SCR 0x0c @@ -1001,7 +1002,9 @@ static int tegra186_gpio_probe(struct platform_device *pdev) if (gpio->soc->num_irqs_per_bank > 1) tegra186_gpio_init_route_mapping(gpio); - np = of_find_matching_node(NULL, tegra186_pmc_of_match); + np = of_parse_phandle(pdev->dev.of_node, "wakeup-parent", 0); + if (!np) + np = of_find_matching_node(NULL, tegra186_pmc_of_match); if (np) { if (of_device_is_available(np)) { irq->parent_domain = irq_find_host(np); @@ -1277,6 +1280,80 @@ static const struct tegra_gpio_soc tegra241_aon_soc = { .has_vm_support = false, }; +#define TEGRA264_MAIN_GPIO_PORT(_name, _bank, _port, _pins) \ + TEGRA_GPIO_PORT(TEGRA264_MAIN, _name, _bank, _port, _pins) + +static const struct tegra_gpio_port tegra264_main_ports[] = { + TEGRA264_MAIN_GPIO_PORT(F, 3, 0, 8), + TEGRA264_MAIN_GPIO_PORT(G, 3, 1, 5), + TEGRA264_MAIN_GPIO_PORT(H, 1, 0, 8), + TEGRA264_MAIN_GPIO_PORT(J, 1, 1, 8), + TEGRA264_MAIN_GPIO_PORT(K, 1, 2, 8), + TEGRA264_MAIN_GPIO_PORT(L, 1, 3, 8), + TEGRA264_MAIN_GPIO_PORT(M, 1, 4, 6), + TEGRA264_MAIN_GPIO_PORT(P, 2, 0, 8), + TEGRA264_MAIN_GPIO_PORT(Q, 2, 1, 8), + TEGRA264_MAIN_GPIO_PORT(R, 2, 2, 8), + TEGRA264_MAIN_GPIO_PORT(S, 2, 3, 2), + TEGRA264_MAIN_GPIO_PORT(T, 0, 0, 7), + TEGRA264_MAIN_GPIO_PORT(U, 0, 1, 8), + TEGRA264_MAIN_GPIO_PORT(V, 0, 2, 8), + TEGRA264_MAIN_GPIO_PORT(W, 0, 3, 8), + TEGRA264_MAIN_GPIO_PORT(X, 0, 7, 6), + TEGRA264_MAIN_GPIO_PORT(Y, 0, 5, 8), + TEGRA264_MAIN_GPIO_PORT(Z, 0, 6, 8), + TEGRA264_MAIN_GPIO_PORT(AL, 0, 4, 3), +}; + +static const struct tegra_gpio_soc tegra264_main_soc = { + .num_ports = ARRAY_SIZE(tegra264_main_ports), + .ports = tegra264_main_ports, + .name = "tegra264-gpio", + .instance = 0, + .num_irqs_per_bank = 8, + .has_vm_support = true, +}; + +#define TEGRA264_AON_GPIO_PORT(_name, _bank, _port, _pins) \ + TEGRA_GPIO_PORT(TEGRA264_AON, _name, _bank, _port, _pins) + +static const struct tegra_gpio_port tegra264_aon_ports[] = { + TEGRA264_AON_GPIO_PORT(AA, 0, 0, 8), + TEGRA264_AON_GPIO_PORT(BB, 0, 1, 2), + TEGRA264_AON_GPIO_PORT(CC, 0, 2, 8), + TEGRA264_AON_GPIO_PORT(DD, 0, 3, 8), + TEGRA264_AON_GPIO_PORT(EE, 0, 4, 4) +}; + +static const struct tegra_gpio_soc tegra264_aon_soc = { + .num_ports = ARRAY_SIZE(tegra264_aon_ports), + .ports = tegra264_aon_ports, + .name = "tegra264-gpio-aon", + .instance = 1, + .num_irqs_per_bank = 8, + .has_vm_support = true, +}; + +#define TEGRA264_UPHY_GPIO_PORT(_name, _bank, _port, _pins) \ + TEGRA_GPIO_PORT(TEGRA264_UPHY, _name, _bank, _port, _pins) + +static const struct tegra_gpio_port tegra264_uphy_ports[] = { + TEGRA264_UPHY_GPIO_PORT(A, 0, 0, 6), + TEGRA264_UPHY_GPIO_PORT(B, 0, 1, 8), + TEGRA264_UPHY_GPIO_PORT(C, 0, 2, 3), + TEGRA264_UPHY_GPIO_PORT(D, 1, 0, 8), + TEGRA264_UPHY_GPIO_PORT(E, 1, 1, 4), +}; + +static const struct tegra_gpio_soc tegra264_uphy_soc = { + .num_ports = ARRAY_SIZE(tegra264_uphy_ports), + .ports = tegra264_uphy_ports, + .name = "tegra264-gpio-uphy", + .instance = 2, + .num_irqs_per_bank = 8, + .has_vm_support = true, +}; + #define TEGRA256_MAIN_GPIO_PORT(_name, _bank, _port, _pins) \ TEGRA_GPIO_PORT(TEGRA256_MAIN, _name, _bank, _port, _pins) @@ -1368,6 +1445,15 @@ static const struct of_device_id tegra186_gpio_of_match[] = { }, { .compatible = "nvidia,tegra256-gpio", .data = &tegra256_main_soc + }, { + .compatible = "nvidia,tegra264-gpio", + .data = &tegra264_main_soc + }, { + .compatible = "nvidia,tegra264-gpio-aon", + .data = &tegra264_aon_soc + }, { + .compatible = "nvidia,tegra264-gpio-uphy", + .data = &tegra264_uphy_soc }, { /* sentinel */ }