1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // Regulator driver for ATC260x PMICs
4 //
5 // Copyright (C) 2019 Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
6 // Copyright (C) 2020 Cristian Ciocaltea <cristian.ciocaltea@gmail.com>
7 
8 #include <linux/mfd/atc260x/core.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/platform_device.h>
12 #include <linux/regmap.h>
13 #include <linux/regulator/driver.h>
14 
15 struct atc260x_regulator_data {
16 	int voltage_time_dcdc;
17 	int voltage_time_ldo;
18 };
19 
20 static const struct linear_range atc2603c_dcdc_voltage_ranges[] = {
21 	REGULATOR_LINEAR_RANGE(1300000, 0, 13, 50000),
22 	REGULATOR_LINEAR_RANGE(1950000, 14, 15, 100000),
23 };
24 
25 static const struct linear_range atc2609a_dcdc_voltage_ranges[] = {
26 	REGULATOR_LINEAR_RANGE(600000, 0, 127, 6250),
27 	REGULATOR_LINEAR_RANGE(1400000, 128, 232, 25000),
28 };
29 
30 static const struct linear_range atc2609a_ldo_voltage_ranges0[] = {
31 	REGULATOR_LINEAR_RANGE(700000, 0, 15, 100000),
32 	REGULATOR_LINEAR_RANGE(2100000, 0, 12, 100000),
33 };
34 
35 static const struct linear_range atc2609a_ldo_voltage_ranges1[] = {
36 	REGULATOR_LINEAR_RANGE(850000, 0, 15, 100000),
37 	REGULATOR_LINEAR_RANGE(2100000, 0, 11, 100000),
38 };
39 
40 static const unsigned int atc260x_ldo_voltage_range_sel[] = {
41 	0x0, 0x1,
42 };
43 
44 static int atc260x_dcdc_set_voltage_time_sel(struct regulator_dev *rdev,
45 					     unsigned int old_selector,
46 					     unsigned int new_selector)
47 {
48 	struct atc260x_regulator_data *data = rdev_get_drvdata(rdev);
49 
50 	if (new_selector > old_selector)
51 		return data->voltage_time_dcdc;
52 
53 	return 0;
54 }
55 
56 static int atc260x_ldo_set_voltage_time_sel(struct regulator_dev *rdev,
57 					    unsigned int old_selector,
58 					    unsigned int new_selector)
59 {
60 	struct atc260x_regulator_data *data = rdev_get_drvdata(rdev);
61 
62 	if (new_selector > old_selector)
63 		return data->voltage_time_ldo;
64 
65 	return 0;
66 }
67 
68 static const struct regulator_ops atc260x_dcdc_ops = {
69 	.enable	= regulator_enable_regmap,
70 	.disable = regulator_disable_regmap,
71 	.is_enabled = regulator_is_enabled_regmap,
72 	.list_voltage = regulator_list_voltage_linear,
73 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
74 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
75 	.set_voltage_time_sel = atc260x_dcdc_set_voltage_time_sel,
76 };
77 
78 static const struct regulator_ops atc260x_ldo_ops = {
79 	.enable	= regulator_enable_regmap,
80 	.disable = regulator_disable_regmap,
81 	.is_enabled = regulator_is_enabled_regmap,
82 	.list_voltage = regulator_list_voltage_linear,
83 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
84 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
85 	.set_voltage_time_sel = atc260x_ldo_set_voltage_time_sel,
86 };
87 
88 static const struct regulator_ops atc260x_ldo_bypass_ops = {
89 	.enable	= regulator_enable_regmap,
90 	.disable = regulator_disable_regmap,
91 	.is_enabled = regulator_is_enabled_regmap,
92 	.list_voltage = regulator_list_voltage_linear,
93 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
94 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
95 	.set_voltage_time_sel = atc260x_ldo_set_voltage_time_sel,
96 	.set_bypass = regulator_set_bypass_regmap,
97 	.get_bypass = regulator_get_bypass_regmap,
98 };
99 
100 static const struct regulator_ops atc260x_ldo_bypass_discharge_ops = {
101 	.enable	= regulator_enable_regmap,
102 	.disable = regulator_disable_regmap,
103 	.is_enabled = regulator_is_enabled_regmap,
104 	.list_voltage = regulator_list_voltage_linear,
105 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
106 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
107 	.set_voltage_time_sel = atc260x_ldo_set_voltage_time_sel,
108 	.set_bypass = regulator_set_bypass_regmap,
109 	.get_bypass = regulator_get_bypass_regmap,
110 	.set_active_discharge = regulator_set_active_discharge_regmap,
111 };
112 
113 static const struct regulator_ops atc260x_dcdc_range_ops = {
114 	.enable	= regulator_enable_regmap,
115 	.disable = regulator_disable_regmap,
116 	.is_enabled = regulator_is_enabled_regmap,
117 	.list_voltage = regulator_list_voltage_linear_range,
118 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
119 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
120 	.set_voltage_time_sel = atc260x_dcdc_set_voltage_time_sel,
121 };
122 
123 static const struct regulator_ops atc260x_ldo_range_pick_ops = {
124 	.enable	= regulator_enable_regmap,
125 	.disable = regulator_disable_regmap,
126 	.is_enabled = regulator_is_enabled_regmap,
127 	.list_voltage = regulator_list_voltage_pickable_linear_range,
128 	.set_voltage_sel = regulator_set_voltage_sel_pickable_regmap,
129 	.get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
130 	.set_voltage_time_sel = atc260x_ldo_set_voltage_time_sel,
131 };
132 
133 static const struct regulator_ops atc260x_dcdc_fixed_ops = {
134 	.list_voltage = regulator_list_voltage_linear,
135 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
136 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
137 	.set_voltage_time_sel = atc260x_dcdc_set_voltage_time_sel,
138 };
139 
140 static const struct regulator_ops atc260x_ldo_fixed_ops = {
141 	.list_voltage = regulator_list_voltage_linear,
142 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
143 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
144 	.set_voltage_time_sel = atc260x_ldo_set_voltage_time_sel,
145 };
146 
147 static const struct regulator_ops atc260x_no_ops = {
148 };
149 
150 /*
151  * Note LDO8 is not documented in datasheet (v2.4), but supported
152  * in the vendor's driver implementation (xapp-le-kernel).
153  */
154 enum atc2603c_reg_ids {
155 	ATC2603C_ID_DCDC1,
156 	ATC2603C_ID_DCDC2,
157 	ATC2603C_ID_DCDC3,
158 	ATC2603C_ID_LDO1,
159 	ATC2603C_ID_LDO2,
160 	ATC2603C_ID_LDO3,
161 	ATC2603C_ID_LDO5,
162 	ATC2603C_ID_LDO6,
163 	ATC2603C_ID_LDO7,
164 	ATC2603C_ID_LDO8,
165 	ATC2603C_ID_LDO11,
166 	ATC2603C_ID_LDO12,
167 	ATC2603C_ID_SWITCHLDO1,
168 	ATC2603C_ID_MAX,
169 };
170 
171 #define atc2603c_reg_desc_dcdc(num, min, step, n_volt, vsel_h, vsel_l) { \
172 	.name = "DCDC"#num, \
173 	.supply_name = "dcdc"#num, \
174 	.of_match = of_match_ptr("dcdc"#num), \
175 	.regulators_node = of_match_ptr("regulators"), \
176 	.id = ATC2603C_ID_DCDC##num, \
177 	.ops = &atc260x_dcdc_ops, \
178 	.type = REGULATOR_VOLTAGE, \
179 	.min_uV = min, \
180 	.uV_step = step, \
181 	.n_voltages = n_volt, \
182 	.vsel_reg = ATC2603C_PMU_DC##num##_CTL0, \
183 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
184 	.enable_reg = ATC2603C_PMU_DC##num##_CTL0, \
185 	.enable_mask = BIT(15), \
186 	.enable_time = 800, \
187 	.owner = THIS_MODULE, \
188 }
189 
190 #define atc2603c_reg_desc_dcdc_range(num, vsel_h, vsel_l) { \
191 	.name = "DCDC"#num, \
192 	.supply_name = "dcdc"#num, \
193 	.of_match = of_match_ptr("dcdc"#num), \
194 	.regulators_node = of_match_ptr("regulators"), \
195 	.id = ATC2603C_ID_DCDC##num, \
196 	.ops = &atc260x_dcdc_range_ops, \
197 	.type = REGULATOR_VOLTAGE, \
198 	.n_voltages = 16, \
199 	.linear_ranges = atc2603c_dcdc_voltage_ranges, \
200 	.n_linear_ranges = ARRAY_SIZE(atc2603c_dcdc_voltage_ranges), \
201 	.vsel_reg = ATC2603C_PMU_DC##num##_CTL0, \
202 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
203 	.enable_reg = ATC2603C_PMU_DC##num##_CTL0, \
204 	.enable_mask = BIT(15), \
205 	.enable_time = 800, \
206 	.owner = THIS_MODULE, \
207 }
208 
209 #define atc2603c_reg_desc_dcdc_fixed(num, min, step, n_volt, vsel_h, vsel_l) { \
210 	.name = "DCDC"#num, \
211 	.supply_name = "dcdc"#num, \
212 	.of_match = of_match_ptr("dcdc"#num), \
213 	.regulators_node = of_match_ptr("regulators"), \
214 	.id = ATC2603C_ID_DCDC##num, \
215 	.ops = &atc260x_dcdc_fixed_ops, \
216 	.type = REGULATOR_VOLTAGE, \
217 	.min_uV = min, \
218 	.uV_step = step, \
219 	.n_voltages = n_volt, \
220 	.vsel_reg = ATC2603C_PMU_DC##num##_CTL0, \
221 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
222 	.enable_time = 800, \
223 	.owner = THIS_MODULE, \
224 }
225 
226 #define atc2603c_reg_desc_ldo(num, min, step, n_volt, vsel_h, vsel_l) { \
227 	.name = "LDO"#num, \
228 	.supply_name = "ldo"#num, \
229 	.of_match = of_match_ptr("ldo"#num), \
230 	.regulators_node = of_match_ptr("regulators"), \
231 	.id = ATC2603C_ID_LDO##num, \
232 	.ops = &atc260x_ldo_ops, \
233 	.type = REGULATOR_VOLTAGE, \
234 	.min_uV = min, \
235 	.uV_step = step, \
236 	.n_voltages = n_volt, \
237 	.vsel_reg = ATC2603C_PMU_LDO##num##_CTL, \
238 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
239 	.enable_reg = ATC2603C_PMU_LDO##num##_CTL, \
240 	.enable_mask = BIT(0), \
241 	.enable_time = 2000, \
242 	.owner = THIS_MODULE, \
243 }
244 
245 #define atc2603c_reg_desc_ldo_fixed(num, min, step, n_volt, vsel_h, vsel_l) { \
246 	.name = "LDO"#num, \
247 	.supply_name = "ldo"#num, \
248 	.of_match = of_match_ptr("ldo"#num), \
249 	.regulators_node = of_match_ptr("regulators"), \
250 	.id = ATC2603C_ID_LDO##num, \
251 	.ops = &atc260x_ldo_fixed_ops, \
252 	.type = REGULATOR_VOLTAGE, \
253 	.min_uV = min, \
254 	.uV_step = step, \
255 	.n_voltages = n_volt, \
256 	.vsel_reg = ATC2603C_PMU_LDO##num##_CTL, \
257 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
258 	.enable_time = 2000, \
259 	.owner = THIS_MODULE, \
260 }
261 
262 #define atc2603c_reg_desc_ldo_noops(num, vfixed) { \
263 	.name = "LDO"#num, \
264 	.supply_name = "ldo"#num, \
265 	.of_match = of_match_ptr("ldo"#num), \
266 	.regulators_node = of_match_ptr("regulators"), \
267 	.id = ATC2603C_ID_LDO##num, \
268 	.ops = &atc260x_no_ops, \
269 	.type = REGULATOR_VOLTAGE, \
270 	.fixed_uV = vfixed, \
271 	.n_voltages = 1, \
272 	.owner = THIS_MODULE, \
273 }
274 
275 #define atc2603c_reg_desc_ldo_switch(num, min, step, n_volt, vsel_h, vsel_l) { \
276 	.name = "SWITCHLDO"#num, \
277 	.supply_name = "switchldo"#num, \
278 	.of_match = of_match_ptr("switchldo"#num), \
279 	.regulators_node = of_match_ptr("regulators"), \
280 	.id = ATC2603C_ID_SWITCHLDO##num, \
281 	.ops = &atc260x_ldo_bypass_discharge_ops, \
282 	.type = REGULATOR_VOLTAGE, \
283 	.min_uV = min, \
284 	.uV_step = step, \
285 	.n_voltages = n_volt, \
286 	.vsel_reg = ATC2603C_PMU_SWITCH_CTL, \
287 	.vsel_mask = GENMASK(vsel_h, vsel_l), \
288 	.enable_reg = ATC2603C_PMU_SWITCH_CTL, \
289 	.enable_mask = BIT(15), \
290 	.enable_is_inverted = true, \
291 	.enable_time = 2000, \
292 	.bypass_reg = ATC2603C_PMU_SWITCH_CTL, \
293 	.bypass_mask = BIT(5), \
294 	.active_discharge_reg = ATC2603C_PMU_SWITCH_CTL, \
295 	.active_discharge_mask = BIT(1), \
296 	.active_discharge_on = BIT(1), \
297 	.owner = THIS_MODULE, \
298 }
299 
300 static const struct regulator_desc atc2603c_reg[] = {
301 	atc2603c_reg_desc_dcdc_fixed(1, 700000, 25000, 29, 11, 7),
302 	atc2603c_reg_desc_dcdc_range(2, 12, 8),
303 	atc2603c_reg_desc_dcdc_fixed(3, 2600000, 100000, 8, 11, 9),
304 	atc2603c_reg_desc_ldo_fixed(1, 2600000, 100000, 8, 15, 13),
305 	atc2603c_reg_desc_ldo_fixed(2, 2600000, 100000, 8, 15, 13),
306 	atc2603c_reg_desc_ldo_fixed(3, 1500000, 100000, 6, 15, 13),
307 	atc2603c_reg_desc_ldo(5, 2600000, 100000, 8, 15, 13),
308 	atc2603c_reg_desc_ldo_fixed(6, 700000, 25000, 29, 15, 11),
309 	atc2603c_reg_desc_ldo(7, 1500000, 100000, 6, 15, 13),
310 	atc2603c_reg_desc_ldo(8, 2300000, 100000, 11, 15, 12),
311 	atc2603c_reg_desc_ldo_fixed(11, 2600000, 100000, 8, 15, 13),
312 	atc2603c_reg_desc_ldo_noops(12, 1800000),
313 	atc2603c_reg_desc_ldo_switch(1, 3000000, 100000, 4, 4, 3),
314 };
315 
316 static const struct regulator_desc atc2603c_reg_dcdc2_ver_b =
317 	atc2603c_reg_desc_dcdc(2, 1000000, 50000, 18, 12, 8);
318 
319 enum atc2609a_reg_ids {
320 	ATC2609A_ID_DCDC0,
321 	ATC2609A_ID_DCDC1,
322 	ATC2609A_ID_DCDC2,
323 	ATC2609A_ID_DCDC3,
324 	ATC2609A_ID_DCDC4,
325 	ATC2609A_ID_LDO0,
326 	ATC2609A_ID_LDO1,
327 	ATC2609A_ID_LDO2,
328 	ATC2609A_ID_LDO3,
329 	ATC2609A_ID_LDO4,
330 	ATC2609A_ID_LDO5,
331 	ATC2609A_ID_LDO6,
332 	ATC2609A_ID_LDO7,
333 	ATC2609A_ID_LDO8,
334 	ATC2609A_ID_LDO9,
335 	ATC2609A_ID_MAX,
336 };
337 
338 #define atc2609a_reg_desc_dcdc(num, en_bit) { \
339 	.name = "DCDC"#num, \
340 	.supply_name = "dcdc"#num, \
341 	.of_match = of_match_ptr("dcdc"#num), \
342 	.regulators_node = of_match_ptr("regulators"), \
343 	.id = ATC2609A_ID_DCDC##num, \
344 	.ops = &atc260x_dcdc_ops, \
345 	.type = REGULATOR_VOLTAGE, \
346 	.min_uV = 600000, \
347 	.uV_step = 6250, \
348 	.n_voltages = 256, \
349 	.vsel_reg = ATC2609A_PMU_DC##num##_CTL0, \
350 	.vsel_mask = GENMASK(15, 8), \
351 	.enable_reg = ATC2609A_PMU_DC_OSC, \
352 	.enable_mask = BIT(en_bit), \
353 	.enable_time = 800, \
354 	.owner = THIS_MODULE, \
355 }
356 
357 #define atc2609a_reg_desc_dcdc_range(num, en_bit) { \
358 	.name = "DCDC"#num, \
359 	.supply_name = "dcdc"#num, \
360 	.of_match = of_match_ptr("dcdc"#num), \
361 	.regulators_node = of_match_ptr("regulators"), \
362 	.id = ATC2609A_ID_DCDC##num, \
363 	.ops = &atc260x_dcdc_range_ops, \
364 	.type = REGULATOR_VOLTAGE, \
365 	.n_voltages = 233, \
366 	.linear_ranges = atc2609a_dcdc_voltage_ranges, \
367 	.n_linear_ranges = ARRAY_SIZE(atc2609a_dcdc_voltage_ranges), \
368 	.vsel_reg = ATC2609A_PMU_DC##num##_CTL0, \
369 	.vsel_mask = GENMASK(15, 8), \
370 	.enable_reg = ATC2609A_PMU_DC_OSC, \
371 	.enable_mask = BIT(en_bit), \
372 	.enable_time = 800, \
373 	.owner = THIS_MODULE, \
374 }
375 
376 #define atc2609a_reg_desc_ldo(num) { \
377 	.name = "LDO"#num, \
378 	.supply_name = "ldo"#num, \
379 	.of_match = of_match_ptr("ldo"#num), \
380 	.regulators_node = of_match_ptr("regulators"), \
381 	.id = ATC2609A_ID_LDO##num, \
382 	.ops = &atc260x_ldo_ops, \
383 	.type = REGULATOR_VOLTAGE, \
384 	.min_uV = 700000, \
385 	.uV_step = 100000, \
386 	.n_voltages = 16, \
387 	.vsel_reg = ATC2609A_PMU_LDO##num##_CTL0, \
388 	.vsel_mask = GENMASK(4, 1), \
389 	.enable_reg = ATC2609A_PMU_LDO##num##_CTL0, \
390 	.enable_mask = BIT(0), \
391 	.enable_time = 2000, \
392 	.owner = THIS_MODULE, \
393 }
394 
395 #define atc2609a_reg_desc_ldo_bypass(num) { \
396 	.name = "LDO"#num, \
397 	.supply_name = "ldo"#num, \
398 	.of_match = of_match_ptr("ldo"#num), \
399 	.regulators_node = of_match_ptr("regulators"), \
400 	.id = ATC2609A_ID_LDO##num, \
401 	.ops = &atc260x_ldo_bypass_ops, \
402 	.type = REGULATOR_VOLTAGE, \
403 	.min_uV = 2300000, \
404 	.uV_step = 100000, \
405 	.n_voltages = 12, \
406 	.vsel_reg = ATC2609A_PMU_LDO##num##_CTL0, \
407 	.vsel_mask = GENMASK(5, 2), \
408 	.enable_reg = ATC2609A_PMU_LDO##num##_CTL0, \
409 	.enable_mask = BIT(0), \
410 	.enable_time = 2000, \
411 	.bypass_reg = ATC2609A_PMU_LDO##num##_CTL0, \
412 	.bypass_mask = BIT(1), \
413 	.owner = THIS_MODULE, \
414 }
415 
416 #define atc2609a_reg_desc_ldo_range_pick(num, n_range, n_volt) { \
417 	.name = "LDO"#num, \
418 	.supply_name = "ldo"#num, \
419 	.of_match = of_match_ptr("ldo"#num), \
420 	.regulators_node = of_match_ptr("regulators"), \
421 	.id = ATC2609A_ID_LDO##num, \
422 	.ops = &atc260x_ldo_range_pick_ops, \
423 	.type = REGULATOR_VOLTAGE, \
424 	.linear_ranges = atc2609a_ldo_voltage_ranges##n_range, \
425 	.n_linear_ranges = ARRAY_SIZE(atc2609a_ldo_voltage_ranges##n_range), \
426 	.n_voltages = n_volt, \
427 	.vsel_reg = ATC2609A_PMU_LDO##num##_CTL0, \
428 	.vsel_mask = GENMASK(4, 1), \
429 	.vsel_range_reg = ATC2609A_PMU_LDO##num##_CTL0, \
430 	.vsel_range_mask = BIT(5), \
431 	.linear_range_selectors_bitfield = atc260x_ldo_voltage_range_sel, \
432 	.enable_reg = ATC2609A_PMU_LDO##num##_CTL0, \
433 	.enable_mask = BIT(0), \
434 	.enable_time = 2000, \
435 	.owner = THIS_MODULE, \
436 }
437 
438 #define atc2609a_reg_desc_ldo_fixed(num) { \
439 	.name = "LDO"#num, \
440 	.supply_name = "ldo"#num, \
441 	.of_match = of_match_ptr("ldo"#num), \
442 	.regulators_node = of_match_ptr("regulators"), \
443 	.id = ATC2609A_ID_LDO##num, \
444 	.ops = &atc260x_ldo_fixed_ops, \
445 	.type = REGULATOR_VOLTAGE, \
446 	.min_uV = 2600000, \
447 	.uV_step = 100000, \
448 	.n_voltages = 8, \
449 	.vsel_reg = ATC2609A_PMU_LDO##num##_CTL, \
450 	.vsel_mask = GENMASK(15, 13), \
451 	.enable_time = 2000, \
452 	.owner = THIS_MODULE, \
453 }
454 
455 static const struct regulator_desc atc2609a_reg[] = {
456 	atc2609a_reg_desc_dcdc(0, 4),
457 	atc2609a_reg_desc_dcdc(1, 5),
458 	atc2609a_reg_desc_dcdc(2, 6),
459 	atc2609a_reg_desc_dcdc_range(3, 7),
460 	atc2609a_reg_desc_dcdc(4, 8),
461 	atc2609a_reg_desc_ldo_bypass(0),
462 	atc2609a_reg_desc_ldo_bypass(1),
463 	atc2609a_reg_desc_ldo_bypass(2),
464 	atc2609a_reg_desc_ldo_range_pick(3, 0, 29),
465 	atc2609a_reg_desc_ldo_range_pick(4, 0, 29),
466 	atc2609a_reg_desc_ldo(5),
467 	atc2609a_reg_desc_ldo_range_pick(6, 1, 28),
468 	atc2609a_reg_desc_ldo_range_pick(7, 0, 29),
469 	atc2609a_reg_desc_ldo_range_pick(8, 0, 29),
470 	atc2609a_reg_desc_ldo_fixed(9),
471 };
472 
473 static int atc260x_regulator_probe(struct platform_device *pdev)
474 {
475 	struct atc260x *atc260x = dev_get_drvdata(pdev->dev.parent);
476 	struct device *dev = atc260x->dev;
477 	struct atc260x_regulator_data *atc260x_data;
478 	struct regulator_config config = {};
479 	struct regulator_dev *atc260x_rdev;
480 	const struct regulator_desc *regulators;
481 	bool atc2603c_ver_b = false;
482 	int i, nregulators;
483 
484 	atc260x_data = devm_kzalloc(&pdev->dev, sizeof(*atc260x_data), GFP_KERNEL);
485 	if (!atc260x_data)
486 		return -ENOMEM;
487 
488 	atc260x_data->voltage_time_dcdc = 350;
489 	atc260x_data->voltage_time_ldo = 800;
490 
491 	switch (atc260x->ic_type) {
492 	case ATC2603C:
493 		regulators = atc2603c_reg;
494 		nregulators = ATC2603C_ID_MAX;
495 		atc2603c_ver_b = atc260x->ic_ver == ATC260X_B;
496 		break;
497 	case ATC2609A:
498 		atc260x_data->voltage_time_dcdc = 250;
499 		regulators = atc2609a_reg;
500 		nregulators = ATC2609A_ID_MAX;
501 		break;
502 	default:
503 		dev_err(dev, "unsupported ATC260X ID %d\n", atc260x->ic_type);
504 		return -EINVAL;
505 	}
506 
507 	config.dev = dev;
508 	config.regmap = atc260x->regmap;
509 	config.driver_data = atc260x_data;
510 
511 	/* Instantiate the regulators */
512 	for (i = 0; i < nregulators; i++) {
513 		if (atc2603c_ver_b && regulators[i].id == ATC2603C_ID_DCDC2)
514 			atc260x_rdev = devm_regulator_register(&pdev->dev,
515 							       &atc2603c_reg_dcdc2_ver_b,
516 							       &config);
517 		else
518 			atc260x_rdev = devm_regulator_register(&pdev->dev,
519 							       &regulators[i],
520 							       &config);
521 		if (IS_ERR(atc260x_rdev)) {
522 			dev_err(dev, "failed to register regulator: %d\n", i);
523 			return PTR_ERR(atc260x_rdev);
524 		}
525 	}
526 
527 	return 0;
528 }
529 
530 static struct platform_driver atc260x_regulator_driver = {
531 	.probe = atc260x_regulator_probe,
532 	.driver = {
533 		.name = "atc260x-regulator",
534 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
535 	},
536 };
537 
538 module_platform_driver(atc260x_regulator_driver);
539 
540 MODULE_DESCRIPTION("Regulator driver for ATC260x PMICs");
541 MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>");
542 MODULE_AUTHOR("Cristian Ciocaltea <cristian.ciocaltea@gmail.com>");
543 MODULE_LICENSE("GPL");
544