]>
Commit | Line | Data |
---|---|---|
5bbbfc7f CH |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | ||
3 | #include <linux/gpio/consumer.h> | |
4 | #include <linux/i2c.h> | |
5 | #include <linux/kernel.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/of.h> | |
8 | #include <linux/regmap.h> | |
9 | #include <linux/regulator/driver.h> | |
10 | ||
11 | #define RT4801_REG_VOP 0x00 | |
12 | #define RT4801_REG_VON 0x01 | |
13 | #define RT4801_REG_APPS 0x03 | |
14 | ||
15 | #define VOUT_MASK 0x1F | |
16 | ||
17 | #define MIN_UV 4000000 | |
18 | #define STEP_UV 100000 | |
19 | #define MAX_UV 6000000 | |
20 | #define N_VOLTAGES ((MAX_UV - MIN_UV) / STEP_UV + 1) | |
21 | ||
22 | #define DSV_OUT_POS 0 | |
23 | #define DSV_OUT_NEG 1 | |
24 | #define DSV_OUT_MAX 2 | |
25 | ||
26 | #define DSVP_ENABLE BIT(0) | |
27 | #define DSVN_ENABLE BIT(1) | |
28 | #define DSVALL_ENABLE (DSVP_ENABLE | DSVN_ENABLE) | |
29 | ||
30 | struct rt4801_priv { | |
31 | struct device *dev; | |
32 | struct gpio_descs *enable_gpios; | |
33 | unsigned int enable_flag; | |
34 | unsigned int volt_sel[DSV_OUT_MAX]; | |
35 | }; | |
36 | ||
37 | static int rt4801_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector) | |
38 | { | |
39 | struct rt4801_priv *priv = rdev_get_drvdata(rdev); | |
40 | int id = rdev_get_id(rdev), ret; | |
41 | ||
42 | if (priv->enable_flag & BIT(id)) { | |
43 | ret = regulator_set_voltage_sel_regmap(rdev, selector); | |
44 | if (ret) | |
45 | return ret; | |
46 | } | |
47 | ||
48 | priv->volt_sel[id] = selector; | |
49 | return 0; | |
50 | } | |
51 | ||
52 | static int rt4801_get_voltage_sel(struct regulator_dev *rdev) | |
53 | { | |
54 | struct rt4801_priv *priv = rdev_get_drvdata(rdev); | |
55 | int id = rdev_get_id(rdev); | |
56 | ||
57 | if (priv->enable_flag & BIT(id)) | |
58 | return regulator_get_voltage_sel_regmap(rdev); | |
59 | ||
60 | return priv->volt_sel[id]; | |
61 | } | |
62 | ||
63 | static int rt4801_enable(struct regulator_dev *rdev) | |
64 | { | |
65 | struct rt4801_priv *priv = rdev_get_drvdata(rdev); | |
66 | struct gpio_descs *gpios = priv->enable_gpios; | |
67 | int id = rdev_get_id(rdev), ret; | |
68 | ||
cb2381cb | 69 | if (!gpios || gpios->ndescs <= id) { |
5bbbfc7f CH |
70 | dev_warn(&rdev->dev, "no dedicated gpio can control\n"); |
71 | goto bypass_gpio; | |
72 | } | |
73 | ||
74 | gpiod_set_value(gpios->desc[id], 1); | |
75 | ||
76 | bypass_gpio: | |
77 | ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, priv->volt_sel[id]); | |
78 | if (ret) | |
79 | return ret; | |
80 | ||
81 | priv->enable_flag |= BIT(id); | |
82 | return 0; | |
83 | } | |
84 | ||
85 | static int rt4801_disable(struct regulator_dev *rdev) | |
86 | { | |
87 | struct rt4801_priv *priv = rdev_get_drvdata(rdev); | |
88 | struct gpio_descs *gpios = priv->enable_gpios; | |
89 | int id = rdev_get_id(rdev); | |
90 | ||
cb2381cb | 91 | if (!gpios || gpios->ndescs <= id) { |
5bbbfc7f CH |
92 | dev_warn(&rdev->dev, "no dedicated gpio can control\n"); |
93 | goto bypass_gpio; | |
94 | } | |
95 | ||
96 | gpiod_set_value(gpios->desc[id], 0); | |
97 | ||
98 | bypass_gpio: | |
99 | priv->enable_flag &= ~BIT(id); | |
100 | return 0; | |
101 | } | |
102 | ||
103 | static int rt4801_is_enabled(struct regulator_dev *rdev) | |
104 | { | |
105 | struct rt4801_priv *priv = rdev_get_drvdata(rdev); | |
106 | int id = rdev_get_id(rdev); | |
107 | ||
108 | return !!(priv->enable_flag & BIT(id)); | |
109 | } | |
110 | ||
111 | static const struct regulator_ops rt4801_regulator_ops = { | |
112 | .list_voltage = regulator_list_voltage_linear, | |
113 | .set_voltage_sel = rt4801_set_voltage_sel, | |
114 | .get_voltage_sel = rt4801_get_voltage_sel, | |
115 | .enable = rt4801_enable, | |
116 | .disable = rt4801_disable, | |
117 | .is_enabled = rt4801_is_enabled, | |
118 | }; | |
119 | ||
120 | static const struct regulator_desc rt4801_regulator_descs[] = { | |
121 | { | |
122 | .name = "DSVP", | |
123 | .ops = &rt4801_regulator_ops, | |
124 | .of_match = of_match_ptr("DSVP"), | |
125 | .type = REGULATOR_VOLTAGE, | |
126 | .id = DSV_OUT_POS, | |
127 | .min_uV = MIN_UV, | |
128 | .uV_step = STEP_UV, | |
129 | .n_voltages = N_VOLTAGES, | |
130 | .owner = THIS_MODULE, | |
131 | .vsel_reg = RT4801_REG_VOP, | |
132 | .vsel_mask = VOUT_MASK, | |
133 | }, | |
134 | { | |
135 | .name = "DSVN", | |
136 | .ops = &rt4801_regulator_ops, | |
137 | .of_match = of_match_ptr("DSVN"), | |
138 | .type = REGULATOR_VOLTAGE, | |
139 | .id = DSV_OUT_NEG, | |
140 | .min_uV = MIN_UV, | |
141 | .uV_step = STEP_UV, | |
142 | .n_voltages = N_VOLTAGES, | |
143 | .owner = THIS_MODULE, | |
144 | .vsel_reg = RT4801_REG_VON, | |
145 | .vsel_mask = VOUT_MASK, | |
146 | }, | |
147 | }; | |
148 | ||
149 | static const struct regmap_config rt4801_regmap_config = { | |
150 | .reg_bits = 8, | |
151 | .val_bits = 8, | |
152 | .max_register = RT4801_REG_APPS, | |
153 | }; | |
154 | ||
155 | static int rt4801_probe(struct i2c_client *i2c) | |
156 | { | |
157 | struct rt4801_priv *priv; | |
158 | struct regmap *regmap; | |
159 | int i; | |
160 | ||
161 | priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL); | |
162 | if (!priv) | |
163 | return -ENOMEM; | |
164 | ||
165 | priv->dev = &i2c->dev; | |
166 | /* bootloader will on, driver only reconfigure enable to all output high */ | |
167 | priv->enable_flag = DSVALL_ENABLE; | |
168 | ||
169 | regmap = devm_regmap_init_i2c(i2c, &rt4801_regmap_config); | |
170 | if (IS_ERR(regmap)) { | |
171 | dev_err(&i2c->dev, "Failed to init regmap\n"); | |
172 | return PTR_ERR(regmap); | |
173 | } | |
174 | ||
175 | priv->enable_gpios = devm_gpiod_get_array_optional(&i2c->dev, "enable", GPIOD_OUT_HIGH); | |
176 | if (IS_ERR(priv->enable_gpios)) { | |
177 | dev_err(&i2c->dev, "Failed to get gpios\n"); | |
178 | return PTR_ERR(priv->enable_gpios); | |
179 | } | |
180 | ||
181 | for (i = 0; i < DSV_OUT_MAX; i++) { | |
182 | const struct regulator_desc *desc = rt4801_regulator_descs + i; | |
183 | struct regulator_config config = { .dev = &i2c->dev, .driver_data = priv, | |
184 | .regmap = regmap, }; | |
185 | struct regulator_dev *rdev; | |
186 | unsigned int val; | |
187 | int ret; | |
188 | ||
189 | /* initialize volt_sel variable */ | |
190 | ret = regmap_read(regmap, desc->vsel_reg, &val); | |
191 | if (ret) | |
192 | return ret; | |
193 | ||
194 | priv->volt_sel[i] = val & desc->vsel_mask; | |
195 | ||
196 | rdev = devm_regulator_register(&i2c->dev, desc, &config); | |
197 | if (IS_ERR(rdev)) { | |
198 | dev_err(&i2c->dev, "Failed to register [%d] regulator\n", i); | |
199 | return PTR_ERR(rdev); | |
200 | } | |
201 | } | |
202 | ||
203 | return 0; | |
204 | } | |
205 | ||
c8b2c894 | 206 | static const struct of_device_id __maybe_unused rt4801_of_id[] = { |
5bbbfc7f CH |
207 | { .compatible = "richtek,rt4801", }, |
208 | { }, | |
209 | }; | |
210 | MODULE_DEVICE_TABLE(of, rt4801_of_id); | |
211 | ||
212 | static struct i2c_driver rt4801_driver = { | |
213 | .driver = { | |
214 | .name = "rt4801", | |
215 | .of_match_table = of_match_ptr(rt4801_of_id), | |
216 | }, | |
217 | .probe_new = rt4801_probe, | |
218 | }; | |
219 | module_i2c_driver(rt4801_driver); | |
220 | ||
221 | MODULE_AUTHOR("ChiYuan Hwang <cy_huang@richtek.com>"); | |
222 | MODULE_DESCRIPTION("Richtek RT4801 Display Bias Driver"); | |
223 | MODULE_LICENSE("GPL v2"); |