1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2021 Fuzhou Rockchip Electronics Co., Ltd
4 */
5 #include <linux/err.h>
6 #include <linux/gpio.h>
7 #include <linux/i2c.h>
8 #include <linux/module.h>
9 #include <linux/of_device.h>
10 #include <linux/of_gpio.h>
11 #include <linux/param.h>
12 #include <linux/platform_device.h>
13 #include <linux/regmap.h>
14 #include <linux/regulator/driver.h>
15 #include <linux/regulator/machine.h>
16 #include <linux/regulator/of_regulator.h>
17 #include <linux/slab.h>
18
19 /* Voltage setting */
20
21 #define RK860X_VSEL0_A 0x00
22 #define RK860X_VSEL1_A 0x01
23 #define RK860X_VSEL0_B 0x06
24 #define RK860X_VSEL1_B 0x07
25 #define RK860X_MAX_SET 0x08
26
27 /* Control register */
28 #define RK860X_CONTROL 0x02
29 /* IC Type */
30 #define RK860X_ID1 0x03
31 /* IC mask version */
32 #define RK860X_ID2 0x04
33 /* Monitor register */
34 #define RK860X_MONITOR 0x05
35
36 /* VSEL bit definitions */
37 #define VSEL_BUCK_EN BIT(7)
38 #define VSEL_MODE BIT(6)
39 #define VSEL_A_NSEL_MASK 0x3F
40 #define VSEL_B_NSEL_MASK 0xff
41
42 /* Chip ID */
43 #define DIE_ID 0x0f
44 #define DIE_REV 0x0f
45 /* Control bit definitions */
46 #define CTL_OUTPUT_DISCHG BIT(7)
47 #define CTL_SLEW_MASK (0x7 << 4)
48 #define CTL_SLEW_SHIFT 4
49 #define CTL_RESET BIT(2)
50
51 #define RK860X_NVOLTAGES_64 64
52 #define RK860X_NVOLTAGES_160 160
53
54 /* IC Type */
55 enum {
56 RK860X_CHIP_ID_00 = 0,
57 RK860X_CHIP_ID_01,
58 RK860X_CHIP_ID_02,
59 RK860X_CHIP_ID_03,
60 };
61
62 struct rk860x_platform_data {
63 struct regulator_init_data *regulator;
64 unsigned int slew_rate;
65 /* Sleep VSEL ID */
66 unsigned int sleep_vsel_id;
67 int limit_volt;
68 struct gpio_desc *vsel_gpio;
69 };
70
71 struct rk860x_device_info {
72 struct regmap *regmap;
73 struct device *dev;
74 struct regulator_desc desc;
75 struct regulator_dev *rdev;
76 struct regulator_init_data *regulator;
77 /* IC Type and Rev */
78 int chip_id;
79 /* Voltage setting register */
80 unsigned int vol_reg;
81 unsigned int sleep_reg;
82 unsigned int en_reg;
83 unsigned int sleep_en_reg;
84 unsigned int mode_reg;
85 unsigned int vol_mask;
86 unsigned int mode_mask;
87 unsigned int slew_reg;
88 unsigned int slew_mask;
89 unsigned int slew_shift;
90 /* Voltage range and step(linear) */
91 unsigned int vsel_min;
92 unsigned int vsel_step;
93 unsigned int n_voltages;
94 /* Voltage slew rate limiting */
95 unsigned int slew_rate;
96 struct gpio_desc *vsel_gpio;
97 unsigned int sleep_vsel_id;
98 };
99
rk860x_map_mode(unsigned int mode)100 static unsigned int rk860x_map_mode(unsigned int mode)
101 {
102 return mode == REGULATOR_MODE_FAST ?
103 REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
104 }
105
rk860x_get_voltage(struct regulator_dev * rdev)106 static int rk860x_get_voltage(struct regulator_dev *rdev)
107 {
108 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
109 unsigned int val;
110 int ret;
111
112 ret = regmap_read(di->regmap, RK860X_MAX_SET, &val);
113 if (ret < 0)
114 return ret;
115 ret = regulator_get_voltage_sel_regmap(rdev);
116 if (ret > val)
117 return val;
118
119 return ret;
120 }
121
rk860x_set_suspend_voltage(struct regulator_dev * rdev,int uV)122 static int rk860x_set_suspend_voltage(struct regulator_dev *rdev, int uV)
123 {
124 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
125 int ret;
126
127 ret = regulator_map_voltage_linear(rdev, uV, uV);
128 if (ret < 0)
129 return ret;
130 ret = regmap_update_bits(di->regmap, di->sleep_reg,
131 di->vol_mask, ret);
132 if (ret < 0)
133 return ret;
134
135 return 0;
136 }
137
rk860x_set_suspend_enable(struct regulator_dev * rdev)138 static int rk860x_set_suspend_enable(struct regulator_dev *rdev)
139 {
140 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
141
142 return regmap_update_bits(di->regmap, di->sleep_en_reg,
143 VSEL_BUCK_EN, VSEL_BUCK_EN);
144 }
145
rk860x_set_suspend_disable(struct regulator_dev * rdev)146 static int rk860x_set_suspend_disable(struct regulator_dev *rdev)
147 {
148 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
149
150 return regmap_update_bits(di->regmap, di->sleep_en_reg,
151 VSEL_BUCK_EN, 0);
152 }
153
rk860x_resume(struct regulator_dev * rdev)154 static int rk860x_resume(struct regulator_dev *rdev)
155 {
156 int ret;
157
158 if (!rdev->constraints->state_mem.changeable)
159 return 0;
160
161 ret = rk860x_set_suspend_enable(rdev);
162 if (ret)
163 return ret;
164
165 return regulator_suspend_enable(rdev, PM_SUSPEND_MEM);
166 }
167
rk860x_set_enable(struct regulator_dev * rdev)168 static int rk860x_set_enable(struct regulator_dev *rdev)
169 {
170 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
171
172 if (di->vsel_gpio) {
173 gpiod_set_raw_value(di->vsel_gpio, !di->sleep_vsel_id);
174 return 0;
175 }
176
177 return regmap_update_bits(di->regmap, di->en_reg,
178 VSEL_BUCK_EN, VSEL_BUCK_EN);
179 }
180
rk860x_set_disable(struct regulator_dev * rdev)181 static int rk860x_set_disable(struct regulator_dev *rdev)
182 {
183 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
184
185 if (di->vsel_gpio) {
186 gpiod_set_raw_value(di->vsel_gpio, di->sleep_vsel_id);
187 return 0;
188 }
189
190 return regmap_update_bits(di->regmap, di->en_reg,
191 VSEL_BUCK_EN, 0);
192 }
193
rk860x_is_enabled(struct regulator_dev * rdev)194 static int rk860x_is_enabled(struct regulator_dev *rdev)
195 {
196 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
197 unsigned int val;
198 int ret = 0;
199
200 if (di->vsel_gpio) {
201 if (di->sleep_vsel_id)
202 return !gpiod_get_raw_value(di->vsel_gpio);
203 else
204 return gpiod_get_raw_value(di->vsel_gpio);
205 }
206
207 ret = regmap_read(di->regmap, di->en_reg, &val);
208 if (ret < 0)
209 return ret;
210 if (val & VSEL_BUCK_EN)
211 return 1;
212 else
213 return 0;
214 }
215
rk860x_set_mode(struct regulator_dev * rdev,unsigned int mode)216 static int rk860x_set_mode(struct regulator_dev *rdev, unsigned int mode)
217 {
218 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
219
220 switch (mode) {
221 case REGULATOR_MODE_FAST:
222 regmap_update_bits(di->regmap, di->mode_reg,
223 di->mode_mask, di->mode_mask);
224 break;
225 case REGULATOR_MODE_NORMAL:
226 regmap_update_bits(di->regmap, di->mode_reg, di->mode_mask, 0);
227 break;
228 default:
229 return -EINVAL;
230 }
231 return 0;
232 }
233
rk860x_get_mode(struct regulator_dev * rdev)234 static unsigned int rk860x_get_mode(struct regulator_dev *rdev)
235 {
236 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
237 unsigned int val;
238 int ret = 0;
239
240 ret = regmap_read(di->regmap, di->mode_reg, &val);
241 if (ret < 0)
242 return ret;
243 if (val & di->mode_mask)
244 return REGULATOR_MODE_FAST;
245 else
246 return REGULATOR_MODE_NORMAL;
247 }
248
249 static const int slew_rates[] = {
250 64000,
251 32000,
252 16000,
253 8000,
254 4000,
255 2000,
256 1000,
257 500,
258 };
259
rk860x_set_ramp(struct regulator_dev * rdev,int ramp)260 static int rk860x_set_ramp(struct regulator_dev *rdev, int ramp)
261 {
262 struct rk860x_device_info *di = rdev_get_drvdata(rdev);
263 int regval = -1, i;
264 const int *slew_rate_t;
265 int slew_rate_n;
266
267 slew_rate_t = slew_rates;
268 slew_rate_n = ARRAY_SIZE(slew_rates);
269
270 for (i = 0; i < slew_rate_n; i++) {
271 if (ramp <= slew_rate_t[i])
272 regval = i;
273 else
274 break;
275 }
276
277 if (regval < 0) {
278 dev_err(di->dev, "unsupported ramp value %d\n", ramp);
279 return -EINVAL;
280 }
281
282 return regmap_update_bits(di->regmap, di->slew_reg,
283 di->slew_mask, regval << di->slew_shift);
284 }
285
286 static const struct regulator_ops rk860x_regulator_ops = {
287 .set_voltage_sel = regulator_set_voltage_sel_regmap,
288 .get_voltage_sel = rk860x_get_voltage,
289 .set_voltage_time_sel = regulator_set_voltage_time_sel,
290 .map_voltage = regulator_map_voltage_linear,
291 .list_voltage = regulator_list_voltage_linear,
292 .set_suspend_voltage = rk860x_set_suspend_voltage,
293 .enable = rk860x_set_enable,
294 .disable = rk860x_set_disable,
295 .is_enabled = rk860x_is_enabled,
296 .set_mode = rk860x_set_mode,
297 .get_mode = rk860x_get_mode,
298 .set_ramp_delay = rk860x_set_ramp,
299 .set_suspend_enable = rk860x_set_suspend_enable,
300 .set_suspend_disable = rk860x_set_suspend_disable,
301 .resume = rk860x_resume,
302 };
303
304 /* For 00,01 options:
305 * VOUT = 0.7125V + NSELx * 12.5mV, from 0.7125 to 1.5V.
306 * For 02,03 options:
307 * VOUT = 0.5V + NSELx * 6.25mV, from 0.5 to 1.5V.
308 */
rk860x_device_setup(struct rk860x_device_info * di,struct rk860x_platform_data * pdata)309 static int rk860x_device_setup(struct rk860x_device_info *di,
310 struct rk860x_platform_data *pdata)
311 {
312 int ret = 0;
313 u32 val = 0;
314
315 switch (di->chip_id) {
316 case RK860X_CHIP_ID_00:
317 case RK860X_CHIP_ID_01:
318 di->vsel_min = 712500;
319 di->vsel_step = 12500;
320 di->n_voltages = RK860X_NVOLTAGES_64;
321 di->vol_mask = VSEL_A_NSEL_MASK;
322 if (di->sleep_vsel_id) {
323 di->sleep_reg = RK860X_VSEL1_A;
324 di->vol_reg = RK860X_VSEL0_A;
325 di->mode_reg = RK860X_VSEL0_A;
326 di->en_reg = RK860X_VSEL0_A;
327 di->sleep_en_reg = RK860X_VSEL1_A;
328 } else {
329 di->sleep_reg = RK860X_VSEL0_A;
330 di->vol_reg = RK860X_VSEL1_A;
331 di->mode_reg = RK860X_VSEL1_A;
332 di->en_reg = RK860X_VSEL1_A;
333 di->sleep_en_reg = RK860X_VSEL0_A;
334 }
335 break;
336 case RK860X_CHIP_ID_02:
337 case RK860X_CHIP_ID_03:
338 di->vsel_min = 500000;
339 di->vsel_step = 6250;
340 di->n_voltages = RK860X_NVOLTAGES_160;
341 di->vol_mask = VSEL_B_NSEL_MASK;
342 if (di->sleep_vsel_id) {
343 di->sleep_reg = RK860X_VSEL1_B;
344 di->vol_reg = RK860X_VSEL0_B;
345 di->mode_reg = RK860X_VSEL0_A;
346 di->en_reg = RK860X_VSEL0_A;
347 di->sleep_en_reg = RK860X_VSEL1_A;
348 } else {
349 di->sleep_reg = RK860X_VSEL0_B;
350 di->vol_reg = RK860X_VSEL1_B;
351 di->mode_reg = RK860X_VSEL1_A;
352 di->en_reg = RK860X_VSEL1_A;
353 di->sleep_en_reg = RK860X_VSEL0_A;
354 }
355 break;
356 default:
357 dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id);
358 return -EINVAL;
359 }
360
361 di->mode_mask = VSEL_MODE;
362 di->slew_reg = RK860X_CONTROL;
363 di->slew_mask = CTL_SLEW_MASK;
364 di->slew_shift = CTL_SLEW_SHIFT;
365
366 if (pdata->limit_volt) {
367 if (pdata->limit_volt < di->vsel_min ||
368 pdata->limit_volt > 1500000)
369 pdata->limit_volt = 1500000;
370 val = (pdata->limit_volt - di->vsel_min) / di->vsel_step;
371 ret = regmap_write(di->regmap, RK860X_MAX_SET, val);
372 if (ret < 0) {
373 dev_err(di->dev, "Failed to set limit voltage!\n");
374 return ret;
375 }
376 }
377
378 return ret;
379 }
380
rk860x_regulator_register(struct rk860x_device_info * di,struct regulator_config * config)381 static int rk860x_regulator_register(struct rk860x_device_info *di,
382 struct regulator_config *config)
383 {
384 struct regulator_desc *rdesc = &di->desc;
385
386 rdesc->name = "rk860x-reg";
387 rdesc->supply_name = "vin";
388 rdesc->ops = &rk860x_regulator_ops;
389 rdesc->type = REGULATOR_VOLTAGE;
390 rdesc->n_voltages = di->n_voltages;
391 rdesc->enable_reg = di->en_reg;
392 rdesc->enable_mask = VSEL_BUCK_EN;
393 rdesc->min_uV = di->vsel_min;
394 rdesc->uV_step = di->vsel_step;
395 rdesc->vsel_reg = di->vol_reg;
396 rdesc->vsel_mask = di->vol_mask;
397 rdesc->owner = THIS_MODULE;
398 rdesc->enable_time = 400;
399
400 di->rdev = devm_regulator_register(di->dev, &di->desc, config);
401 return PTR_ERR_OR_ZERO(di->rdev);
402 }
403
404 static const struct regmap_config rk860x_regmap_config = {
405 .reg_bits = 8,
406 .val_bits = 8,
407 };
408
409 static struct rk860x_platform_data *
rk860x_parse_dt(struct device * dev,struct device_node * np,const struct regulator_desc * desc)410 rk860x_parse_dt(struct device *dev, struct device_node *np,
411 const struct regulator_desc *desc)
412 {
413 struct rk860x_platform_data *pdata;
414 int ret, flag, limit_volt;
415 u32 tmp;
416
417 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
418 if (!pdata)
419 return NULL;
420
421 pdata->regulator = of_get_regulator_init_data(dev, np, desc);
422 pdata->regulator->constraints.initial_state = PM_SUSPEND_MEM;
423
424 if (!(of_property_read_u32(np, "limit-microvolt", &limit_volt)))
425 pdata->limit_volt = limit_volt;
426
427 ret = of_property_read_u32(np, "rockchip,suspend-voltage-selector",
428 &tmp);
429 if (!ret)
430 pdata->sleep_vsel_id = tmp;
431
432 if (pdata->sleep_vsel_id)
433 flag = GPIOD_OUT_LOW;
434 else
435 flag = GPIOD_OUT_HIGH;
436
437 pdata->vsel_gpio = devm_gpiod_get_index_optional(dev, "vsel", 0, flag);
438 if (IS_ERR(pdata->vsel_gpio)) {
439 ret = PTR_ERR(pdata->vsel_gpio);
440 dev_err(dev, "failed to get vesl gpio (%d)\n", ret);
441 pdata->vsel_gpio = NULL;
442 }
443
444 return pdata;
445 }
446
447 static const struct of_device_id rk860x_dt_ids[] = {
448 {
449 .compatible = "rockchip,rk8600",
450 .data = (void *)RK860X_CHIP_ID_00
451 },
452 {
453 .compatible = "rockchip,rk8601",
454 .data = (void *)RK860X_CHIP_ID_01
455 },
456 {
457 .compatible = "rockchip,rk8602",
458 .data = (void *)RK860X_CHIP_ID_02
459 },
460 {
461 .compatible = "rockchip,rk8603",
462 .data = (void *)RK860X_CHIP_ID_03
463 },
464
465 { }
466 };
467 MODULE_DEVICE_TABLE(of, rk860x_dt_ids);
468
rk860x_regulator_probe(struct i2c_client * client,const struct i2c_device_id * id)469 static int rk860x_regulator_probe(struct i2c_client *client,
470 const struct i2c_device_id *id)
471 {
472 struct device_node *np = client->dev.of_node;
473 struct rk860x_device_info *di;
474 struct rk860x_platform_data *pdata;
475 struct regulator_config config = { };
476 unsigned int val;
477 int ret;
478
479 di = devm_kzalloc(&client->dev, sizeof(*di), GFP_KERNEL);
480 if (!di)
481 return -ENOMEM;
482
483 di->desc.of_map_mode = rk860x_map_mode;
484
485 pdata = dev_get_platdata(&client->dev);
486 if (!pdata)
487 pdata = rk860x_parse_dt(&client->dev, np, &di->desc);
488
489 if (!pdata || !pdata->regulator) {
490 dev_err(&client->dev, "Platform data not found!\n");
491 return -ENODEV;
492 }
493
494 di->vsel_gpio = pdata->vsel_gpio;
495 di->sleep_vsel_id = pdata->sleep_vsel_id;
496
497 di->regulator = pdata->regulator;
498 if (client->dev.of_node) {
499 di->chip_id =
500 (unsigned long)of_device_get_match_data(&client->dev);
501 } else {
502 /* if no ramp constraint set, get the pdata ramp_delay */
503 if (!di->regulator->constraints.ramp_delay) {
504 int slew_idx = (pdata->slew_rate & 0x7)
505 ? pdata->slew_rate : 0;
506
507 di->regulator->constraints.ramp_delay =
508 slew_rates[slew_idx];
509 }
510 di->chip_id = id->driver_data;
511 }
512
513 di->regmap = devm_regmap_init_i2c(client, &rk860x_regmap_config);
514 if (IS_ERR(di->regmap)) {
515 dev_err(&client->dev, "Failed to allocate regmap!\n");
516 return PTR_ERR(di->regmap);
517 }
518 di->dev = &client->dev;
519 i2c_set_clientdata(client, di);
520 /* Get chip ID */
521 ret = regmap_read(di->regmap, RK860X_ID1, &val);
522 if (ret < 0) {
523 dev_err(&client->dev, "Failed to get chip ID!\n");
524 return ret;
525 }
526
527 switch (di->chip_id) {
528 case RK860X_CHIP_ID_00:
529 case RK860X_CHIP_ID_01:
530 if ((val & DIE_ID) != 0x8) {
531 dev_err(&client->dev, "Failed to match chip ID!\n");
532 return -EINVAL;
533 }
534 break;
535 case RK860X_CHIP_ID_02:
536 case RK860X_CHIP_ID_03:
537 if ((val & DIE_ID) != 0xa) {
538 dev_err(&client->dev, "Failed to match chip ID!\n");
539 return -EINVAL;
540 }
541 break;
542 default:
543 return -EINVAL;
544 }
545
546 /* Device init */
547 ret = rk860x_device_setup(di, pdata);
548 if (ret < 0) {
549 dev_err(&client->dev, "Failed to setup device!\n");
550 return ret;
551 }
552 /* Register regulator */
553 config.dev = di->dev;
554 config.init_data = di->regulator;
555 config.regmap = di->regmap;
556 config.driver_data = di;
557 config.of_node = np;
558
559 ret = rk860x_regulator_register(di, &config);
560 if (ret < 0)
561 dev_err(&client->dev, "Failed to register regulator!\n");
562
563 return ret;
564 }
565
rk860x_regulator_shutdown(struct i2c_client * client)566 static void rk860x_regulator_shutdown(struct i2c_client *client)
567 {
568 struct rk860x_device_info *di;
569 int ret;
570
571 di = i2c_get_clientdata(client);
572
573 dev_info(di->dev, "rk860..... reset\n");
574
575 ret = regmap_update_bits(di->regmap, di->slew_reg,
576 CTL_RESET, CTL_RESET);
577
578 if (ret < 0)
579 dev_err(di->dev, "force rk860x_reset error! ret=%d\n", ret);
580 else
581 dev_info(di->dev, "force rk860x_reset ok!\n");
582 }
583
584 static const struct i2c_device_id rk860x_id[] = {
585 { .name = "rk8600", .driver_data = RK860X_CHIP_ID_00 },
586 { .name = "rk8601", .driver_data = RK860X_CHIP_ID_01 },
587 { .name = "rk8602", .driver_data = RK860X_CHIP_ID_02 },
588 { .name = "rk8603", .driver_data = RK860X_CHIP_ID_03 },
589 {},
590 };
591 MODULE_DEVICE_TABLE(i2c, rk860x_id);
592
593 static struct i2c_driver rk860x_regulator_driver = {
594 .driver = {
595 .name = "rk860-regulator",
596 .of_match_table = of_match_ptr(rk860x_dt_ids),
597 },
598 .probe = rk860x_regulator_probe,
599 .shutdown = rk860x_regulator_shutdown,
600 .id_table = rk860x_id,
601 };
602
603 module_i2c_driver(rk860x_regulator_driver);
604
605 MODULE_AUTHOR("Elaine Zhang <zhangqing@rock-chips.com>");
606 MODULE_DESCRIPTION("rk860x regulator driver");
607 MODULE_LICENSE("GPL v2");
608