| Message ID | 20250403-s2mpg10-v3-0-b542b3505e68@linaro.org |
|---|---|
| Headers | show |
| Series | Samsung S2MPG10 PMIC MFD-based drivers | expand |
On Thu, 03 Apr 2025, André Draszik wrote: > Add support for Samsung's S2MPG10 PMIC, which is a Power Management IC > for mobile applications with buck converters, various LDOs, power > meters, RTC, clock outputs, and additional GPIOs interfaces. > > Contrary to existing Samsung S2M series PMICs supported, communication > is not via I2C, but via the Samsung ACPM firmware. > > This commit adds the core driver. > > Signed-off-by: André Draszik <andre.draszik@linaro.org> > > --- > Checkpatch suggests to update MAINTAINERS, but the new file is covered > already due to using a wildcard. > > v3: > * use an enum for struct sec_acpm_bus_context::type > * consistent name space for all functions sec_pmic_acpm_... to be > similar to i2c and consistent in this file > > v2: > * update to using devm_acpm_get_by_node() instead of > devm_acpm_get_by_phandle() as this is now expected to be a child of > the ACPM node > * use c-type file header > * updates to error messages > * drop s2mpg10_rtc_wr_table as everything in RTC is writeable > * rename s2mpg10_volatile_registers -> s2mpg10_rtc_volatile_registers > * fix incorrect regmap range in common block > * add comments to regmap ranges > * add all registers to header for all IP blocks > --- > drivers/mfd/Kconfig | 17 ++ > drivers/mfd/Makefile | 1 + > drivers/mfd/sec-acpm.c | 465 ++++++++++++++++++++++++++++++++++++ > drivers/mfd/sec-core.c | 16 ++ > drivers/mfd/sec-irq.c | 68 ++++++ > include/linux/mfd/samsung/core.h | 1 + > include/linux/mfd/samsung/irq.h | 103 ++++++++ > include/linux/mfd/samsung/rtc.h | 37 +++ > include/linux/mfd/samsung/s2mpg10.h | 454 +++++++++++++++++++++++++++++++++++ > 9 files changed, 1162 insertions(+) > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index 62565dc89ec6d58611bbc1f31c65f757343b6453..e146b28240e731557f34ebe6dea99016b6d19f6b 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -1296,6 +1296,23 @@ config MFD_SEC_CORE > select MFD_CORE > select REGMAP_IRQ > > +config MFD_SEC_ACPM > + tristate "Samsung Electronics S2MPG1x PMICs" > + depends on EXYNOS_ACPM_PROTOCOL > + depends on OF > + select MFD_SEC_CORE > + help > + Support for the Samsung Electronics PMICs with ACPM interface. > + This is a Power Management IC for mobile applications with buck > + converters, various LDOs, power meters, RTC, clock outputs, and > + additional GPIOs interfaces. > + This driver provides common support for accessing the device; > + additional drivers must be enabled in order to use the functionality > + of the device. > + > + To compile this driver as a module, choose M here: the module will be > + called sec-acpm. > + > config MFD_SEC_I2C > tristate "Samsung Electronics S2MPA/S2MPS1X/S2MPU/S5M series PMICs" > depends on I2C=y > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index ab6c4b17a391946d4c88f52ccbfee5424b4fb2d2..b617782eca436e34084a9cd24c309801c5680390 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -229,6 +229,7 @@ obj-$(CONFIG_MFD_RK8XX_I2C) += rk8xx-i2c.o > obj-$(CONFIG_MFD_RK8XX_SPI) += rk8xx-spi.o > obj-$(CONFIG_MFD_RN5T618) += rn5t618.o > obj-$(CONFIG_MFD_SEC_CORE) += sec-core.o sec-irq.o > +obj-$(CONFIG_MFD_SEC_ACPM) += sec-acpm.o > obj-$(CONFIG_MFD_SEC_I2C) += sec-i2c.o > obj-$(CONFIG_MFD_SYSCON) += syscon.o > obj-$(CONFIG_MFD_LM3533) += lm3533-core.o lm3533-ctrlbank.o > diff --git a/drivers/mfd/sec-acpm.c b/drivers/mfd/sec-acpm.c > new file mode 100644 > index 0000000000000000000000000000000000000000..39dbb968086ac835b96ed3e4efa68868fda63429 > --- /dev/null > +++ b/drivers/mfd/sec-acpm.c > @@ -0,0 +1,465 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Copyright 2020 Google Inc > + * Copyright 2025 Linaro Ltd. > + * > + * Samsung S2MPG1x ACPM driver > + */ > + > +#include <linux/array_size.h> > +#include <linux/device.h> > +#include <linux/firmware/samsung/exynos-acpm-protocol.h> > +#include <linux/mfd/samsung/core.h> > +#include <linux/mfd/samsung/rtc.h> > +#include <linux/mfd/samsung/s2mpg10.h> > +#include <linux/mod_devicetable.h> > +#include <linux/module.h> > +#include <linux/of.h> > +#include <linux/platform_device.h> > +#include <linux/pm.h> > +#include <linux/property.h> > +#include <linux/regmap.h> > +#include "sec-core.h" > + > +#define ACPM_MAX_BULK_DATA 8 > + > +struct sec_pmic_acpm_platform_data { This isn't platform data. It's driver data. Platform data is passed in, driver data is derived. See how the other drivers do this: $ git grep ddata -- drivers/mfd > + int device_type; > + > + unsigned int acpm_chan_id; > + u8 speedy_channel; > + > + const struct regmap_config *regmap_cfg_common; > + const struct regmap_config *regmap_cfg_pmic; > + const struct regmap_config *regmap_cfg_rtc; > + const struct regmap_config *regmap_cfg_meter; > +}; > + > +static const struct regmap_range s2mpg10_common_registers[] = { > + regmap_reg_range(0x00, 0x02), /* CHIP_ID_M, INT, INT_MASK */ > + regmap_reg_range(0x0a, 0x0c), /* speedy control */ > + regmap_reg_range(0x1a, 0x2a), /* debug */ Nit: I like comments to start with an upper-case char. > +}; > + > +static const struct regmap_range s2mpg10_common_ro_registers[] = { > + regmap_reg_range(0x00, 0x01), > + regmap_reg_range(0x28, 0x2a), Why describe some, but not all ranges? > +}; > + > +static const struct regmap_range s2mpg10_common_nonvolatile_registers[] = { > + regmap_reg_range(0x00, 0x00), > + regmap_reg_range(0x02, 0x02), > + regmap_reg_range(0x0a, 0x0c), > +}; > + > +static const struct regmap_range s2mpg10_common_precious_registers[] = { > + regmap_reg_range(0x01, 0x01), > +}; > + > +static const struct regmap_access_table s2mpg10_common_wr_table = { > + .yes_ranges = s2mpg10_common_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_common_registers), > + .no_ranges = s2mpg10_common_ro_registers, > + .n_no_ranges = ARRAY_SIZE(s2mpg10_common_ro_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_common_rd_table = { > + .yes_ranges = s2mpg10_common_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_common_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_common_volatile_table = { > + .no_ranges = s2mpg10_common_nonvolatile_registers, > + .n_no_ranges = ARRAY_SIZE(s2mpg10_common_nonvolatile_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_common_precious_table = { > + .yes_ranges = s2mpg10_common_precious_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_common_precious_registers), > +}; > + > +static const struct regmap_config s2mpg10_regmap_config_common = { > + .name = "common", > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = S2MPG10_COMMON_SPD_DEBUG4, > + .wr_table = &s2mpg10_common_wr_table, > + .rd_table = &s2mpg10_common_rd_table, > + .volatile_table = &s2mpg10_common_volatile_table, > + .precious_table = &s2mpg10_common_precious_table, > + .num_reg_defaults_raw = S2MPG10_COMMON_SPD_DEBUG4 + 1, > + .cache_type = REGCACHE_FLAT, > +}; > + > +static const struct regmap_range s2mpg10_pmic_registers[] = { > + regmap_reg_range(0x00, 0xf6), > +}; > + > +static const struct regmap_range s2mpg10_pmic_ro_registers[] = { > + regmap_reg_range(0x00, 0x05), /* INTx */ > + regmap_reg_range(0x0c, 0x0f), /* STATUSx PWRONSRC OFFSRC */ > + regmap_reg_range(0xc7, 0xc7), /* GPIO input */ > +}; > + > +static const struct regmap_range s2mpg10_pmic_nonvolatile_registers[] = { > + regmap_reg_range(0x06, 0x0b), /* INTxM */ > +}; > + > +static const struct regmap_range s2mpg10_pmic_precious_registers[] = { > + regmap_reg_range(0x00, 0x05), /* INTx */ > +}; > + > +static const struct regmap_access_table s2mpg10_pmic_wr_table = { > + .yes_ranges = s2mpg10_pmic_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_pmic_registers), > + .no_ranges = s2mpg10_pmic_ro_registers, > + .n_no_ranges = ARRAY_SIZE(s2mpg10_pmic_ro_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_pmic_rd_table = { > + .yes_ranges = s2mpg10_pmic_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_pmic_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_pmic_volatile_table = { > + .no_ranges = s2mpg10_pmic_nonvolatile_registers, > + .n_no_ranges = ARRAY_SIZE(s2mpg10_pmic_nonvolatile_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_pmic_precious_table = { > + .yes_ranges = s2mpg10_pmic_precious_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_pmic_precious_registers), > +}; > + > +static const struct regmap_config s2mpg10_regmap_config_pmic = { > + .name = "pmic", > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = S2MPG10_PMIC_LDO_SENSE4, > + .wr_table = &s2mpg10_pmic_wr_table, > + .rd_table = &s2mpg10_pmic_rd_table, > + .volatile_table = &s2mpg10_pmic_volatile_table, > + .precious_table = &s2mpg10_pmic_precious_table, > + .num_reg_defaults_raw = S2MPG10_PMIC_LDO_SENSE4 + 1, > + .cache_type = REGCACHE_FLAT, > +}; > + > +static const struct regmap_range s2mpg10_rtc_registers[] = { > + regmap_reg_range(0x00, 0x2b), /* RTC */ > +}; > + > +static const struct regmap_range s2mpg10_rtc_volatile_registers[] = { > + regmap_reg_range(0x01, 0x01), /* RTC_UPDATE */ > + regmap_reg_range(0x05, 0x0c), /* time / date */ > +}; > + > +static const struct regmap_access_table s2mpg10_rtc_rd_table = { > + .yes_ranges = s2mpg10_rtc_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_rtc_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_rtc_volatile_table = { > + .yes_ranges = s2mpg10_rtc_volatile_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_rtc_volatile_registers), > +}; > + > +static const struct regmap_config s2mpg10_regmap_config_rtc = { > + .name = "rtc", > + .reg_bits = 8, > + .val_bits = 8, > + .reg_stride = 1, > + .max_register = S2MPG10_RTC_OSC_CTRL, > + .rd_table = &s2mpg10_rtc_rd_table, > + .volatile_table = &s2mpg10_rtc_volatile_table, > + .num_reg_defaults_raw = S2MPG10_RTC_OSC_CTRL + 1, > + .cache_type = REGCACHE_FLAT, > +}; > + > +static const struct regmap_range s2mpg10_meter_registers[] = { > + regmap_reg_range(0x00, 0x21), /* meter config */ > + regmap_reg_range(0x40, 0x8a), /* meter data */ > + regmap_reg_range(0xee, 0xee), /* offset */ > + regmap_reg_range(0xf1, 0xf1), /* trim */ > +}; > + > +static const struct regmap_range s2mpg10_meter_ro_registers[] = { > + regmap_reg_range(0x40, 0x8a), > +}; > + > +static const struct regmap_access_table s2mpg10_meter_wr_table = { > + .yes_ranges = s2mpg10_meter_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_meter_registers), > + .no_ranges = s2mpg10_meter_ro_registers, > + .n_no_ranges = ARRAY_SIZE(s2mpg10_meter_ro_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_meter_rd_table = { > + .yes_ranges = s2mpg10_meter_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_meter_registers), > +}; > + > +static const struct regmap_access_table s2mpg10_meter_volatile_table = { > + .yes_ranges = s2mpg10_meter_ro_registers, > + .n_yes_ranges = ARRAY_SIZE(s2mpg10_meter_ro_registers), > +}; > + > +static const struct regmap_config s2mpg10_regmap_config_meter = { > + .name = "meter", > + .reg_bits = 8, > + .val_bits = 8, > + .reg_stride = 1, > + .max_register = S2MPG10_METER_BUCK_METER_TRIM3, > + .wr_table = &s2mpg10_meter_wr_table, > + .rd_table = &s2mpg10_meter_rd_table, > + .volatile_table = &s2mpg10_meter_volatile_table, > + .num_reg_defaults_raw = S2MPG10_METER_BUCK_METER_TRIM3 + 1, > + .cache_type = REGCACHE_FLAT, > +}; > + > +struct sec_pmic_acpm_shared_bus_context { > + const struct acpm_handle *acpm; > + unsigned int acpm_chan_id; > + u8 speedy_channel; > +}; > + > +enum sec_pmic_acpm_accesstype { > + SEC_PMIC_ACPM_ACCESSTYPE_COMMON = 0x00, > + SEC_PMIC_ACPM_ACCESSTYPE_PMIC = 0x01, > + SEC_PMIC_ACPM_ACCESSTYPE_RTC = 0x02, > + SEC_PMIC_ACPM_ACCESSTYPE_METER = 0x0a, > + SEC_PMIC_ACPM_ACCESSTYPE_WLWP = 0x0b, > + SEC_PMIC_ACPM_ACCESSTYPE_TRIM = 0x0f, > +}; > + > +struct sec_pmic_acpm_bus_context { > + struct sec_pmic_acpm_shared_bus_context *shared; > + enum sec_pmic_acpm_accesstype type; > +}; > + > +static int sec_pmic_acpm_bus_write(void *context, const void *data, > + size_t count) Nit: You can tidy this, and similar line-feeds, up by using 100-chars here. > +{ > + struct sec_pmic_acpm_bus_context *ctx = context; > + const struct acpm_handle *acpm = ctx->shared->acpm; > + const struct acpm_pmic_ops *pmic_ops = &acpm->ops.pmic_ops; > + u8 reg; > + > + if (count < 2 || count > (ACPM_MAX_BULK_DATA + 1)) 2 because? Either comment or define magic numbers please. > + return -EINVAL; > + > + reg = *(u8 *)data; No API to conduct this raw read for you? readl(), *_to_cpu() or similar? > + ++data; > + --count; > + > + return pmic_ops->bulk_write(acpm, ctx->shared->acpm_chan_id, > + ctx->type, reg, > + ctx->shared->speedy_channel, count, data); > +} > + > +static int sec_pmic_acpm_bus_read(void *context, const void *reg_buf, > + size_t reg_size, void *val_buf, > + size_t val_size) > +{ > + struct sec_pmic_acpm_bus_context *ctx = context; > + const struct acpm_handle *acpm = ctx->shared->acpm; > + const struct acpm_pmic_ops *pmic_ops = &acpm->ops.pmic_ops; > + u8 reg; > + > + if (reg_size != 1 || !val_size || val_size > ACPM_MAX_BULK_DATA) > + return -EINVAL; > + > + reg = *(u8 *)reg_buf; > + > + return pmic_ops->bulk_read(acpm, ctx->shared->acpm_chan_id, > + ctx->type, reg, > + ctx->shared->speedy_channel, > + val_size, val_buf); > +} > + > +static int sec_pmic_acpm_bus_reg_update_bits(void *context, unsigned int reg, > + unsigned int mask, > + unsigned int val) > +{ > + struct sec_pmic_acpm_bus_context *ctx = context; > + const struct acpm_handle *acpm = ctx->shared->acpm; > + const struct acpm_pmic_ops *pmic_ops = &acpm->ops.pmic_ops; > + > + return pmic_ops->update_reg(acpm, ctx->shared->acpm_chan_id, > + ctx->type, reg & 0xff, > + ctx->shared->speedy_channel, val, mask); > +} > + > +static const struct regmap_bus sec_pmic_acpm_regmap_bus = { > + .write = sec_pmic_acpm_bus_write, > + .read = sec_pmic_acpm_bus_read, > + .reg_update_bits = sec_pmic_acpm_bus_reg_update_bits, > + .max_raw_read = ACPM_MAX_BULK_DATA, > + .max_raw_write = ACPM_MAX_BULK_DATA, > +}; > + > +static struct regmap * > +sec_pmic_acpm_regmap_init(struct device *dev, Place both of these on the same line please. > + struct sec_pmic_acpm_shared_bus_context *shared_ctx, > + enum sec_pmic_acpm_accesstype type, > + const struct regmap_config *cfg, bool do_attach) > +{ > + struct sec_pmic_acpm_bus_context *ctx; > + struct regmap *regmap; > + > + ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); > + if (!ctx) > + return ERR_PTR(-ENOMEM); > + > + ctx->shared = shared_ctx; > + ctx->type = type; > + > + regmap = devm_regmap_init(dev, &sec_pmic_acpm_regmap_bus, ctx, cfg); > + if (IS_ERR(regmap)) > + return ERR_PTR(dev_err_probe(dev, PTR_ERR(regmap), dev_err_cast_probe() > + "regmap init (%s) failed\n", > + cfg->name)); > + > + if (do_attach) { > + int ret; > + > + ret = regmap_attach_dev(dev, regmap, cfg); > + if (ret) > + return ERR_PTR(dev_err_probe(dev, ret, dev_err_ptr_probe() > + "regmap attach (%s) failed\n", > + cfg->name)); > + } > + > + return regmap; > +} > + > +static void sec_pmic_acpm_mask_common_irqs(void *regmap_common) > +{ > + regmap_write(regmap_common, S2MPG10_COMMON_INT_MASK, > + S2MPG10_COMMON_INT_SRC); Single line. And others like it. > +} > + > +static int sec_pmic_acpm_probe(struct platform_device *pdev) > +{ > + struct regmap *regmap_common, *regmap_pmic, *regmap; > + const struct sec_pmic_acpm_platform_data *pdata; > + struct sec_pmic_acpm_shared_bus_context *shared_ctx; > + const struct acpm_handle *acpm; > + struct device *dev; > + int ret, irq; > + > + dev = &pdev->dev; You can do this during the declaration. > + pdata = device_get_match_data(dev); > + if (!pdata) > + return dev_err_probe(dev, -ENODEV, > + "unsupported device type\n"); > + > + acpm = devm_acpm_get_by_node(dev, pdev->dev.parent->of_node); You have 'dev' now. Please use it. > + if (IS_ERR(acpm)) > + return dev_err_probe(dev, PTR_ERR(acpm), > + "failed to get acpm (2)\n"); > + > + irq = platform_get_irq(pdev, 0); > + if (irq < 0) > + return irq; > + > + shared_ctx = devm_kzalloc(dev, sizeof(*shared_ctx), GFP_KERNEL); > + if (!shared_ctx) > + return -ENOMEM; > + > + shared_ctx->acpm = acpm; > + shared_ctx->acpm_chan_id = pdata->acpm_chan_id; > + shared_ctx->speedy_channel = pdata->speedy_channel; > + > + regmap_common = sec_pmic_acpm_regmap_init(dev, shared_ctx, > + SEC_PMIC_ACPM_ACCESSTYPE_COMMON, > + pdata->regmap_cfg_common, false); > + if (IS_ERR(regmap_common)) > + return PTR_ERR(regmap_common); > + > + /* Mask all interrupts from 'common' block, until successful init */ > + ret = regmap_write(regmap_common, S2MPG10_COMMON_INT_MASK, > + S2MPG10_COMMON_INT_SRC); > + if (ret) > + return dev_err_probe(dev, ret, > + "failed to mask common block interrupts\n"); > + > + regmap_pmic = sec_pmic_acpm_regmap_init(dev, shared_ctx, > + SEC_PMIC_ACPM_ACCESSTYPE_PMIC, > + pdata->regmap_cfg_pmic, false); > + if (IS_ERR(regmap_pmic)) > + return PTR_ERR(regmap_pmic); > + > + regmap = sec_pmic_acpm_regmap_init(dev, shared_ctx, > + SEC_PMIC_ACPM_ACCESSTYPE_RTC, > + pdata->regmap_cfg_rtc, true); > + if (IS_ERR(regmap)) > + return PTR_ERR(regmap); > + > + regmap = sec_pmic_acpm_regmap_init(dev, shared_ctx, > + SEC_PMIC_ACPM_ACCESSTYPE_METER, > + pdata->regmap_cfg_meter, true); > + if (IS_ERR(regmap)) > + return PTR_ERR(regmap); > + > + ret = sec_pmic_probe(dev, pdata->device_type, irq, regmap_pmic, NULL); > + if (ret) > + return ret; > + > + if (device_property_read_bool(dev, "wakeup-source")) > + devm_device_init_wakeup(dev); > + > + /* > + * Unmask PMIC interrupt from 'common' block, now that everything is in > + * place. > + */ > + ret = regmap_clear_bits(regmap_common, S2MPG10_COMMON_INT_MASK, > + S2MPG10_COMMON_INT_SRC_PMIC); > + if (ret) > + return dev_err_probe(dev, ret, > + "failed to unmask PMIC interrupt\n"); > + > + /* Mask all interrupts from 'common' block on shutdown */ > + ret = devm_add_action_or_reset(dev, sec_pmic_acpm_mask_common_irqs, > + regmap_common); > + if (ret) > + return ret; > + > + return 0; > +} > + > +static void sec_pmic_acpm_shutdown(struct platform_device *pdev) > +{ > + sec_pmic_shutdown(&pdev->dev); sec_pmic_shutdown() takes a pointer to i2c_client (unless you changed it somewhere else). If the later is true, then why not make it take a pointer to platform_device and omit this abstraction? > +} > + > +static const struct sec_pmic_acpm_platform_data s2mpg10_data = { > + .device_type = S2MPG10, > + .acpm_chan_id = 2, > + .speedy_channel = 0, > + .regmap_cfg_common = &s2mpg10_regmap_config_common, > + .regmap_cfg_pmic = &s2mpg10_regmap_config_pmic, > + .regmap_cfg_rtc = &s2mpg10_regmap_config_rtc, > + .regmap_cfg_meter = &s2mpg10_regmap_config_meter, > +}; > + > +static const struct of_device_id sec_pmic_acpm_of_match[] = { > + { .compatible = "samsung,s2mpg10-pmic", .data = &s2mpg10_data, }, > + { }, > +}; > +MODULE_DEVICE_TABLE(of, sec_pmic_acpm_of_match); > + > +static struct platform_driver sec_pmic_acpm_driver = { > + .driver = { > + .name = "sec-pmic-acpm", > + .pm = pm_sleep_ptr(&sec_pmic_pm_ops), > + .of_match_table = sec_pmic_acpm_of_match, > + }, > + .probe = sec_pmic_acpm_probe, > + .shutdown = sec_pmic_acpm_shutdown, > +}; > +module_platform_driver(sec_pmic_acpm_driver); > + > +MODULE_AUTHOR("André Draszik <andre.draszik@linaro.org>"); > +MODULE_DESCRIPTION("ACPM driver for the Samsung S2MPG1x"); > +MODULE_LICENSE("GPL"); > diff --git a/drivers/mfd/sec-core.c b/drivers/mfd/sec-core.c > index bb664e052bf5198f2fc83a86bd6e1e72364fb8df..c4b7abe511090d8f5ff2eb501f325cc8173b9bf5 100644 > --- a/drivers/mfd/sec-core.c > +++ b/drivers/mfd/sec-core.c > @@ -36,6 +36,14 @@ static const struct mfd_cell s2dos05_devs[] = { > { .name = "s2dos05-regulator", }, > }; > > +static const struct mfd_cell s2mpg10_devs[] = { > + MFD_CELL_NAME("s2mpg10-meter"), > + MFD_CELL_NAME("s2mpg10-regulator"), > + MFD_CELL_NAME("s2mpg10-rtc"), > + MFD_CELL_OF("s2mpg10-clk", NULL, NULL, 0, 0, "samsung,s2mpg10-clk"), > + MFD_CELL_OF("s2mpg10-gpio", NULL, NULL, 0, 0, "samsung,s2mpg10-gpio"), > +}; > + > static const struct mfd_cell s2mps11_devs[] = { > { .name = "s2mps11-regulator", }, > { .name = "s2mps14-rtc", }, > @@ -90,6 +98,10 @@ static void sec_pmic_dump_rev(struct sec_pmic_dev *sec_pmic) > { > unsigned int val; > > + /* For s2mpg1x, the revision is in a different regmap */ Nice, thanks for that. > + if (sec_pmic->device_type == S2MPG10) > + return; > + > /* For each device type, the REG_ID is always the first register */ > if (!regmap_read(sec_pmic->regmap_pmic, S2MPS11_REG_ID, &val)) > dev_dbg(sec_pmic->dev, "Revision: 0x%x\n", val); > @@ -188,6 +200,10 @@ int sec_pmic_probe(struct device *dev, unsigned long device_type, > sec_devs = s2mpa01_devs; > num_sec_devs = ARRAY_SIZE(s2mpa01_devs); > break; > + case S2MPG10: > + sec_devs = s2mpg10_devs; > + num_sec_devs = ARRAY_SIZE(s2mpg10_devs); > + break; > case S2MPS11X: > sec_devs = s2mps11_devs; > num_sec_devs = ARRAY_SIZE(s2mps11_devs); > diff --git a/drivers/mfd/sec-irq.c b/drivers/mfd/sec-irq.c > index 4d49bb42bd0d109263f485c8b58e88cdd8d598d9..bf86281401ac6ff05c90c2d71c84744709ed79cb 100644 > --- a/drivers/mfd/sec-irq.c > +++ b/drivers/mfd/sec-irq.c > @@ -11,6 +11,7 @@ > #include <linux/irq.h> > #include <linux/mfd/samsung/core.h> > #include <linux/mfd/samsung/irq.h> > +#include <linux/mfd/samsung/s2mpg10.h> > #include <linux/mfd/samsung/s2mps11.h> > #include <linux/mfd/samsung/s2mps14.h> > #include <linux/mfd/samsung/s2mpu02.h> > @@ -20,6 +21,60 @@ > #include <linux/regmap.h> > #include "sec-core.h" > > +static const struct regmap_irq s2mpg10_irqs[] = { > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWRONF, 0, S2MPG10_IRQ_PWRONF_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWRONR, 0, S2MPG10_IRQ_PWRONR_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_JIGONBF, 0, S2MPG10_IRQ_JIGONBF_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_JIGONBR, 0, S2MPG10_IRQ_JIGONBR_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_ACOKBF, 0, S2MPG10_IRQ_ACOKBF_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_ACOKBR, 0, S2MPG10_IRQ_ACOKBR_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWRON1S, 0, S2MPG10_IRQ_PWRON1S_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_MRB, 0, S2MPG10_IRQ_MRB_MASK), > + > + REGMAP_IRQ_REG(S2MPG10_IRQ_RTC60S, 1, S2MPG10_IRQ_RTC60S_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_RTCA1, 1, S2MPG10_IRQ_RTCA1_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_RTCA0, 1, S2MPG10_IRQ_RTCA0_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_RTC1S, 1, S2MPG10_IRQ_RTC1S_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_WTSR_COLDRST, 1, S2MPG10_IRQ_WTSR_COLDRST_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_WTSR, 1, S2MPG10_IRQ_WTSR_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_WRST, 1, S2MPG10_IRQ_WRST_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_SMPL, 1, S2MPG10_IRQ_SMPL_MASK), > + > + REGMAP_IRQ_REG(S2MPG10_IRQ_120C, 2, S2MPG10_IRQ_INT120C_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_140C, 2, S2MPG10_IRQ_INT140C_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_TSD, 2, S2MPG10_IRQ_TSD_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PIF_TIMEOUT1, 2, S2MPG10_IRQ_PIF_TIMEOUT1_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PIF_TIMEOUT2, 2, S2MPG10_IRQ_PIF_TIMEOUT2_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_SPD_PARITY_ERR, 2, S2MPG10_IRQ_SPD_PARITY_ERR_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_SPD_ABNORMAL_STOP, 2, S2MPG10_IRQ_SPD_ABNORMAL_STOP_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PMETER_OVERF, 2, S2MPG10_IRQ_PMETER_OVERF_MASK), > + > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B1M, 3, S2MPG10_IRQ_OCP_B1M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B2M, 3, S2MPG10_IRQ_OCP_B2M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B3M, 3, S2MPG10_IRQ_OCP_B3M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B4M, 3, S2MPG10_IRQ_OCP_B4M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B5M, 3, S2MPG10_IRQ_OCP_B5M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B6M, 3, S2MPG10_IRQ_OCP_B6M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B7M, 3, S2MPG10_IRQ_OCP_B7M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B8M, 3, S2MPG10_IRQ_OCP_B8M_MASK), > + > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B9M, 4, S2MPG10_IRQ_OCP_B9M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_OCP_B10M, 4, S2MPG10_IRQ_OCP_B10M_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_WLWP_ACC, 4, S2MPG10_IRQ_WLWP_ACC_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_SMPL_TIMEOUT, 4, S2MPG10_IRQ_SMPL_TIMEOUT_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_WTSR_TIMEOUT, 4, S2MPG10_IRQ_WTSR_TIMEOUT_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_SPD_SRP_PKT_RST, 4, S2MPG10_IRQ_SPD_SRP_PKT_RST_MASK), > + > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH0, 5, S2MPG10_IRQ_PWR_WARN_CH0_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH1, 5, S2MPG10_IRQ_PWR_WARN_CH1_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH2, 5, S2MPG10_IRQ_PWR_WARN_CH2_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH3, 5, S2MPG10_IRQ_PWR_WARN_CH3_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH4, 5, S2MPG10_IRQ_PWR_WARN_CH4_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH5, 5, S2MPG10_IRQ_PWR_WARN_CH5_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH6, 5, S2MPG10_IRQ_PWR_WARN_CH6_MASK), > + REGMAP_IRQ_REG(S2MPG10_IRQ_PWR_WARN_CH7, 5, S2MPG10_IRQ_PWR_WARN_CH7_MASK), > +}; > + > static const struct regmap_irq s2mps11_irqs[] = { > [S2MPS11_IRQ_PWRONF] = { > .reg_offset = 0, > @@ -320,6 +375,16 @@ static const struct regmap_irq s5m8767_irqs[] = { > }, > }; > > +static const struct regmap_irq_chip s2mpg10_irq_chip = { > + .name = "s2mpg10", > + .irqs = s2mpg10_irqs, > + .num_irqs = ARRAY_SIZE(s2mpg10_irqs), > + .num_regs = 6, > + .status_base = S2MPG10_PMIC_INT1, > + .mask_base = S2MPG10_PMIC_INT1M, > + /* all interrupt sources are read-to-clear */ TOUPPER(a); Comments usually go on-top of the thing they're commenting on. > +}; > + > static const struct regmap_irq_chip s2mps11_irq_chip = { > .name = "s2mps11", > .irqs = s2mps11_irqs, > @@ -402,6 +467,9 @@ int sec_irq_init(struct sec_pmic_dev *sec_pmic) > case S2MPA01: > sec_irq_chip = &s2mps14_irq_chip; > break; > + case S2MPG10: > + sec_irq_chip = &s2mpg10_irq_chip; > + break; > case S2MPS11X: > sec_irq_chip = &s2mps11_irq_chip; > break; > diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h > index 8a4e660854bbc955b812b4d61d4a52a0fc2f2899..c1102324172a9b6bd6072b5929a4866d6c9653fa 100644 > --- a/include/linux/mfd/samsung/core.h > +++ b/include/linux/mfd/samsung/core.h > @@ -39,6 +39,7 @@ enum sec_device_type { > S5M8767X, > S2DOS05, > S2MPA01, > + S2MPG10, > S2MPS11X, > S2MPS13X, > S2MPS14X, > diff --git a/include/linux/mfd/samsung/irq.h b/include/linux/mfd/samsung/irq.h > index 978f7af66f74842c4f8dd62c0f58a7a45aba7c34..b4805cbd949bd605004bd88cf361109d1cbbc3bf 100644 > --- a/include/linux/mfd/samsung/irq.h > +++ b/include/linux/mfd/samsung/irq.h > @@ -57,6 +57,109 @@ enum s2mpa01_irq { > #define S2MPA01_IRQ_B24_TSD_MASK (1 << 4) > #define S2MPA01_IRQ_B35_TSD_MASK (1 << 5) > > +enum s2mpg10_irq { > + /* PMIC */ > + S2MPG10_IRQ_PWRONF, > + S2MPG10_IRQ_PWRONR, > + S2MPG10_IRQ_JIGONBF, > + S2MPG10_IRQ_JIGONBR, > + S2MPG10_IRQ_ACOKBF, > + S2MPG10_IRQ_ACOKBR, > + S2MPG10_IRQ_PWRON1S, > + S2MPG10_IRQ_MRB, > +#define S2MPG10_IRQ_PWRONF_MASK BIT(0) > +#define S2MPG10_IRQ_PWRONR_MASK BIT(1) > +#define S2MPG10_IRQ_JIGONBF_MASK BIT(2) > +#define S2MPG10_IRQ_JIGONBR_MASK BIT(3) > +#define S2MPG10_IRQ_ACOKBF_MASK BIT(4) > +#define S2MPG10_IRQ_ACOKBR_MASK BIT(5) > +#define S2MPG10_IRQ_PWRON1S_MASK BIT(6) > +#define S2MPG10_IRQ_MRB_MASK BIT(7) > + > + S2MPG10_IRQ_RTC60S, > + S2MPG10_IRQ_RTCA1, > + S2MPG10_IRQ_RTCA0, > + S2MPG10_IRQ_RTC1S, > + S2MPG10_IRQ_WTSR_COLDRST, > + S2MPG10_IRQ_WTSR, > + S2MPG10_IRQ_WRST, > + S2MPG10_IRQ_SMPL, > +#define S2MPG10_IRQ_RTC60S_MASK BIT(0) > +#define S2MPG10_IRQ_RTCA1_MASK BIT(1) > +#define S2MPG10_IRQ_RTCA0_MASK BIT(2) > +#define S2MPG10_IRQ_RTC1S_MASK BIT(3) > +#define S2MPG10_IRQ_WTSR_COLDRST_MASK BIT(4) > +#define S2MPG10_IRQ_WTSR_MASK BIT(5) > +#define S2MPG10_IRQ_WRST_MASK BIT(6) > +#define S2MPG10_IRQ_SMPL_MASK BIT(7) > + > + S2MPG10_IRQ_120C, > + S2MPG10_IRQ_140C, > + S2MPG10_IRQ_TSD, > + S2MPG10_IRQ_PIF_TIMEOUT1, > + S2MPG10_IRQ_PIF_TIMEOUT2, > + S2MPG10_IRQ_SPD_PARITY_ERR, > + S2MPG10_IRQ_SPD_ABNORMAL_STOP, > + S2MPG10_IRQ_PMETER_OVERF, > +#define S2MPG10_IRQ_INT120C_MASK BIT(0) > +#define S2MPG10_IRQ_INT140C_MASK BIT(1) > +#define S2MPG10_IRQ_TSD_MASK BIT(2) > +#define S2MPG10_IRQ_PIF_TIMEOUT1_MASK BIT(3) > +#define S2MPG10_IRQ_PIF_TIMEOUT2_MASK BIT(4) > +#define S2MPG10_IRQ_SPD_PARITY_ERR_MASK BIT(5) > +#define S2MPG10_IRQ_SPD_ABNORMAL_STOP_MASK BIT(6) > +#define S2MPG10_IRQ_PMETER_OVERF_MASK BIT(7) > + > + S2MPG10_IRQ_OCP_B1M, > + S2MPG10_IRQ_OCP_B2M, > + S2MPG10_IRQ_OCP_B3M, > + S2MPG10_IRQ_OCP_B4M, > + S2MPG10_IRQ_OCP_B5M, > + S2MPG10_IRQ_OCP_B6M, > + S2MPG10_IRQ_OCP_B7M, > + S2MPG10_IRQ_OCP_B8M, > +#define S2MPG10_IRQ_OCP_B1M_MASK BIT(0) > +#define S2MPG10_IRQ_OCP_B2M_MASK BIT(1) > +#define S2MPG10_IRQ_OCP_B3M_MASK BIT(2) > +#define S2MPG10_IRQ_OCP_B4M_MASK BIT(3) > +#define S2MPG10_IRQ_OCP_B5M_MASK BIT(4) > +#define S2MPG10_IRQ_OCP_B6M_MASK BIT(5) > +#define S2MPG10_IRQ_OCP_B7M_MASK BIT(6) > +#define S2MPG10_IRQ_OCP_B8M_MASK BIT(7) > + > + S2MPG10_IRQ_OCP_B9M, > + S2MPG10_IRQ_OCP_B10M, > + S2MPG10_IRQ_WLWP_ACC, > + S2MPG10_IRQ_SMPL_TIMEOUT, > + S2MPG10_IRQ_WTSR_TIMEOUT, > + S2MPG10_IRQ_SPD_SRP_PKT_RST, > +#define S2MPG10_IRQ_OCP_B9M_MASK BIT(0) > +#define S2MPG10_IRQ_OCP_B10M_MASK BIT(1) > +#define S2MPG10_IRQ_WLWP_ACC_MASK BIT(2) > +#define S2MPG10_IRQ_SMPL_TIMEOUT_MASK BIT(5) > +#define S2MPG10_IRQ_WTSR_TIMEOUT_MASK BIT(6) > +#define S2MPG10_IRQ_SPD_SRP_PKT_RST_MASK BIT(7) > + > + S2MPG10_IRQ_PWR_WARN_CH0, > + S2MPG10_IRQ_PWR_WARN_CH1, > + S2MPG10_IRQ_PWR_WARN_CH2, > + S2MPG10_IRQ_PWR_WARN_CH3, > + S2MPG10_IRQ_PWR_WARN_CH4, > + S2MPG10_IRQ_PWR_WARN_CH5, > + S2MPG10_IRQ_PWR_WARN_CH6, > + S2MPG10_IRQ_PWR_WARN_CH7, > +#define S2MPG10_IRQ_PWR_WARN_CH0_MASK BIT(0) > +#define S2MPG10_IRQ_PWR_WARN_CH1_MASK BIT(1) > +#define S2MPG10_IRQ_PWR_WARN_CH2_MASK BIT(2) > +#define S2MPG10_IRQ_PWR_WARN_CH3_MASK BIT(3) > +#define S2MPG10_IRQ_PWR_WARN_CH4_MASK BIT(4) > +#define S2MPG10_IRQ_PWR_WARN_CH5_MASK BIT(5) > +#define S2MPG10_IRQ_PWR_WARN_CH6_MASK BIT(6) > +#define S2MPG10_IRQ_PWR_WARN_CH7_MASK BIT(7) > + > + S2MPG10_IRQ_NR, > +}; > + > enum s2mps11_irq { > S2MPS11_IRQ_PWRONF, > S2MPS11_IRQ_PWRONR, > diff --git a/include/linux/mfd/samsung/rtc.h b/include/linux/mfd/samsung/rtc.h > index 0204decfc9aacbf4bc93d98a256f1d956bbcd19c..51c4239a1fa6f28155711a0756b0e071b010d848 100644 > --- a/include/linux/mfd/samsung/rtc.h > +++ b/include/linux/mfd/samsung/rtc.h > @@ -72,6 +72,37 @@ enum s2mps_rtc_reg { > S2MPS_RTC_REG_MAX, > }; > > +enum s2mpg10_rtc_reg { > + S2MPG10_RTC_CTRL, > + S2MPG10_RTC_UPDATE, > + S2MPG10_RTC_SMPL, > + S2MPG10_RTC_WTSR, > + S2MPG10_RTC_CAP_SEL, > + S2MPG10_RTC_MSEC, > + S2MPG10_RTC_SEC, > + S2MPG10_RTC_MIN, > + S2MPG10_RTC_HOUR, > + S2MPG10_RTC_WEEK, > + S2MPG10_RTC_DAY, > + S2MPG10_RTC_MON, > + S2MPG10_RTC_YEAR, > + S2MPG10_RTC_A0SEC, > + S2MPG10_RTC_A0MIN, > + S2MPG10_RTC_A0HOUR, > + S2MPG10_RTC_A0WEEK, > + S2MPG10_RTC_A0DAY, > + S2MPG10_RTC_A0MON, > + S2MPG10_RTC_A0YEAR, > + S2MPG10_RTC_A1SEC, > + S2MPG10_RTC_A1MIN, > + S2MPG10_RTC_A1HOUR, > + S2MPG10_RTC_A1WEEK, > + S2MPG10_RTC_A1DAY, > + S2MPG10_RTC_A1MON, > + S2MPG10_RTC_A1YEAR, > + S2MPG10_RTC_OSC_CTRL, > +}; > + > #define RTC_I2C_ADDR (0x0C >> 1) > > #define HOUR_12 (1 << 7) > @@ -124,10 +155,16 @@ enum s2mps_rtc_reg { > #define ALARM_ENABLE_SHIFT 7 > #define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT) > > +/* WTSR & SMPL registers */ > #define SMPL_ENABLE_SHIFT 7 > #define SMPL_ENABLE_MASK (1 << SMPL_ENABLE_SHIFT) > > #define WTSR_ENABLE_SHIFT 6 > #define WTSR_ENABLE_MASK (1 << WTSR_ENABLE_SHIFT) > > +#define S2MPG10_WTSR_COLDTIMER GENMASK(6, 5) > +#define S2MPG10_WTSR_COLDRST BIT(4) > +#define S2MPG10_WTSR_WTSRT GENMASK(3, 1) > +#define S2MPG10_WTSR_WTSR_EN BIT(0) > + > #endif /* __LINUX_MFD_SEC_RTC_H */ > diff --git a/include/linux/mfd/samsung/s2mpg10.h b/include/linux/mfd/samsung/s2mpg10.h > new file mode 100644 > index 0000000000000000000000000000000000000000..778ff16ef6668ded514e8dc7242f369cb9c2d0e6 > --- /dev/null > +++ b/include/linux/mfd/samsung/s2mpg10.h > @@ -0,0 +1,454 @@ > +/* SPDX-License-Identifier: GPL-2.0+ */ > +/* > + * Copyright 2015 Samsung Electronics > + * Copyright 2020 Google Inc > + * Copyright 2025 Linaro Ltd. > + */ > + > +#ifndef __LINUX_MFD_S2MPG10_H > +#define __LINUX_MFD_S2MPG10_H > + > +/* Common registers (type 0x000) */ > +enum s2mpg10_common_reg { > + S2MPG10_COMMON_CHIPID, > + S2MPG10_COMMON_INT, > + S2MPG10_COMMON_INT_MASK, > + S2MPG10_COMMON_SPD_CTRL1 = 0x0a, > + S2MPG10_COMMON_SPD_CTRL2, > + S2MPG10_COMMON_SPD_CTRL3, > + S2MPG10_COMMON_MON1SEL = 0x1a, > + S2MPG10_COMMON_MON2SEL, > + S2MPG10_COMMON_MONR, > + S2MPG10_COMMON_DEBUG_CTRL1, > + S2MPG10_COMMON_DEBUG_CTRL2, > + S2MPG10_COMMON_DEBUG_CTRL3, > + S2MPG10_COMMON_DEBUG_CTRL4, > + S2MPG10_COMMON_DEBUG_CTRL5, > + S2MPG10_COMMON_DEBUG_CTRL6, > + S2MPG10_COMMON_DEBUG_CTRL7, > + S2MPG10_COMMON_DEBUG_CTRL8, > + S2MPG10_COMMON_TEST_MODE1, > + S2MPG10_COMMON_TEST_MODE2, > + S2MPG10_COMMON_SPD_DEBUG1, > + S2MPG10_COMMON_SPD_DEBUG2, > + S2MPG10_COMMON_SPD_DEBUG3, > + S2MPG10_COMMON_SPD_DEBUG4, > +}; > + > +/* for S2MPG10_COMMON_INT and S2MPG10_COMMON_INT_MASK */ TOUPPER(f), etc. > +#define S2MPG10_COMMON_INT_SRC GENMASK(7, 0) > +#define S2MPG10_COMMON_INT_SRC_PMIC BIT(0) > + > +/* PMIC registers (type 0x100) */ > +enum s2mpg10_pmic_reg { > + S2MPG10_PMIC_INT1, > + S2MPG10_PMIC_INT2, > + S2MPG10_PMIC_INT3, > + S2MPG10_PMIC_INT4, > + S2MPG10_PMIC_INT5, > + S2MPG10_PMIC_INT6, > + S2MPG10_PMIC_INT1M, > + S2MPG10_PMIC_INT2M, > + S2MPG10_PMIC_INT3M, > + S2MPG10_PMIC_INT4M, > + S2MPG10_PMIC_INT5M, > + S2MPG10_PMIC_INT6M, > + S2MPG10_PMIC_STATUS1, > + S2MPG10_PMIC_STATUS2, > + S2MPG10_PMIC_PWRONSRC, > + S2MPG10_PMIC_OFFSRC, > + S2MPG10_PMIC_BU_CHG, > + S2MPG10_PMIC_RTCBUF, > + S2MPG10_PMIC_COMMON_CTRL1, > + S2MPG10_PMIC_COMMON_CTRL2, > + S2MPG10_PMIC_COMMON_CTRL3, > + S2MPG10_PMIC_COMMON_CTRL4, > + S2MPG10_PMIC_SMPL_WARN_CTRL, > + S2MPG10_PMIC_MIMICKING_CTRL, > + S2MPG10_PMIC_B1M_CTRL, > + S2MPG10_PMIC_B1M_OUT1, > + S2MPG10_PMIC_B1M_OUT2, > + S2MPG10_PMIC_B2M_CTRL, > + S2MPG10_PMIC_B2M_OUT1, > + S2MPG10_PMIC_B2M_OUT2, > + S2MPG10_PMIC_B3M_CTRL, > + S2MPG10_PMIC_B3M_OUT1, > + S2MPG10_PMIC_B3M_OUT2, > + S2MPG10_PMIC_B4M_CTRL, > + S2MPG10_PMIC_B4M_OUT1, > + S2MPG10_PMIC_B4M_OUT2, > + S2MPG10_PMIC_B5M_CTRL, > + S2MPG10_PMIC_B5M_OUT1, > + S2MPG10_PMIC_B5M_OUT2, > + S2MPG10_PMIC_B6M_CTRL, > + S2MPG10_PMIC_B6M_OUT1, > + S2MPG10_PMIC_B6M_OUT2, > + S2MPG10_PMIC_B7M_CTRL, > + S2MPG10_PMIC_B7M_OUT1, > + S2MPG10_PMIC_B7M_OUT2, > + S2MPG10_PMIC_B8M_CTRL, > + S2MPG10_PMIC_B8M_OUT1, > + S2MPG10_PMIC_B8M_OUT2, > + S2MPG10_PMIC_B9M_CTRL, > + S2MPG10_PMIC_B9M_OUT1, > + S2MPG10_PMIC_B9M_OUT2, > + S2MPG10_PMIC_B10M_CTRL, > + S2MPG10_PMIC_B10M_OUT1, > + S2MPG10_PMIC_B10M_OUT2, > + S2MPG10_PMIC_BUCK1M_USONIC, > + S2MPG10_PMIC_BUCK2M_USONIC, > + S2MPG10_PMIC_BUCK3M_USONIC, > + S2MPG10_PMIC_BUCK4M_USONIC, > + S2MPG10_PMIC_BUCK5M_USONIC, > + S2MPG10_PMIC_BUCK6M_USONIC, > + S2MPG10_PMIC_BUCK7M_USONIC, > + S2MPG10_PMIC_BUCK8M_USONIC, > + S2MPG10_PMIC_BUCK9M_USONIC, > + S2MPG10_PMIC_BUCK10M_USONIC, > + S2MPG10_PMIC_L1M_CTRL, > + S2MPG10_PMIC_L2M_CTRL, > + S2MPG10_PMIC_L3M_CTRL, > + S2MPG10_PMIC_L4M_CTRL, > + S2MPG10_PMIC_L5M_CTRL, > + S2MPG10_PMIC_L6M_CTRL, > + S2MPG10_PMIC_L7M_CTRL, > + S2MPG10_PMIC_L8M_CTRL, > + S2MPG10_PMIC_L9M_CTRL, > + S2MPG10_PMIC_L10M_CTRL, > + S2MPG10_PMIC_L11M_CTRL1, > + S2MPG10_PMIC_L11M_CTRL2, > + S2MPG10_PMIC_L12M_CTRL1, > + S2MPG10_PMIC_L12M_CTRL2, > + S2MPG10_PMIC_L13M_CTRL1, > + S2MPG10_PMIC_L13M_CTRL2, > + S2MPG10_PMIC_L14M_CTRL, > + S2MPG10_PMIC_L15M_CTRL1, > + S2MPG10_PMIC_L15M_CTRL2, > + S2MPG10_PMIC_L16M_CTRL, > + S2MPG10_PMIC_L17M_CTRL, > + S2MPG10_PMIC_L18M_CTRL, > + S2MPG10_PMIC_L19M_CTRL, > + S2MPG10_PMIC_L20M_CTRL, > + S2MPG10_PMIC_L21M_CTRL, > + S2MPG10_PMIC_L22M_CTRL, > + S2MPG10_PMIC_L23M_CTRL, > + S2MPG10_PMIC_L24M_CTRL, > + S2MPG10_PMIC_L25M_CTRL, > + S2MPG10_PMIC_L26M_CTRL, > + S2MPG10_PMIC_L27M_CTRL, > + S2MPG10_PMIC_L28M_CTRL, > + S2MPG10_PMIC_L29M_CTRL, > + S2MPG10_PMIC_L30M_CTRL, > + S2MPG10_PMIC_L31M_CTRL, > + S2MPG10_PMIC_LDO_CTRL1, > + S2MPG10_PMIC_LDO_CTRL2, > + S2MPG10_PMIC_LDO_DSCH1, > + S2MPG10_PMIC_LDO_DSCH2, > + S2MPG10_PMIC_LDO_DSCH3, > + S2MPG10_PMIC_LDO_DSCH4, > + S2MPG10_PMIC_LDO_BUCK7M_HLIMIT, > + S2MPG10_PMIC_LDO_BUCK7M_LLIMIT, > + S2MPG10_PMIC_LDO_LDO21M_HLIMIT, > + S2MPG10_PMIC_LDO_LDO21M_LLIMIT, > + S2MPG10_PMIC_LDO_LDO11M_HLIMIT, > + S2MPG10_PMIC_DVS_RAMP1, > + S2MPG10_PMIC_DVS_RAMP2, > + S2MPG10_PMIC_DVS_RAMP3, > + S2MPG10_PMIC_DVS_RAMP4, > + S2MPG10_PMIC_DVS_RAMP5, > + S2MPG10_PMIC_DVS_RAMP6, > + S2MPG10_PMIC_DVS_SYNC_CTRL1, > + S2MPG10_PMIC_DVS_SYNC_CTRL2, > + S2MPG10_PMIC_DVS_SYNC_CTRL3, > + S2MPG10_PMIC_DVS_SYNC_CTRL4, > + S2MPG10_PMIC_DVS_SYNC_CTRL5, > + S2MPG10_PMIC_DVS_SYNC_CTRL6, > + S2MPG10_PMIC_OFF_CTRL1, > + S2MPG10_PMIC_OFF_CTRL2, > + S2MPG10_PMIC_OFF_CTRL3, > + S2MPG10_PMIC_OFF_CTRL4, > + S2MPG10_PMIC_SEQ_CTRL1, > + S2MPG10_PMIC_SEQ_CTRL2, > + S2MPG10_PMIC_SEQ_CTRL3, > + S2MPG10_PMIC_SEQ_CTRL4, > + S2MPG10_PMIC_SEQ_CTRL5, > + S2MPG10_PMIC_SEQ_CTRL6, > + S2MPG10_PMIC_SEQ_CTRL7, > + S2MPG10_PMIC_SEQ_CTRL8, > + S2MPG10_PMIC_SEQ_CTRL9, > + S2MPG10_PMIC_SEQ_CTRL10, > + S2MPG10_PMIC_SEQ_CTRL11, > + S2MPG10_PMIC_SEQ_CTRL12, > + S2MPG10_PMIC_SEQ_CTRL13, > + S2MPG10_PMIC_SEQ_CTRL14, > + S2MPG10_PMIC_SEQ_CTRL15, > + S2MPG10_PMIC_SEQ_CTRL16, > + S2MPG10_PMIC_SEQ_CTRL17, > + S2MPG10_PMIC_SEQ_CTRL18, > + S2MPG10_PMIC_SEQ_CTRL19, > + S2MPG10_PMIC_SEQ_CTRL20, > + S2MPG10_PMIC_SEQ_CTRL21, > + S2MPG10_PMIC_SEQ_CTRL22, > + S2MPG10_PMIC_SEQ_CTRL23, > + S2MPG10_PMIC_SEQ_CTRL24, > + S2MPG10_PMIC_SEQ_CTRL25, > + S2MPG10_PMIC_SEQ_CTRL26, > + S2MPG10_PMIC_SEQ_CTRL27, > + S2MPG10_PMIC_SEQ_CTRL28, > + S2MPG10_PMIC_SEQ_CTRL29, > + S2MPG10_PMIC_SEQ_CTRL30, > + S2MPG10_PMIC_SEQ_CTRL31, > + S2MPG10_PMIC_SEQ_CTRL32, > + S2MPG10_PMIC_SEQ_CTRL33, > + S2MPG10_PMIC_SEQ_CTRL34, > + S2MPG10_PMIC_SEQ_CTRL35, > + S2MPG10_PMIC_OFF_SEQ_CTRL1, > + S2MPG10_PMIC_OFF_SEQ_CTRL2, > + S2MPG10_PMIC_OFF_SEQ_CTRL3, > + S2MPG10_PMIC_OFF_SEQ_CTRL4, > + S2MPG10_PMIC_OFF_SEQ_CTRL5, > + S2MPG10_PMIC_OFF_SEQ_CTRL6, > + S2MPG10_PMIC_OFF_SEQ_CTRL7, > + S2MPG10_PMIC_OFF_SEQ_CTRL8, > + S2MPG10_PMIC_OFF_SEQ_CTRL9, > + S2MPG10_PMIC_OFF_SEQ_CTRL10, > + S2MPG10_PMIC_OFF_SEQ_CTRL11, > + S2MPG10_PMIC_OFF_SEQ_CTRL12, > + S2MPG10_PMIC_OFF_SEQ_CTRL13, > + S2MPG10_PMIC_OFF_SEQ_CTRL14, > + S2MPG10_PMIC_OFF_SEQ_CTRL15, > + S2MPG10_PMIC_OFF_SEQ_CTRL16, > + S2MPG10_PMIC_OFF_SEQ_CTRL17, > + S2MPG10_PMIC_OFF_SEQ_CTRL18, > + S2MPG10_PMIC_PCTRLSEL1, > + S2MPG10_PMIC_PCTRLSEL2, > + S2MPG10_PMIC_PCTRLSEL3, > + S2MPG10_PMIC_PCTRLSEL4, > + S2MPG10_PMIC_PCTRLSEL5, > + S2MPG10_PMIC_PCTRLSEL6, > + S2MPG10_PMIC_PCTRLSEL7, > + S2MPG10_PMIC_PCTRLSEL8, > + S2MPG10_PMIC_PCTRLSEL9, > + S2MPG10_PMIC_PCTRLSEL10, > + S2MPG10_PMIC_PCTRLSEL11, > + S2MPG10_PMIC_PCTRLSEL12, > + S2MPG10_PMIC_PCTRLSEL13, > + S2MPG10_PMIC_DCTRLSEL1, > + S2MPG10_PMIC_DCTRLSEL2, > + S2MPG10_PMIC_DCTRLSEL3, > + S2MPG10_PMIC_DCTRLSEL4, > + S2MPG10_PMIC_DCTRLSEL5, > + S2MPG10_PMIC_DCTRLSEL6, > + S2MPG10_PMIC_DCTRLSEL7, > + S2MPG10_PMIC_GPIO_CTRL1, > + S2MPG10_PMIC_GPIO_CTRL2, > + S2MPG10_PMIC_GPIO_CTRL3, > + S2MPG10_PMIC_GPIO_CTRL4, > + S2MPG10_PMIC_GPIO_CTRL5, > + S2MPG10_PMIC_GPIO_CTRL6, > + S2MPG10_PMIC_GPIO_CTRL7, > + S2MPG10_PMIC_B2M_OCP_WARN, > + S2MPG10_PMIC_B2M_OCP_WARN_X, > + S2MPG10_PMIC_B2M_OCP_WARN_Y, > + S2MPG10_PMIC_B2M_OCP_WARN_Z, > + S2MPG10_PMIC_B3M_OCP_WARN, > + S2MPG10_PMIC_B3M_OCP_WARN_X, > + S2MPG10_PMIC_B3M_OCP_WARN_Y, > + S2MPG10_PMIC_B3M_OCP_WARN_Z, > + S2MPG10_PMIC_B10M_OCP_WARN, > + S2MPG10_PMIC_B10M_OCP_WARN_X, > + S2MPG10_PMIC_B10M_OCP_WARN_Y, > + S2MPG10_PMIC_B10M_OCP_WARN_Z, > + S2MPG10_PMIC_B2M_SOFT_OCP_WARN, > + S2MPG10_PMIC_B2M_SOFT_OCP_WARN_X, > + S2MPG10_PMIC_B2M_SOFT_OCP_WARN_Y, > + S2MPG10_PMIC_B2M_SOFT_OCP_WARN_Z, > + S2MPG10_PMIC_B3M_SOFT_OCP_WARN, > + S2MPG10_PMIC_B3M_SOFT_OCP_WARN_X, > + S2MPG10_PMIC_B3M_SOFT_OCP_WARN_Y, > + S2MPG10_PMIC_B3M_SOFT_OCP_WARN_Z, > + S2MPG10_PMIC_B10M_SOFT_OCP_WARN, > + S2MPG10_PMIC_B10M_SOFT_OCP_WARN_X, > + S2MPG10_PMIC_B10M_SOFT_OCP_WARN_Y, > + S2MPG10_PMIC_B10M_SOFT_OCP_WARN_Z, > + S2MPG10_PMIC_BUCK_OCP_EN1, > + S2MPG10_PMIC_BUCK_OCP_EN2, > + S2MPG10_PMIC_BUCK_OCP_PD_EN1, > + S2MPG10_PMIC_BUCK_OCP_PD_EN2, > + S2MPG10_PMIC_BUCK_OCP_CTRL1, > + S2MPG10_PMIC_BUCK_OCP_CTRL2, > + S2MPG10_PMIC_BUCK_OCP_CTRL3, > + S2MPG10_PMIC_BUCK_OCP_CTRL4, > + S2MPG10_PMIC_BUCK_OCP_CTRL5, > + S2MPG10_PMIC_PIF_CTRL, > + S2MPG10_PMIC_BUCK_HR_MODE1, > + S2MPG10_PMIC_BUCK_HR_MODE2, > + S2MPG10_PMIC_FAULTOUT_CTRL, > + S2MPG10_PMIC_LDO_SENSE1, > + S2MPG10_PMIC_LDO_SENSE2, > + S2MPG10_PMIC_LDO_SENSE3, > + S2MPG10_PMIC_LDO_SENSE4, > +}; > + > +/* Meter registers (type 0xa00) */ > +enum s2mpg10_meter_reg { > + S2MPG10_METER_CTRL1, > + S2MPG10_METER_CTRL2, > + S2MPG10_METER_CTRL3, > + S2MPG10_METER_CTRL4, > + S2MPG10_METER_BUCKEN1, > + S2MPG10_METER_BUCKEN2, > + S2MPG10_METER_MUXSEL0, > + S2MPG10_METER_MUXSEL1, > + S2MPG10_METER_MUXSEL2, > + S2MPG10_METER_MUXSEL3, > + S2MPG10_METER_MUXSEL4, > + S2MPG10_METER_MUXSEL5, > + S2MPG10_METER_MUXSEL6, > + S2MPG10_METER_MUXSEL7, > + S2MPG10_METER_LPF_C0_0, > + S2MPG10_METER_LPF_C0_1, > + S2MPG10_METER_LPF_C0_2, > + S2MPG10_METER_LPF_C0_3, > + S2MPG10_METER_LPF_C0_4, > + S2MPG10_METER_LPF_C0_5, > + S2MPG10_METER_LPF_C0_6, > + S2MPG10_METER_LPF_C0_7, > + S2MPG10_METER_PWR_WARN0, > + S2MPG10_METER_PWR_WARN1, > + S2MPG10_METER_PWR_WARN2, > + S2MPG10_METER_PWR_WARN3, > + S2MPG10_METER_PWR_WARN4, > + S2MPG10_METER_PWR_WARN5, > + S2MPG10_METER_PWR_WARN6, > + S2MPG10_METER_PWR_WARN7, > + S2MPG10_METER_PWR_HYS1, > + S2MPG10_METER_PWR_HYS2, > + S2MPG10_METER_PWR_HYS3, > + S2MPG10_METER_PWR_HYS4, > + S2MPG10_METER_ACC_DATA_CH0_1 = 0x40, > + S2MPG10_METER_ACC_DATA_CH0_2, > + S2MPG10_METER_ACC_DATA_CH0_3, > + S2MPG10_METER_ACC_DATA_CH0_4, > + S2MPG10_METER_ACC_DATA_CH0_5, > + S2MPG10_METER_ACC_DATA_CH0_6, > + S2MPG10_METER_ACC_DATA_CH1_1, > + S2MPG10_METER_ACC_DATA_CH1_2, > + S2MPG10_METER_ACC_DATA_CH1_3, > + S2MPG10_METER_ACC_DATA_CH1_4, > + S2MPG10_METER_ACC_DATA_CH1_5, > + S2MPG10_METER_ACC_DATA_CH1_6, > + S2MPG10_METER_ACC_DATA_CH2_1, > + S2MPG10_METER_ACC_DATA_CH2_2, > + S2MPG10_METER_ACC_DATA_CH2_3, > + S2MPG10_METER_ACC_DATA_CH2_4, > + S2MPG10_METER_ACC_DATA_CH2_5, > + S2MPG10_METER_ACC_DATA_CH2_6, > + S2MPG10_METER_ACC_DATA_CH3_1, > + S2MPG10_METER_ACC_DATA_CH3_2, > + S2MPG10_METER_ACC_DATA_CH3_3, > + S2MPG10_METER_ACC_DATA_CH3_4, > + S2MPG10_METER_ACC_DATA_CH3_5, > + S2MPG10_METER_ACC_DATA_CH3_6, > + S2MPG10_METER_ACC_DATA_CH4_1, > + S2MPG10_METER_ACC_DATA_CH4_2, > + S2MPG10_METER_ACC_DATA_CH4_3, > + S2MPG10_METER_ACC_DATA_CH4_4, > + S2MPG10_METER_ACC_DATA_CH4_5, > + S2MPG10_METER_ACC_DATA_CH4_6, > + S2MPG10_METER_ACC_DATA_CH5_1, > + S2MPG10_METER_ACC_DATA_CH5_2, > + S2MPG10_METER_ACC_DATA_CH5_3, > + S2MPG10_METER_ACC_DATA_CH5_4, > + S2MPG10_METER_ACC_DATA_CH5_5, > + S2MPG10_METER_ACC_DATA_CH5_6, > + S2MPG10_METER_ACC_DATA_CH6_1, > + S2MPG10_METER_ACC_DATA_CH6_2, > + S2MPG10_METER_ACC_DATA_CH6_3, > + S2MPG10_METER_ACC_DATA_CH6_4, > + S2MPG10_METER_ACC_DATA_CH6_5, > + S2MPG10_METER_ACC_DATA_CH6_6, > + S2MPG10_METER_ACC_DATA_CH7_1, > + S2MPG10_METER_ACC_DATA_CH7_2, > + S2MPG10_METER_ACC_DATA_CH7_3, > + S2MPG10_METER_ACC_DATA_CH7_4, > + S2MPG10_METER_ACC_DATA_CH7_5, > + S2MPG10_METER_ACC_DATA_CH7_6, > + S2MPG10_METER_ACC_COUNT_1, > + S2MPG10_METER_ACC_COUNT_2, > + S2MPG10_METER_ACC_COUNT_3, > + S2MPG10_METER_LPF_DATA_CH0_1, > + S2MPG10_METER_LPF_DATA_CH0_2, > + S2MPG10_METER_LPF_DATA_CH0_3, > + S2MPG10_METER_LPF_DATA_CH1_1, > + S2MPG10_METER_LPF_DATA_CH1_2, > + S2MPG10_METER_LPF_DATA_CH1_3, > + S2MPG10_METER_LPF_DATA_CH2_1, > + S2MPG10_METER_LPF_DATA_CH2_2, > + S2MPG10_METER_LPF_DATA_CH2_3, > + S2MPG10_METER_LPF_DATA_CH3_1, > + S2MPG10_METER_LPF_DATA_CH3_2, > + S2MPG10_METER_LPF_DATA_CH3_3, > + S2MPG10_METER_LPF_DATA_CH4_1, > + S2MPG10_METER_LPF_DATA_CH4_2, > + S2MPG10_METER_LPF_DATA_CH4_3, > + S2MPG10_METER_LPF_DATA_CH5_1, > + S2MPG10_METER_LPF_DATA_CH5_2, > + S2MPG10_METER_LPF_DATA_CH5_3, > + S2MPG10_METER_LPF_DATA_CH6_1, > + S2MPG10_METER_LPF_DATA_CH6_2, > + S2MPG10_METER_LPF_DATA_CH6_3, > + S2MPG10_METER_LPF_DATA_CH7_1, > + S2MPG10_METER_LPF_DATA_CH7_2, > + S2MPG10_METER_LPF_DATA_CH7_3, > + S2MPG10_METER_DSM_TRIM_OFFSET = 0xee, > + S2MPG10_METER_BUCK_METER_TRIM3 = 0xf1, > +}; > + > +/* S2MPG10 regulator IDs */ > +enum s2mpg10_regulators { > + S2MPG10_LDO1, > + S2MPG10_LDO2, > + S2MPG10_LDO3, > + S2MPG10_LDO4, > + S2MPG10_LDO5, > + S2MPG10_LDO6, > + S2MPG10_LDO7, > + S2MPG10_LDO8, > + S2MPG10_LDO9, > + S2MPG10_LDO10, > + S2MPG10_LDO11, > + S2MPG10_LDO12, > + S2MPG10_LDO13, > + S2MPG10_LDO14, > + S2MPG10_LDO15, > + S2MPG10_LDO16, > + S2MPG10_LDO17, > + S2MPG10_LDO18, > + S2MPG10_LDO19, > + S2MPG10_LDO20, > + S2MPG10_LDO21, > + S2MPG10_LDO22, > + S2MPG10_LDO23, > + S2MPG10_LDO24, > + S2MPG10_LDO25, > + S2MPG10_LDO26, > + S2MPG10_LDO27, > + S2MPG10_LDO28, > + S2MPG10_LDO29, > + S2MPG10_LDO30, > + S2MPG10_LDO31, > + S2MPG10_BUCK1, > + S2MPG10_BUCK2, > + S2MPG10_BUCK3, > + S2MPG10_BUCK4, > + S2MPG10_BUCK5, > + S2MPG10_BUCK6, > + S2MPG10_BUCK7, > + S2MPG10_BUCK8, > + S2MPG10_BUCK9, > + S2MPG10_BUCK10, > + S2MPG10_REGULATOR_MAX, > +}; > + > +#endif /* __LINUX_MFD_S2MPG10_H */ > > -- > 2.49.0.472.ge94155a9ec-goog >
On Thu, 03 Apr 2025, André Draszik wrote: > checkpatch complains about unexpected alignment issues in this file - Fine, but either call it by it's name 'Checkpatch' or the command 'checkpatch.pl'. > update the code accordingly. This phrasing and grammar is odd. How about? Subject: mfd: sec-common: Fix multiple trivial whitespace issues Rectify a couple of alignment problems reported by Checkpatch. > Signed-off-by: André Draszik <andre.draszik@linaro.org> > > --- > v2: > * make new alignment more readable (Krzysztof) > --- > drivers/mfd/sec-common.c | 8 ++++---- > 1 file changed, 4 insertions(+), 4 deletions(-) > > diff --git a/drivers/mfd/sec-common.c b/drivers/mfd/sec-common.c > index 782dec1956a5fd7bf0dbb2159f9d222ad3fea942..1a6f14dda825adeaeee1a677459c7399c144d553 100644 > --- a/drivers/mfd/sec-common.c > +++ b/drivers/mfd/sec-common.c > @@ -149,9 +149,9 @@ sec_pmic_parse_dt_pdata(struct device *dev) > return ERR_PTR(-ENOMEM); > > pd->manual_poweroff = of_property_read_bool(dev->of_node, > - "samsung,s2mps11-acokb-ground"); > + "samsung,s2mps11-acokb-ground"); > pd->disable_wrstbi = of_property_read_bool(dev->of_node, > - "samsung,s2mps11-wrstbi-ground"); > + "samsung,s2mps11-wrstbi-ground"); > return pd; > } > > @@ -264,8 +264,8 @@ void sec_pmic_shutdown(struct device *dev) > * ignore the rest. > */ > dev_warn(sec_pmic->dev, > - "Unsupported device %lu for manual power off\n", > - sec_pmic->device_type); > + "Unsupported device %lu for manual power off\n", > + sec_pmic->device_type); > return; > } > > > -- > 2.49.0.472.ge94155a9ec-goog >
Patch is fine, but the subject line should be more assertive. Also, there is seldom any need for sub-sentences in ()'s in them. IOW, drop the "(it seems)" part. > The commit bf231e5febcf ("mfd: sec-core: Add support for the Samsung > s2dos05") adding s2dos05 support didn't add anything related to IRQ > support, so I assume this works without IRQs. > > Rather than printing a warning message in sec_irq_init() due to the > missing IRQ number, or returning an error due to a missing irq chip > regmap, just return early explicitly. > > This will become particularly important once errors from sec_irq_init() > aren't ignored anymore in an upcoming patch and helps the reader of > this code while reasoning about what the intention might be here. > > Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> > Signed-off-by: André Draszik <andre.draszik@linaro.org> > --- > drivers/mfd/sec-irq.c | 14 ++++++++------ > 1 file changed, 8 insertions(+), 6 deletions(-) > > diff --git a/drivers/mfd/sec-irq.c b/drivers/mfd/sec-irq.c > index 9f0173c48b0c8186a2cdc1d2179db081ef2e09c4..79a3b33441fa5ab48b4b233eb8d89b4c20c142ed 100644 > --- a/drivers/mfd/sec-irq.c > +++ b/drivers/mfd/sec-irq.c > @@ -452,16 +452,12 @@ int sec_irq_init(struct sec_pmic_dev *sec_pmic) > int type = sec_pmic->device_type; > const struct regmap_irq_chip *sec_irq_chip; > > - if (!sec_pmic->irq) { > - dev_warn(sec_pmic->dev, > - "No interrupt specified, no interrupts\n"); > - return 0; > - } > - > switch (type) { > case S5M8767X: > sec_irq_chip = &s5m8767_irq_chip; > break; > + case S2DOS05: > + return 0; > case S2MPA01: > sec_irq_chip = &s2mps14_irq_chip; > break; > @@ -492,6 +488,12 @@ int sec_irq_init(struct sec_pmic_dev *sec_pmic) > sec_pmic->device_type); > } > > + if (!sec_pmic->irq) { > + dev_warn(sec_pmic->dev, > + "No interrupt specified, no interrupts\n"); > + return 0; > + } > + > ret = devm_regmap_add_irq_chip(sec_pmic->dev, sec_pmic->regmap_pmic, > sec_pmic->irq, IRQF_ONESHOT, > 0, sec_irq_chip, &sec_pmic->irq_data); > > -- > 2.49.0.472.ge94155a9ec-goog >
On Thu, 03 Apr 2025, André Draszik wrote: > This series adds initial support for the Samsung S2MPG10 PMIC using the > MFD framework. This is a PMIC for mobile applications and is used on > the Google Pixel 6 and 6 Pro (oriole / raven). Okay, review complete. If I didn't comment on a patch, it means I didn't see any issues with it. However, saying that, it doesn't mean I won't spot something next time. :)
On Thu, Apr 03, 2025 at 09:58:55AM GMT, André Draszik wrote: > The PMIC is supposed to be a child of ACPM, add it here to describe the > connection. > > Signed-off-by: André Draszik <andre.draszik@linaro.org> > > --- > v3: > - drop '$ref' and 'unevaluatedProperties' from pmic subnode, use > 'additionalProperties' instead (Krzysztof) > - add some regulators to examples since s2mpg10 requires them as of v3 > --- > .../bindings/firmware/google,gs101-acpm-ipc.yaml | 35 ++++++++++++++++++++++ > 1 file changed, 35 insertions(+) Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> Best regards, Krzysztof
On Fri, 2025-04-04 at 10:42 +0100, Lee Jones wrote: > On Thu, 03 Apr 2025, André Draszik wrote: > > > Add myself as module author, so people know whom to complain to about > > after the recent updates :-) > > Full-stop. > > Smiley faces might be okay on the list, but not sure we want them in > commit messages. OK. > > > Signed-off-by: André Draszik <andre.draszik@linaro.org> > > --- > > drivers/mfd/sec-common.c | 1 + > > drivers/mfd/sec-i2c.c | 1 + > > 2 files changed, 2 insertions(+) > > > > diff --git a/drivers/mfd/sec-common.c b/drivers/mfd/sec-common.c > > index 448300ab547c10d81f9f2b2798d54c8a03c714d8..05658f05cb857a784c7d01b1cf25de4870e1a95e 100644 > > --- a/drivers/mfd/sec-common.c > > +++ b/drivers/mfd/sec-common.c > > @@ -293,6 +293,7 @@ static int sec_pmic_resume(struct device *dev) > > DEFINE_SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume); > > EXPORT_SYMBOL_GPL(sec_pmic_pm_ops); > > > > +MODULE_AUTHOR("André Draszik <andre.draszik@linaro.org>"); > > Might be more polite to put yourself at the bottom. > > Not sure these are ordered alphabetically on purpose. Yes, I wanted to keep the alphabetical order (by first name), no ill intention here. Will do. Cheers, A. > > > MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>"); > > MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>"); > > MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
On Fri, 2025-04-04 at 10:30 +0100, Lee Jones wrote: > On Thu, 03 Apr 2025, André Draszik wrote: > > > This series adds initial support for the Samsung S2MPG10 PMIC using the > > MFD framework. This is a PMIC for mobile applications and is used on > > the Google Pixel 6 and 6 Pro (oriole / raven). > > When you resubmit these, please note that MFD subjects take the form: > > mfd: <file>: Succinct change description starting with an uppercase char I've followed your suggestion regarding the prefix when patches touch just one file, but for patches that touch multiple files, I've kept the 'mfd: sec:' prefix, e.g. in patch 18. Hope that's OK. Cheers, Andre'
This series adds initial support for the Samsung S2MPG10 PMIC using the MFD framework. This is a PMIC for mobile applications and is used on the Google Pixel 6 and 6 Pro (oriole / raven). *** dependency note *** To compile, this depends on the Samsung ACPM driver in Linux next with the following additional patches: https://lore.kernel.org/all/20250324-acpm-atomic-v2-0-7d87746e1765@linaro.org/ https://lore.kernel.org/all/20250319-acpm-fixes-v2-0-ac2c1bcf322b@linaro.org/ https://lore.kernel.org/all/20250327-acpm-children-v1-0-0afe15ee2ff7@linaro.org/ *** dependency note end *** +++ Kconfig update +++ There is a Kconfig symbol update in this series, because the existing Samsung S2M driver has been split into core and transport (I2C & ACPM) parts. CONFIG_MFD_SEC_CORE is now truly a core driver, and the I2C code that was part of it is now enabled via CONFIG_MFD_SEC_I2C. This was necessary because unlike the other S2M PMICs, S2MPG10 doesn't talk via I2C, but via the Samsung ACPM firmware. +++ Kconfig update end +++ This series must be applied in-order, due to interdependencies of some of the patches. There are also various cleanup patches to the S2M drivers. I've kept them ordered as: * DT bindings (patches 1 ... 3) * s2m mfd prep for adding S2MPG10 support (patches 4 ... 7) * split S2M mfd driver into s2m-core and s2m-i2c, including the kconfig symbol update (patch 8) * S2MPG10 core driver (patch 9) * s2m mfd driver cleanup patches (patches 10 ... 23) * S2MPG10 clock driver (patch 24) * s2m RTC prep for adding S2MPG10 (patch 25 ... 26) * S2MPG10 RTC driver (patch 27) * s2m RTC cleanup patches (patches 28 ... 31) I realise these are many, but since some prep-work was required to be able to add S2MPG anyway, I wanted to get the cleanup patches in as well :-) Let me know if I should postpone them to a later date instead. The S2MPG10 includes buck converters, various LDOs, power meters, RTC, clock outputs, and additional GPIOs interfaces. This series adds support in the top-level device driver, and for the RTC and clock. Importantly, having the RTC driver allows to do a proper reset of the system. Drivers or driver updates for the other components will be added in future patches. This will need a DT update for Oriole / Raven to enable this device. I will send that out separately. Cheers, Andre' Signed-off-by: André Draszik <andre.draszik@linaro.org> --- Changes in v3: - Krzysztof: - keep 'regulators' subnode required even for s2mpg10 - drop '$ref' and 'unevaluatedProperties' from pmic subnode, use 'additionalProperties' instead - add some regulators to examples since s2mpg10 requires them as of v3 - sec-acpm: - use an enum for struct sec_acpm_bus_context::type - consistent name space for all functions sec_pmic_acpm_... to be similar to i2c and consistent in this file - Link to v2: https://lore.kernel.org/r/20250328-s2mpg10-v2-0-b54dee33fb6b@linaro.org Changes in v2: - Rob: - make PMIC node a child of ACPM, and all related changes (binding, driver) - Krzysztof: - merge defconfig updates into patch changing the symbols (patch 8) - split MODULE_AUTHOR update into a separate patch - better alignment fix (patch 11) - merge two s2dos05/s2mpu05 related patches into one (patch 14) - myself: - keep PMIC DT parsing in core, not in transport driver - several updates in sec-acpm.c, see separate entries in patch 9 - fix typo in patch 17 - collect tags - Link to v1: https://lore.kernel.org/r/20250323-s2mpg10-v1-0-d08943702707@linaro.org --- André Draszik (32): dt-bindings: mfd: samsung,s2mps11: add s2mpg10 dt-bindings: clock: samsung,s2mps11: add s2mpg10 dt-bindings: firmware: google,gs101-acpm-ipc: add PMIC child node mfd: sec: drop non-existing forward declarations mfd: sec: sort includes alphabetically mfd: sec: update includes to add missing and remove superfluous ones mfd: sec: move private internal API to internal header mfd: sec: split into core and transport (i2c) drivers mfd: sec: add support for S2MPG10 PMIC mfd: sec: merge separate core and irq modules mfd: sec: fix open parenthesis alignment (multiple) mfd: sec: sort struct of_device_id entries and the device type switch mfd: sec: use dev_err_probe() where appropriate mfd: sec: s2dos05/s2mpu05: use explicit regmap config and drop default mfd: sec: s2dos05: doesn't support interrupts (it seems) mfd: sec: don't ignore errors from sec_irq_init() mfd: sec: rework platform data and regmap instantiating mfd: sec: change device_type to int mfd: sec: don't compare against NULL / 0 for errors, use ! mfd: sec: use sizeof(*var), not sizeof(struct type_of_var) mfd: sec: convert to using MFD_CELL macros mfd: sec: convert to using REGMAP_IRQ_REG() macros mfd: sec: add myself as module author clk: s2mps11: add support for S2MPG10 PMIC clock rtc: s5m: cache value of platform_get_device_id() during probe rtc: s5m: prepare for external regmap rtc: s5m: add support for S2MPG10 RTC rtc: s5m: fix a typo: peding -> pending rtc: s5m: switch to devm_device_init_wakeup rtc: s5m: replace regmap_update_bits with regmap_clear/set_bits rtc: s5m: replace open-coded read/modify/write registers with regmap helpers MAINTAINERS: add myself as reviewer for Samsung S2M MFD .../devicetree/bindings/clock/samsung,s2mps11.yaml | 1 + .../bindings/firmware/google,gs101-acpm-ipc.yaml | 35 ++ .../devicetree/bindings/mfd/samsung,s2mps11.yaml | 26 +- MAINTAINERS | 3 +- arch/arm/configs/exynos_defconfig | 2 +- arch/arm/configs/multi_v7_defconfig | 2 +- arch/arm/configs/pxa_defconfig | 2 +- arch/arm64/configs/defconfig | 2 +- drivers/clk/clk-s2mps11.c | 8 + drivers/mfd/Kconfig | 35 +- drivers/mfd/Makefile | 5 +- drivers/mfd/sec-acpm.c | 465 ++++++++++++++++++++ drivers/mfd/sec-common.c | 301 +++++++++++++ drivers/mfd/sec-core.c | 481 --------------------- drivers/mfd/sec-core.h | 23 + drivers/mfd/sec-i2c.c | 239 ++++++++++ drivers/mfd/sec-irq.c | 460 +++++++------------- drivers/rtc/rtc-s5m.c | 197 ++++++--- include/linux/mfd/samsung/core.h | 7 +- include/linux/mfd/samsung/irq.h | 103 +++++ include/linux/mfd/samsung/rtc.h | 37 ++ include/linux/mfd/samsung/s2mpg10.h | 454 +++++++++++++++++++ 22 files changed, 2024 insertions(+), 864 deletions(-) --- base-commit: f58dd835f82a5dda6c9d3895ee6f15016431fb1f change-id: 20250321-s2mpg10-ef5d1ebd3043 Best regards,