1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Regulators driver for Maxim max8649 |
4 | * |
5 | * Copyright (C) 2009-2010 Marvell International Ltd. |
6 | * Haojian Zhuang <haojian.zhuang@marvell.com> |
7 | */ |
8 | #include <linux/kernel.h> |
9 | #include <linux/module.h> |
10 | #include <linux/err.h> |
11 | #include <linux/i2c.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/regulator/driver.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/regulator/max8649.h> |
16 | #include <linux/regmap.h> |
17 | |
18 | #define MAX8649_DCDC_VMIN 750000 /* uV */ |
19 | #define MAX8649_DCDC_VMAX 1380000 /* uV */ |
20 | #define MAX8649_DCDC_STEP 10000 /* uV */ |
21 | #define MAX8649_VOL_MASK 0x3f |
22 | |
23 | /* Registers */ |
24 | #define MAX8649_MODE0 0x00 |
25 | #define MAX8649_MODE1 0x01 |
26 | #define MAX8649_MODE2 0x02 |
27 | #define MAX8649_MODE3 0x03 |
28 | #define MAX8649_CONTROL 0x04 |
29 | #define MAX8649_SYNC 0x05 |
30 | #define MAX8649_RAMP 0x06 |
31 | #define MAX8649_CHIP_ID1 0x08 |
32 | #define MAX8649_CHIP_ID2 0x09 |
33 | |
34 | /* Bits */ |
35 | #define MAX8649_EN_PD (1 << 7) |
36 | #define MAX8649_VID0_PD (1 << 6) |
37 | #define MAX8649_VID1_PD (1 << 5) |
38 | #define MAX8649_VID_MASK (3 << 5) |
39 | |
40 | #define MAX8649_FORCE_PWM (1 << 7) |
41 | #define MAX8649_SYNC_EXTCLK (1 << 6) |
42 | |
43 | #define MAX8649_EXT_MASK (3 << 6) |
44 | |
45 | #define MAX8649_RAMP_MASK (7 << 5) |
46 | #define MAX8649_RAMP_DOWN (1 << 1) |
47 | |
48 | struct max8649_regulator_info { |
49 | struct device *dev; |
50 | struct regmap *regmap; |
51 | |
52 | unsigned mode:2; /* bit[1:0] = VID1, VID0 */ |
53 | unsigned extclk_freq:2; |
54 | unsigned extclk:1; |
55 | unsigned ramp_timing:3; |
56 | unsigned ramp_down:1; |
57 | }; |
58 | |
59 | static int max8649_enable_time(struct regulator_dev *rdev) |
60 | { |
61 | struct max8649_regulator_info *info = rdev_get_drvdata(rdev); |
62 | int voltage, rate, ret; |
63 | unsigned int val; |
64 | |
65 | /* get voltage */ |
66 | ret = regmap_read(map: info->regmap, reg: rdev->desc->vsel_reg, val: &val); |
67 | if (ret != 0) |
68 | return ret; |
69 | val &= MAX8649_VOL_MASK; |
70 | voltage = regulator_list_voltage_linear(rdev, selector: (unsigned char)val); |
71 | |
72 | /* get rate */ |
73 | ret = regmap_read(map: info->regmap, MAX8649_RAMP, val: &val); |
74 | if (ret != 0) |
75 | return ret; |
76 | ret = (val & MAX8649_RAMP_MASK) >> 5; |
77 | rate = (32 * 1000) >> ret; /* uV/uS */ |
78 | |
79 | return DIV_ROUND_UP(voltage, rate); |
80 | } |
81 | |
82 | static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode) |
83 | { |
84 | struct max8649_regulator_info *info = rdev_get_drvdata(rdev); |
85 | |
86 | switch (mode) { |
87 | case REGULATOR_MODE_FAST: |
88 | regmap_update_bits(map: info->regmap, reg: rdev->desc->vsel_reg, |
89 | MAX8649_FORCE_PWM, MAX8649_FORCE_PWM); |
90 | break; |
91 | case REGULATOR_MODE_NORMAL: |
92 | regmap_update_bits(map: info->regmap, reg: rdev->desc->vsel_reg, |
93 | MAX8649_FORCE_PWM, val: 0); |
94 | break; |
95 | default: |
96 | return -EINVAL; |
97 | } |
98 | return 0; |
99 | } |
100 | |
101 | static unsigned int max8649_get_mode(struct regulator_dev *rdev) |
102 | { |
103 | struct max8649_regulator_info *info = rdev_get_drvdata(rdev); |
104 | unsigned int val; |
105 | int ret; |
106 | |
107 | ret = regmap_read(map: info->regmap, reg: rdev->desc->vsel_reg, val: &val); |
108 | if (ret != 0) |
109 | return ret; |
110 | if (val & MAX8649_FORCE_PWM) |
111 | return REGULATOR_MODE_FAST; |
112 | return REGULATOR_MODE_NORMAL; |
113 | } |
114 | |
115 | static const struct regulator_ops max8649_dcdc_ops = { |
116 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
117 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
118 | .list_voltage = regulator_list_voltage_linear, |
119 | .map_voltage = regulator_map_voltage_linear, |
120 | .enable = regulator_enable_regmap, |
121 | .disable = regulator_disable_regmap, |
122 | .is_enabled = regulator_is_enabled_regmap, |
123 | .enable_time = max8649_enable_time, |
124 | .set_mode = max8649_set_mode, |
125 | .get_mode = max8649_get_mode, |
126 | |
127 | }; |
128 | |
129 | static struct regulator_desc dcdc_desc = { |
130 | .name = "max8649" , |
131 | .ops = &max8649_dcdc_ops, |
132 | .type = REGULATOR_VOLTAGE, |
133 | .n_voltages = 1 << 6, |
134 | .owner = THIS_MODULE, |
135 | .vsel_mask = MAX8649_VOL_MASK, |
136 | .min_uV = MAX8649_DCDC_VMIN, |
137 | .uV_step = MAX8649_DCDC_STEP, |
138 | .enable_reg = MAX8649_CONTROL, |
139 | .enable_mask = MAX8649_EN_PD, |
140 | .enable_is_inverted = true, |
141 | }; |
142 | |
143 | static const struct regmap_config max8649_regmap_config = { |
144 | .reg_bits = 8, |
145 | .val_bits = 8, |
146 | }; |
147 | |
148 | static int max8649_regulator_probe(struct i2c_client *client) |
149 | { |
150 | struct max8649_platform_data *pdata = dev_get_platdata(dev: &client->dev); |
151 | struct max8649_regulator_info *info = NULL; |
152 | struct regulator_dev *regulator; |
153 | struct regulator_config config = { }; |
154 | unsigned int val; |
155 | unsigned char data; |
156 | int ret; |
157 | |
158 | info = devm_kzalloc(dev: &client->dev, size: sizeof(struct max8649_regulator_info), |
159 | GFP_KERNEL); |
160 | if (!info) |
161 | return -ENOMEM; |
162 | |
163 | info->regmap = devm_regmap_init_i2c(client, &max8649_regmap_config); |
164 | if (IS_ERR(ptr: info->regmap)) { |
165 | ret = PTR_ERR(ptr: info->regmap); |
166 | dev_err(&client->dev, "Failed to allocate register map: %d\n" , ret); |
167 | return ret; |
168 | } |
169 | |
170 | info->dev = &client->dev; |
171 | i2c_set_clientdata(client, data: info); |
172 | |
173 | info->mode = pdata->mode; |
174 | switch (info->mode) { |
175 | case 0: |
176 | dcdc_desc.vsel_reg = MAX8649_MODE0; |
177 | break; |
178 | case 1: |
179 | dcdc_desc.vsel_reg = MAX8649_MODE1; |
180 | break; |
181 | case 2: |
182 | dcdc_desc.vsel_reg = MAX8649_MODE2; |
183 | break; |
184 | case 3: |
185 | dcdc_desc.vsel_reg = MAX8649_MODE3; |
186 | break; |
187 | default: |
188 | break; |
189 | } |
190 | |
191 | ret = regmap_read(map: info->regmap, MAX8649_CHIP_ID1, val: &val); |
192 | if (ret != 0) { |
193 | dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n" , |
194 | ret); |
195 | return ret; |
196 | } |
197 | dev_info(info->dev, "Detected MAX8649 (ID:%x)\n" , val); |
198 | |
199 | /* enable VID0 & VID1 */ |
200 | regmap_update_bits(map: info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, val: 0); |
201 | |
202 | /* enable/disable external clock synchronization */ |
203 | info->extclk = pdata->extclk; |
204 | data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0; |
205 | regmap_update_bits(map: info->regmap, reg: dcdc_desc.vsel_reg, |
206 | MAX8649_SYNC_EXTCLK, val: data); |
207 | if (info->extclk) { |
208 | /* set external clock frequency */ |
209 | info->extclk_freq = pdata->extclk_freq; |
210 | regmap_update_bits(map: info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK, |
211 | val: info->extclk_freq << 6); |
212 | } |
213 | |
214 | if (pdata->ramp_timing) { |
215 | info->ramp_timing = pdata->ramp_timing; |
216 | regmap_update_bits(map: info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK, |
217 | val: info->ramp_timing << 5); |
218 | } |
219 | |
220 | info->ramp_down = pdata->ramp_down; |
221 | if (info->ramp_down) { |
222 | regmap_update_bits(map: info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN, |
223 | MAX8649_RAMP_DOWN); |
224 | } |
225 | |
226 | config.dev = &client->dev; |
227 | config.init_data = pdata->regulator; |
228 | config.driver_data = info; |
229 | config.regmap = info->regmap; |
230 | |
231 | regulator = devm_regulator_register(dev: &client->dev, regulator_desc: &dcdc_desc, |
232 | config: &config); |
233 | if (IS_ERR(ptr: regulator)) { |
234 | dev_err(info->dev, "failed to register regulator %s\n" , |
235 | dcdc_desc.name); |
236 | return PTR_ERR(ptr: regulator); |
237 | } |
238 | |
239 | return 0; |
240 | } |
241 | |
242 | static const struct i2c_device_id max8649_id[] = { |
243 | { "max8649" , 0 }, |
244 | { } |
245 | }; |
246 | MODULE_DEVICE_TABLE(i2c, max8649_id); |
247 | |
248 | static struct i2c_driver max8649_driver = { |
249 | .probe = max8649_regulator_probe, |
250 | .driver = { |
251 | .name = "max8649" , |
252 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
253 | }, |
254 | .id_table = max8649_id, |
255 | }; |
256 | |
257 | static int __init max8649_init(void) |
258 | { |
259 | return i2c_add_driver(&max8649_driver); |
260 | } |
261 | subsys_initcall(max8649_init); |
262 | |
263 | static void __exit max8649_exit(void) |
264 | { |
265 | i2c_del_driver(driver: &max8649_driver); |
266 | } |
267 | module_exit(max8649_exit); |
268 | |
269 | /* Module information */ |
270 | MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver" ); |
271 | MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>" ); |
272 | MODULE_LICENSE("GPL" ); |
273 | |