--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// SGMicro SGM3804 regulator Driver
+//
+// Copyright (C) 2025 Kancy Joe <kancy2333@outlook.com>
+// Copyright (C) 2026 Linaro Limited
+// Author: Neil Armstrong <neil.armstrong@linaro.org>
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/gpio/consumer.h>
+
+#define SGM3804_POS_RAIL_VOLTAGE_REG 0x0
+#define SGM3804_NEG_RAIL_VOLTAGE_REG 0x1
+#define SGM3804_RAIL_DISCHARGE_REG 0x3
+
+#define RAIL_VOLTAGE_MASK GENMASK(5, 0)
+
+#define POS_RAIL_DISCHARGE_EN BIT(1)
+#define NEG_RAIL_DISCHARGE_EN BIT(0)
+
+#define RAIL_VOLTAGE_INVALID RAIL_VOLTAGE_MASK
+#define RAIL_DISCHARGE_REG_DEFAULT (POS_RAIL_DISCHARGE_EN | NEG_RAIL_DISCHARGE_EN)
+
+#define SGM3804_VOLTAGES_MAX_SELECTOR 0x2f
+
+enum {
+ SGM3804_POS_RAIL = 0,
+ SGM3804_NEG_RAIL,
+ SGM3804_RAIL_COUNT,
+};
+
+/*
+ * The registers are only writable when the gpio is enabled, so
+ * we need to use the cache for read operations and set the regmap
+ * as cache_only when both GPIOs are down.
+ */
+struct sgm3804_data {
+ struct regmap *regmap;
+ /* Protects the regcache state update */
+ struct mutex lock;
+ struct gpio_desc *gpios[SGM3804_RAIL_COUNT];
+};
+
+static const struct linear_range sgm3804_voltages[] = {
+ REGULATOR_LINEAR_RANGE(2400000, 0x20, 0x2f, 100000),
+ REGULATOR_LINEAR_RANGE(4000000, 0x00, 0x17, 100000),
+};
+
+/*
+ * The cache is populated with those hardware default values
+ * so the regmap_update_bits operation will use the cached
+ * value to build a new register value and write it when GPIOs
+ * are enabled.
+ */
+static const struct reg_default sgm3804_reg_defaults[] = {
+ { SGM3804_POS_RAIL_VOLTAGE_REG, RAIL_VOLTAGE_INVALID },
+ { SGM3804_NEG_RAIL_VOLTAGE_REG, RAIL_VOLTAGE_INVALID },
+ { SGM3804_RAIL_DISCHARGE_REG, RAIL_DISCHARGE_REG_DEFAULT },
+};
+
+/* Registers are only writable */
+static bool sgm3804_writeable_reg(struct device *dev, unsigned int reg)
+{
+ switch (reg) {
+ case SGM3804_POS_RAIL_VOLTAGE_REG:
+ case SGM3804_NEG_RAIL_VOLTAGE_REG:
+ case SGM3804_RAIL_DISCHARGE_REG:
+ return true;
+ default:
+ return false;
+ }
+}
+
+/*
+ * Since all registers are only writeable, regmap will only read from the cache data.
+ */
+static bool sgm3804_readable_reg(struct device *dev, unsigned int reg)
+{
+ return false;
+}
+
+static const struct regmap_config sgm3804_regmap_config = {
+ .reg_bits = 8,
+ .val_bits = 8,
+ .max_register = 0x03,
+ .writeable_reg = sgm3804_writeable_reg,
+ .readable_reg = sgm3804_readable_reg,
+ .cache_type = REGCACHE_MAPLE,
+ .reg_defaults = sgm3804_reg_defaults,
+ .num_reg_defaults = ARRAY_SIZE(sgm3804_reg_defaults),
+};
+
+static int sgm3804_sync_regcache_state(struct sgm3804_data *ctx)
+{
+ guard(mutex)(&ctx->lock);
+
+ /* If both GPIOs are down, IC is powered down and I2C writes will fail */
+ if (!gpiod_get_value_cansleep(ctx->gpios[SGM3804_POS_RAIL]) &&
+ !gpiod_get_value_cansleep(ctx->gpios[SGM3804_NEG_RAIL])) {
+ regcache_cache_only(ctx->regmap, true);
+ regcache_mark_dirty(ctx->regmap);
+ } else {
+ int ret;
+
+ /* At least a GPIO is up, we can write registers */
+ regcache_cache_only(ctx->regmap, false);
+ ret = regcache_sync(ctx->regmap);
+ if (ret) {
+ regcache_cache_only(ctx->regmap, true);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int sgm3804_get_voltage_sel(struct regulator_dev *rdev)
+{
+ int ret;
+
+ ret = regulator_get_voltage_sel_regmap(rdev);
+ if (ret < 0)
+ return ret;
+
+ /* Force setting a voltage on probe */
+ if (ret == RAIL_VOLTAGE_INVALID)
+ return -ENOTRECOVERABLE;
+
+ return ret;
+}
+
+static int sgm3804_enable(struct regulator_dev *rdev)
+{
+ struct sgm3804_data *ctx = rdev->reg_data;
+ int ret;
+
+ ret = gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 1);
+ if (ret)
+ return ret;
+
+ ret = sgm3804_sync_regcache_state(ctx);
+ if (ret)
+ goto err;
+
+ return 0;
+
+err:
+ gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 0);
+ return ret;
+}
+
+static int sgm3804_disable(struct regulator_dev *rdev)
+{
+ struct sgm3804_data *ctx = rdev->reg_data;
+ int ret;
+
+ ret = gpiod_set_value_cansleep(ctx->gpios[rdev_get_id(rdev)], 0);
+ if (ret)
+ return ret;
+
+ return sgm3804_sync_regcache_state(ctx);
+}
+
+static int sgm3804_is_enabled(struct regulator_dev *rdev)
+{
+ struct sgm3804_data *ctx = rdev->reg_data;
+
+ return gpiod_get_value_cansleep(ctx->gpios[rdev_get_id(rdev)]);
+}
+
+static const struct regulator_ops sgm3804_ops = {
+ .list_voltage = regulator_list_voltage_linear_range,
+ .map_voltage = regulator_map_voltage_linear_range,
+ .set_voltage_sel = regulator_set_voltage_sel_regmap,
+ .get_voltage_sel = sgm3804_get_voltage_sel,
+ .set_active_discharge = regulator_set_active_discharge_regmap,
+ .enable = sgm3804_enable,
+ .disable = sgm3804_disable,
+ .is_enabled = sgm3804_is_enabled,
+};
+
+static const struct regulator_desc sgm3804_regulator_desc[] = {
+ /* Positive Output */
+ {
+ .name = "pos",
+ .of_match = "pos",
+ .supply_name = "vin",
+ .id = SGM3804_POS_RAIL,
+ .ops = &sgm3804_ops,
+ .type = REGULATOR_VOLTAGE,
+ .linear_ranges = sgm3804_voltages,
+ .n_linear_ranges = ARRAY_SIZE(sgm3804_voltages),
+ .n_voltages = SGM3804_VOLTAGES_MAX_SELECTOR + 1,
+ .vsel_reg = SGM3804_POS_RAIL_VOLTAGE_REG,
+ .vsel_mask = RAIL_VOLTAGE_MASK,
+ .active_discharge_on = POS_RAIL_DISCHARGE_EN,
+ .active_discharge_mask = POS_RAIL_DISCHARGE_EN,
+ .active_discharge_reg = SGM3804_RAIL_DISCHARGE_REG,
+ .enable_time = 40000,
+ .owner = THIS_MODULE,
+ },
+ /* Negative Output */
+ {
+ .name = "neg",
+ .of_match = "neg",
+ .supply_name = "vin",
+ .id = SGM3804_NEG_RAIL,
+ .ops = &sgm3804_ops,
+ .type = REGULATOR_VOLTAGE,
+ .linear_ranges = sgm3804_voltages,
+ .n_linear_ranges = ARRAY_SIZE(sgm3804_voltages),
+ .n_voltages = SGM3804_VOLTAGES_MAX_SELECTOR + 1,
+ .vsel_reg = SGM3804_NEG_RAIL_VOLTAGE_REG,
+ .vsel_mask = RAIL_VOLTAGE_MASK,
+ .active_discharge_on = NEG_RAIL_DISCHARGE_EN,
+ .active_discharge_mask = NEG_RAIL_DISCHARGE_EN,
+ .active_discharge_reg = SGM3804_RAIL_DISCHARGE_REG,
+ .enable_time = 40000,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int sgm3804_probe(struct i2c_client *i2c)
+{
+ struct device *dev = &i2c->dev;
+ struct sgm3804_data *ctx;
+ int ret, i;
+
+ ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
+ if (!ctx)
+ return -ENOMEM;
+
+ mutex_init(&ctx->lock);
+
+ ctx->regmap = devm_regmap_init_i2c(i2c, &sgm3804_regmap_config);
+ if (IS_ERR(ctx->regmap))
+ return dev_err_probe(dev, PTR_ERR(ctx->regmap),
+ "failed to init regmap\n");
+
+ /* Get enable GPIOs */
+ for (i = 0; i < ARRAY_SIZE(sgm3804_regulator_desc); i++) {
+ const struct regulator_desc *reg = &sgm3804_regulator_desc[i];
+ struct fwnode_handle *child;
+
+ child = device_get_named_child_node(dev, reg->of_match);
+ if (!child) {
+ dev_err(dev, "missing child '%s'\n", reg->of_match);
+ return -EINVAL;
+ }
+
+ ctx->gpios[i] = devm_fwnode_gpiod_get(dev, child, "enable",
+ GPIOD_ASIS, reg->name);
+ fwnode_handle_put(child);
+ if (IS_ERR(ctx->gpios[i]))
+ return dev_err_probe(dev, PTR_ERR(ctx->gpios[i]),
+ "failed to get '%s' enable GPIO\n",
+ reg->name);
+ }
+
+ ret = sgm3804_sync_regcache_state(ctx);
+ if (ret)
+ return ret;
+
+ for (i = 0; i < ARRAY_SIZE(sgm3804_regulator_desc); i++) {
+ struct regulator_config config = { };
+ struct regulator_dev *rdev;
+
+ config.dev = dev;
+ config.regmap = ctx->regmap;
+ config.of_node = dev_of_node(dev);
+ config.driver_data = ctx;
+ rdev = devm_regulator_register(dev, &sgm3804_regulator_desc[i],
+ &config);
+ if (IS_ERR(rdev))
+ return dev_err_probe(dev, PTR_ERR(rdev),
+ "failed to register regulator %d\n", i);
+ }
+
+ return 0;
+}
+
+static const struct i2c_device_id sgm3804_id[] = {
+ { "sgm3804" },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, sgm3804_id);
+
+static const struct of_device_id sgm3804_of_match[] = {
+ { .compatible = "sgmicro,sgm3804" },
+ { }
+};
+MODULE_DEVICE_TABLE(of, sgm3804_of_match);
+
+static struct i2c_driver sgm3804_regulator_driver = {
+ .driver = {
+ .name = "sgm3804",
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
+ .of_match_table = sgm3804_of_match,
+ },
+ .probe = sgm3804_probe,
+ .id_table = sgm3804_id,
+};
+
+module_i2c_driver(sgm3804_regulator_driver);
+
+MODULE_DESCRIPTION("SGMicro SGM3804 regulator Driver");
+MODULE_AUTHOR("Kancy Joe <kancy2333@outlook.com>");
+MODULE_AUTHOR("Neil Armstrong <neil.armstrong@linaro.org>");
+MODULE_LICENSE("GPL");
projects / thirdparty / linux.git / commitdiff
