1// SPDX-License-Identifier: GPL-2.0+
2//
3// s2dos05.c - Regulator driver for the Samsung s2dos05
4//
5// Copyright (C) 2025 Dzmitry Sankouski <dsankouski@gmail.com>
6
7#include <linux/bug.h>
8#include <linux/delay.h>
9#include <linux/err.h>
10#include <linux/slab.h>
11#include <linux/module.h>
12#include <linux/regmap.h>
13#include <linux/interrupt.h>
14#include <linux/platform_device.h>
15#include <linux/regulator/driver.h>
16#include <linux/regulator/machine.h>
17#include <linux/regulator/of_regulator.h>
18#include <linux/mfd/samsung/core.h>
19#include <linux/regulator/s2dos05.h>
20#include <linux/i2c.h>
21
22struct s2dos05_data {
23 struct regmap *regmap;
24 struct device *dev;
25};
26
27#define _BUCK(macro) S2DOS05_BUCK##macro
28#define _buck_ops(num) s2dos05_ops##num
29#define _LDO(macro) S2DOS05_LDO##macro
30#define _REG(ctrl) S2DOS05_REG##ctrl
31#define _ldo_ops(num) s2dos05_ops##num
32#define _MASK(macro) S2DOS05_ENABLE_MASK##macro
33#define _TIME(macro) S2DOS05_ENABLE_TIME##macro
34
35#define BUCK_DESC(_name, _id, _ops, m, s, v, e, em, t, a) { \
36 .name = _name, \
37 .id = _id, \
38 .ops = _ops, \
39 .of_match = of_match_ptr(_name), \
40 .of_match_full_name = true, \
41 .regulators_node = of_match_ptr("regulators"), \
42 .type = REGULATOR_VOLTAGE, \
43 .owner = THIS_MODULE, \
44 .min_uV = m, \
45 .uV_step = s, \
46 .n_voltages = S2DOS05_BUCK_N_VOLTAGES, \
47 .vsel_reg = v, \
48 .vsel_mask = S2DOS05_BUCK_VSEL_MASK, \
49 .enable_reg = e, \
50 .enable_mask = em, \
51 .enable_time = t, \
52 .active_discharge_off = 0, \
53 .active_discharge_on = S2DOS05_BUCK_FD_MASK, \
54 .active_discharge_reg = a, \
55 .active_discharge_mask = S2DOS05_BUCK_FD_MASK \
56}
57
58#define LDO_DESC(_name, _id, _ops, m, s, v, e, em, t, a) { \
59 .name = _name, \
60 .id = _id, \
61 .ops = _ops, \
62 .of_match = of_match_ptr(_name), \
63 .of_match_full_name = true, \
64 .regulators_node = of_match_ptr("regulators"), \
65 .type = REGULATOR_VOLTAGE, \
66 .owner = THIS_MODULE, \
67 .min_uV = m, \
68 .uV_step = s, \
69 .n_voltages = S2DOS05_LDO_N_VOLTAGES, \
70 .vsel_reg = v, \
71 .vsel_mask = S2DOS05_LDO_VSEL_MASK, \
72 .enable_reg = e, \
73 .enable_mask = em, \
74 .enable_time = t, \
75 .active_discharge_off = 0, \
76 .active_discharge_on = S2DOS05_LDO_FD_MASK, \
77 .active_discharge_reg = a, \
78 .active_discharge_mask = S2DOS05_LDO_FD_MASK \
79}
80
81static const struct regulator_ops s2dos05_ops = {
82 .list_voltage = regulator_list_voltage_linear,
83 .map_voltage = regulator_map_voltage_linear,
84 .is_enabled = regulator_is_enabled_regmap,
85 .enable = regulator_enable_regmap,
86 .disable = regulator_disable_regmap,
87 .get_voltage_sel = regulator_get_voltage_sel_regmap,
88 .set_voltage_sel = regulator_set_voltage_sel_regmap,
89 .set_voltage_time_sel = regulator_set_voltage_time_sel,
90 .set_active_discharge = regulator_set_active_discharge_regmap,
91};
92
93static const struct regulator_desc regulators[S2DOS05_REGULATOR_MAX] = {
94 // name, id, ops, min_uv, uV_step, vsel_reg, enable_reg
95 LDO_DESC("ldo1", _LDO(1), &_ldo_ops(), _LDO(_MIN1),
96 _LDO(_STEP1), _REG(_LDO1_CFG),
97 _REG(_EN), _MASK(_L1), _TIME(_LDO), _REG(_LDO1_CFG)),
98 LDO_DESC("ldo2", _LDO(2), &_ldo_ops(), _LDO(_MIN1),
99 _LDO(_STEP1), _REG(_LDO2_CFG),
100 _REG(_EN), _MASK(_L2), _TIME(_LDO), _REG(_LDO2_CFG)),
101 LDO_DESC("ldo3", _LDO(3), &_ldo_ops(), _LDO(_MIN2),
102 _LDO(_STEP1), _REG(_LDO3_CFG),
103 _REG(_EN), _MASK(_L3), _TIME(_LDO), _REG(_LDO3_CFG)),
104 LDO_DESC("ldo4", _LDO(4), &_ldo_ops(), _LDO(_MIN2),
105 _LDO(_STEP1), _REG(_LDO4_CFG),
106 _REG(_EN), _MASK(_L4), _TIME(_LDO), _REG(_LDO4_CFG)),
107 BUCK_DESC("buck", _BUCK(1), &_buck_ops(), _BUCK(_MIN1),
108 _BUCK(_STEP1), _REG(_BUCK_VOUT),
109 _REG(_EN), _MASK(_B1), _TIME(_BUCK), _REG(_BUCK_CFG)),
110};
111
112static int s2dos05_pmic_probe(struct platform_device *pdev)
113{
114 struct device *dev = &pdev->dev;
115 struct sec_pmic_dev *iodev = dev_get_drvdata(dev: pdev->dev.parent);
116 struct s2dos05_data *s2dos05;
117 struct regulator_config config = { };
118 unsigned int rdev_num = ARRAY_SIZE(regulators);
119
120 s2dos05 = devm_kzalloc(dev, size: sizeof(*s2dos05), GFP_KERNEL);
121 if (!s2dos05)
122 return -ENOMEM;
123
124 platform_set_drvdata(pdev, data: s2dos05);
125
126 s2dos05->regmap = iodev->regmap_pmic;
127 s2dos05->dev = dev;
128 if (!dev->of_node)
129 dev->of_node = dev->parent->of_node;
130
131 config.dev = dev;
132 config.driver_data = s2dos05;
133
134 for (int i = 0; i < rdev_num; i++) {
135 struct regulator_dev *regulator;
136
137 regulator = devm_regulator_register(dev: &pdev->dev,
138 regulator_desc: &regulators[i], config: &config);
139 if (IS_ERR(ptr: regulator)) {
140 return dev_err_probe(dev: &pdev->dev, err: PTR_ERR(ptr: regulator),
141 fmt: "regulator init failed for %d\n", i);
142 }
143 }
144
145 return 0;
146}
147
148static const struct platform_device_id s2dos05_pmic_id[] = {
149 { "s2dos05-regulator" },
150 { },
151};
152MODULE_DEVICE_TABLE(platform, s2dos05_pmic_id);
153
154static struct platform_driver s2dos05_platform_driver = {
155 .driver = {
156 .name = "s2dos05",
157 },
158 .probe = s2dos05_pmic_probe,
159 .id_table = s2dos05_pmic_id,
160};
161module_platform_driver(s2dos05_platform_driver);
162
163MODULE_AUTHOR("Dzmitry Sankouski <dsankouski@gmail.com>");
164MODULE_DESCRIPTION("Samsung S2DOS05 Regulator Driver");
165MODULE_LICENSE("GPL");
166

source code of linux/drivers/regulator/s2dos05-regulator.c