2 * drivers/regulator/rt5036-regulator.c
3 * Driver for Richtek RT5036 PMIC Regulator
5 * Copyright (C) 2014 Richtek Technology Corp.
6 * cy_huang <cy_huang@richtek.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/err.h>
17 #include <linux/i2c.h>
18 #include <linux/platform_device.h>
19 #include <linux/regulator/machine.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/version.h>
23 #include <linux/regulator/of_regulator.h>
24 #endif /* #ifdef CONFIG_OF */
26 #include <linux/mfd/rt5036/rt5036.h>
27 #include <linux/regulator/rt5036-regulator.h>
29 struct rt5036_regulator_info {
30 struct regulator_desc desc;
31 struct regulator_dev *regulator;
32 struct i2c_client *i2c;
33 const unsigned int *vol_output_list;
34 const int vol_output_size;
37 unsigned char nvol_reg;
38 unsigned char nvol_shift;
39 unsigned char nvol_mask;
40 unsigned char nenable_reg;
41 unsigned char nenable_bit;
42 unsigned char nmode_reg;
43 unsigned char nmode_bit;
44 unsigned char nramp_reg;
45 unsigned char nramp_bit;
46 unsigned char nramp_shift;
47 unsigned char svol_reg;
48 unsigned char svol_shift;
49 unsigned char svol_mask;
50 unsigned char senable_reg;
51 unsigned char senable_bit;
52 unsigned char smode_reg;
53 unsigned char smode_bit;
54 unsigned char sramp_reg;
55 unsigned char sramp_bit;
56 unsigned char sramp_shift;
59 /*For DCDC1~4 and LDO1~4 and LSW1~2*/
60 static const unsigned int rt5036_vol_output_list[] = {
62 800 * 1000, 825 * 1000, 850 * 1000, 875 * 1000, 900 * 1000, 925 * 1000,
63 950 * 1000, 975 * 1000,
65 1000 * 1000, 1025 * 1000, 1050 * 1000, 1075 * 1000, 1100 * 1000,
66 1125 * 1000, 1150 * 1000, 1175 * 1000,
68 1200 * 1000, 1225 * 1000, 1250 * 1000, 1275 * 1000, 1300 * 1000,
69 1325 * 1000, 1350 * 1000, 1375 * 1000,
71 1400 * 1000, 1425 * 1000, 1450 * 1000, 1475 * 1000, 1500 * 1000,
72 1525 * 1000, 1550 * 1000, 1575 * 1000,
74 1600 * 1000, 1625 * 1000, 1650 * 1000, 1675 * 1000, 1700 * 1000,
75 1725 * 1000, 1750 * 1000, 1775 * 1000,
77 1800 * 1000, 1825 * 1000, 1850 * 1000, 1875 * 1000, 1900 * 1000,
78 1925 * 1000, 1950 * 1000, 1975 * 1000,
80 2000 * 1000, 2025 * 1000, 2050 * 1000, 2075 * 1000, 2100 * 1000,
81 2125 * 1000, 2150 * 1000, 2175 * 1000,
83 2200 * 1000, 2225 * 1000, 2250 * 1000, 2275 * 1000, 2300 * 1000,
84 2325 * 1000, 2350 * 1000, 2375 * 1000,
86 2400 * 1000, 2425 * 1000, 2450 * 1000, 2475 * 1000, 2500 * 1000,
87 2525 * 1000, 2550 * 1000, 2575 * 1000,
89 2600 * 1000, 2625 * 1000, 2650 * 1000, 2675 * 1000, 2700 * 1000,
90 2725 * 1000, 2750 * 1000, 2775 * 1000,
92 2800 * 1000, 2825 * 1000, 2850 * 1000, 2875 * 1000, 2900 * 1000,
93 2925 * 1000, 2950 * 1000, 2975 * 1000,
95 3000 * 1000, 3025 * 1000, 3050 * 1000, 3075 * 1000, 3100 * 1000,
96 3125 * 1000, 3150 * 1000, 3175 * 1000,
98 3200 * 1000, 3225 * 1000, 3250 * 1000, 3275 * 1000, 3300 * 1000,
99 3300 * 1000, 3300 * 1000, 3300 * 1000,
101 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
102 3300 * 1000, 3300 * 1000, 3300 * 1000,
104 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
105 3300 * 1000, 3300 * 1000, 3300 * 1000,
107 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
108 3300 * 1000, 3300 * 1000, 3300 * 1000,
111 #define rt5036_vol_output_size ARRAY_SIZE(rt5036_vol_output_list)
113 static inline int check_range(struct rt5036_regulator_info *info,
114 int min_uV, int max_uV)
116 if (min_uV < info->min_uV || min_uV > info->max_uV)
121 static int rt5036_list_voltage(struct regulator_dev *rdev, unsigned index)
123 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
125 return (index >= info->vol_output_size) ?
126 -EINVAL : info->vol_output_list[index];
129 static int rt5036_find_voltage(struct regulator_dev *rdev,
130 int min_uV, int max_uV)
132 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
134 const int count = info->vol_output_size;
136 for (i = 0; i < count; i++) {
137 if ((info->vol_output_list[i] >= min_uV)
138 && (info->vol_output_list[i] <= max_uV))
144 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
145 static int rt5036_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
147 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
149 const int count = info->vol_output_size;
151 if (selector > count)
153 data = (unsigned char)selector;
154 data <<= info->nvol_shift;
155 return rt5036_assign_bits(info->i2c, info->nvol_reg, info->nvol_mask,
159 static int rt5036_get_voltage_sel(struct regulator_dev *rdev)
161 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
164 ret = rt5036_reg_read(info->i2c, info->nvol_reg);
167 return (ret & info->nvol_mask) >> info->nvol_shift;
171 static int rt5036_set_voltage(struct regulator_dev *rdev,
172 int min_uV, int max_uV, unsigned *selector)
174 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
177 if (check_range(info, min_uV, max_uV)) {
178 dev_err(&rdev->dev, "invalid voltage range (%d, %d) uV\n",
182 data = rt5036_find_voltage(rdev, min_uV, max_uV);
183 data <<= info->nvol_shift;
184 return rt5036_assign_bits(info->i2c, info->nvol_reg, info->nvol_mask,
188 static int rt5036_get_voltage(struct regulator_dev *rdev)
190 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
193 ret = rt5036_reg_read(info->i2c, info->nvol_reg);
196 ret = (ret & info->nvol_mask) >> info->nvol_shift;
197 return rt5036_list_voltage(rdev, ret);
199 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
201 static int rt5036_enable(struct regulator_dev *rdev)
203 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
205 return rt5036_set_bits(info->i2c, info->nenable_reg, info->nenable_bit);
208 static int rt5036_disable(struct regulator_dev *rdev)
210 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
212 return rt5036_clr_bits(info->i2c, info->nenable_reg, info->nenable_bit);
215 static int rt5036_is_enabled(struct regulator_dev *rdev)
217 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
220 ret = rt5036_reg_read(info->i2c, info->nenable_reg);
223 return (ret & info->nenable_bit) ? 1 : 0;
226 static int rt5036_set_mode(struct regulator_dev *rdev, unsigned int mode)
228 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
232 case REGULATOR_MODE_NORMAL:
234 rt5036_set_bits(info->i2c, info->nmode_reg,
237 case REGULATOR_MODE_FAST:
239 rt5036_clr_bits(info->i2c, info->nmode_reg,
249 static unsigned int rt5036_get_mode(struct regulator_dev *rdev)
251 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
255 data = rt5036_reg_read(info->i2c, info->nmode_reg);
257 (data & info->nmode_bit) ? REGULATOR_MODE_NORMAL :
262 static int rt5036_set_suspend_voltage(struct regulator_dev *rdev, int uV)
264 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
267 if (check_range(info, uV, uV)) {
268 dev_err(&rdev->dev, "invalid voltage range (%d, %d) uV\n",
272 data = rt5036_find_voltage(rdev, uV, uV);
273 data <<= info->svol_shift;
274 return rt5036_assign_bits(info->i2c, info->svol_reg, info->svol_mask,
278 static int rt5036_set_suspend_enable(struct regulator_dev *rdev)
280 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
282 return rt5036_set_bits(info->i2c, info->senable_reg, info->senable_bit);
285 static int rt5036_set_suspend_disable(struct regulator_dev *rdev)
287 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
289 return rt5036_clr_bits(info->i2c, info->senable_reg, info->senable_bit);
292 static int rt5036_set_suspend_mode(struct regulator_dev *rdev,
295 struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
299 case REGULATOR_MODE_NORMAL:
301 rt5036_set_bits(info->i2c, info->smode_reg,
304 case REGULATOR_MODE_FAST:
306 rt5036_clr_bits(info->i2c, info->smode_reg,
316 static struct regulator_ops rt5036_regulator_ops = {
317 .list_voltage = rt5036_list_voltage,
318 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
319 .get_voltage_sel = rt5036_get_voltage_sel,
320 .set_voltage_sel = rt5036_set_voltage_sel,
322 .set_voltage = rt5036_set_voltage,
323 .get_voltage = rt5036_get_voltage,
324 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
325 .enable = rt5036_enable,
326 .disable = rt5036_disable,
327 .is_enabled = rt5036_is_enabled,
328 .set_mode = rt5036_set_mode,
329 .get_mode = rt5036_get_mode,
330 .set_suspend_voltage = rt5036_set_suspend_voltage,
331 .set_suspend_enable = rt5036_set_suspend_enable,
332 .set_suspend_disable = rt5036_set_suspend_disable,
333 .set_suspend_mode = rt5036_set_suspend_mode,
336 #define RT5036_VOUT_LIST rt5036_vol_output_list
337 #define RT5036_VOUT_SIZE rt5036_vol_output_size
339 #define RT5036_DCDC(_id, min, max) \
342 .name = "rt5036-dcdc" #_id, \
343 .n_voltages = RT5036_VOUT_SIZE, \
344 .ops = &rt5036_regulator_ops, \
345 .type = REGULATOR_VOLTAGE, \
346 .id = RT5036_ID_DCDC##_id, \
347 .owner = THIS_MODULE, \
349 .vol_output_list = RT5036_VOUT_LIST, \
350 .vol_output_size = RT5036_VOUT_SIZE, \
351 .min_uV = min * 1000, \
352 .max_uV = max * 1000, \
353 .nvol_reg = RT5036_REG_BUCKVN##_id, \
354 .nvol_shift = RT5036_DCDCVOUT_SHIFT##_id, \
355 .nvol_mask = RT5036_DCDCVOUT_MASK##_id, \
356 .nenable_reg = RT5036_REG_BUCKLDONEN, \
357 .nenable_bit = RT5036_DCDCEN_MASK##_id, \
358 .nmode_reg = RT5036_REG_BUCKVRCNEN, \
359 .nmode_bit = RT5036_DCDCMODE_MASK##_id, \
360 .nramp_reg = RT5036_REG_BUCKVRCN, \
361 .nramp_bit = RT5036_DCDCRAMP_MASK##_id, \
362 .nramp_shift = RT5036_DCDCRAMP_SHIFT##_id, \
363 .svol_reg = RT5036_REG_BUCKVS##_id, \
364 .svol_shift = RT5036_DCDCVOUT_SHIFT##_id, \
365 .svol_mask = RT5036_DCDCVOUT_MASK##_id, \
366 .senable_reg = RT5036_REG_BUCKLDOSEN, \
367 .senable_bit = RT5036_DCDCEN_MASK##_id, \
368 .smode_reg = RT5036_REG_BUCKVRCSEN, \
369 .smode_bit = RT5036_DCDCMODE_MASK##_id, \
370 .sramp_reg = RT5036_REG_BUCKVRCS, \
371 .sramp_bit = RT5036_DCDCRAMP_MASK##_id, \
372 .sramp_shift = RT5036_DCDCRAMP_SHIFT##_id, \
375 #define RT5036_LDO(_id, min, max) \
378 .name = "rt5036-ldo" #_id, \
379 .n_voltages = RT5036_VOUT_SIZE, \
380 .ops = &rt5036_regulator_ops, \
381 .type = REGULATOR_VOLTAGE, \
382 .id = RT5036_ID_LDO##_id, \
383 .owner = THIS_MODULE, \
385 .vol_output_list = RT5036_VOUT_LIST, \
386 .vol_output_size = RT5036_VOUT_SIZE, \
387 .min_uV = min * 1000, \
388 .max_uV = max * 1000, \
389 .nvol_reg = RT5036_REG_LDOVN##_id, \
390 .nvol_shift = RT5036_LDOVOUT_SHIFT##_id, \
391 .nvol_mask = RT5036_LDOVOUT_MASK##_id, \
392 .nenable_reg = RT5036_REG_BUCKLDONEN, \
393 .nenable_bit = RT5036_LDOEN_MASK##_id, \
394 .nmode_reg = RT5036_REG_LDOVRCNEN, \
395 .nmode_bit = RT5036_LDOMODE_MASK##_id, \
396 .nramp_reg = RT5036_REG_LDOVRCN, \
397 .nramp_bit = RT5036_LDORAMP_MASK##_id, \
398 .nramp_shift = RT5036_LDORAMP_SHIFT##_id, \
399 .svol_reg = RT5036_REG_LDOVS##_id, \
400 .svol_shift = RT5036_LDOVOUT_SHIFT##_id, \
401 .svol_mask = RT5036_LDOVOUT_MASK##_id, \
402 .senable_reg = RT5036_REG_BUCKLDOSEN, \
403 .senable_bit = RT5036_LDOEN_MASK##_id, \
404 .smode_reg = RT5036_REG_LDOVRCSEN, \
405 .smode_bit = RT5036_LDOMODE_MASK##_id, \
406 .sramp_reg = RT5036_REG_LDOVRCS, \
407 .sramp_bit = RT5036_LDORAMP_MASK##_id, \
408 .sramp_shift = RT5036_LDORAMP_SHIFT##_id, \
411 #define RT5036_LSW(_id, min, max) \
414 .name = "rt5036-lsw" #_id, \
415 .n_voltages = RT5036_VOUT_SIZE, \
416 .ops = &rt5036_regulator_ops, \
417 .type = REGULATOR_VOLTAGE, \
418 .id = RT5036_ID_LSW##_id, \
419 .owner = THIS_MODULE, \
421 .vol_output_list = RT5036_VOUT_LIST, \
422 .vol_output_size = RT5036_VOUT_SIZE, \
423 .min_uV = min * 1000, \
424 .max_uV = max * 1000, \
425 .nvol_reg = RT5036_REG_LSWVN##_id, \
426 .nvol_shift = RT5036_LSWVOUT_SHIFT##_id, \
427 .nvol_mask = RT5036_LSWVOUT_MASK##_id, \
428 .nenable_reg = RT5036_REG_LSWEN, \
429 .nenable_bit = RT5036_LSWNEN_MASK##_id, \
430 .nmode_reg = RT5036_REG_LSWVRCEN, \
431 .nmode_bit = RT5036_LSWNMODE_MASK##_id, \
432 .nramp_reg = RT5036_REG_LSWVRC, \
433 .nramp_bit = RT5036_LSWNRAMP_MASK##_id, \
434 .nramp_shift = RT5036_LSWNRAMP_SHIFT##_id, \
435 .svol_reg = RT5036_REG_LSWVS##_id, \
436 .svol_shift = RT5036_LSWVOUT_SHIFT##_id, \
437 .svol_mask = RT5036_LSWVOUT_MASK##_id, \
438 .senable_reg = RT5036_REG_LSWEN, \
439 .senable_bit = RT5036_LSWSEN_MASK##_id, \
440 .smode_reg = RT5036_REG_LSWVRCEN, \
441 .smode_bit = RT5036_LSWSMODE_MASK##_id, \
442 .sramp_reg = RT5036_REG_LSWVRC, \
443 .sramp_bit = RT5036_LSWSRAMP_MASK##_id, \
444 .sramp_shift = RT5036_LSWSRAMP_SHIFT##_id, \
447 static struct rt5036_regulator_info rt5036_regulator_info[] = {
448 RT5036_DCDC(1, 800, 3300),
449 RT5036_DCDC(2, 800, 3300),
450 RT5036_DCDC(3, 800, 3300),
451 RT5036_DCDC(4, 800, 3300),
452 RT5036_LDO(1, 800, 3300),
453 RT5036_LDO(2, 800, 3300),
454 RT5036_LDO(3, 800, 3300),
455 RT5036_LDO(4, 800, 3300),
456 RT5036_LSW(1, 800, 3300),
457 RT5036_LSW(2, 800, 3300),
460 static struct rt5036_regulator_info *find_regulator_info(int id)
462 struct rt5036_regulator_info *ri;
465 for (i = 0; i < ARRAY_SIZE(rt5036_regulator_info); i++) {
466 ri = &rt5036_regulator_info[i];
467 if (ri->desc.id == id)
473 inline struct regulator_dev *rt5036_regulator_register(struct regulator_desc
481 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
482 struct regulator_config config = {
484 .init_data = init_data,
485 .driver_data = driver_data,
486 .of_node = dev->of_node,
488 return regulator_register(regulator_desc, &config);
489 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 37))
490 return regulator_register(regulator_desc, dev, init_data, driver_data,
493 return regulator_register(regulator_desc, dev, init_data, driver_data);
494 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) */
497 static struct regulator_init_data *rt_parse_dt(struct
498 rt5036_regulator_info
502 struct regulator_init_data *init_data = NULL;
504 struct device_node *np = dev->of_node;
508 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
509 init_data = of_get_regulator_init_data(dev, dev->of_node);
511 init_data = of_get_regulator_init_data(dev);
512 #endif /* #if (LINUX_KERNEL_VERSION >= KERNEL_VERSION(3,3,0)) */
515 init_data->supply_regulator = (char *)of_get_property(np,
518 rc = of_property_read_u32(np, "rt,standby_vol", &tmp);
520 dev_info(dev, "no standby voltage specified\n");
522 init_data->constraints.state_standby.uV = tmp;
523 if (of_property_read_bool(np, "rt,standby_enabled")) {
524 init_data->constraints.state_standby.enabled = 1;
525 init_data->constraints.initial_state =
528 if (of_property_read_bool(np, "rt,standby_disabled")) {
529 init_data->constraints.state_standby.disabled = 1;
530 init_data->constraints.initial_state =
535 rc = of_property_read_u32(np, "rt,nramp_sel", &tmp);
537 dev_info(dev, "no nramp_sel property, use default value\n");
539 if (tmp > RT5036_RAMP_MAX)
540 tmp = RT5036_RAMP_MAX;
541 rt5036_assign_bits(ri->i2c, ri->nramp_reg, ri->nramp_bit,
542 tmp << ri->nramp_shift);
545 rc = of_property_read_u32(np, "rt,sramp_sel", &tmp);
547 dev_info(dev, "no sramp_sel property, use default value\n");
549 if (tmp > RT5036_RAMP_MAX)
550 tmp = RT5036_RAMP_MAX;
551 rt5036_assign_bits(ri->i2c, ri->sramp_reg, ri->sramp_bit,
552 tmp << ri->sramp_shift);
555 if (of_property_read_bool(np, "rt,allow_mode_mask")) {
556 init_data->constraints.valid_modes_mask |=
557 (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL);
558 init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE;
560 #endif /* #ifdef CONFIG_OF */
564 static int rt5036_regulator_probe(struct platform_device *pdev)
566 struct rt5036_chip *chip = dev_get_drvdata(pdev->dev.parent);
567 struct rt5036_platform_data *pdata = (pdev->dev.parent)->platform_data;
568 struct rt5036_regulator_info *ri;
569 struct rt5036_regulator_ramp *ramp;
570 struct regulator_dev *rdev;
571 struct regulator_init_data *init_data;
572 bool use_dt = pdev->dev.of_node;
574 ri = find_regulator_info(pdev->id);
576 dev_err(&pdev->dev, "invalid regulator ID specified\n");
582 init_data = rt_parse_dt(ri, &pdev->dev);
586 init_data = pdata->regulator[pdev->id];
587 ramp = init_data ? init_data->driver_data : NULL;
589 rt5036_assign_bits(ri->i2c, ri->nramp_reg,
591 ramp->nramp_sel << ri->nramp_shift);
592 rt5036_assign_bits(ri->i2c, ri->sramp_reg,
594 ramp->sramp_sel << ri->sramp_shift);
599 dev_err(&pdev->dev, "no initializing data\n");
603 rdev = rt5036_regulator_register(&ri->desc, &pdev->dev, init_data, ri);
605 dev_err(&pdev->dev, "failed to register regulator %s\n",
607 return PTR_ERR(rdev);
610 platform_set_drvdata(pdev, rdev);
611 /*dev_info(&pdev->dev, "regulator successfully registered\n");*/
616 static int rt5036_regulator_remove(struct platform_device *pdev)
618 struct regulator_dev *rdev = platform_get_drvdata(pdev);
620 regulator_unregister(rdev);
625 static const struct of_device_id rt_match_table[] = {
626 {.compatible = "rt,rt5036-dcdc1",},
627 {.compatible = "rt,rt5036-dcdc2",},
628 {.compatible = "rt,rt5036-dcdc3",},
629 {.compatible = "rt,rt5036-dcdc4",},
630 {.compatible = "rt,rt5036-ldo1",},
631 {.compatible = "rt,rt5036-ldo2",},
632 {.compatible = "rt,rt5036-ldo3",},
633 {.compatible = "rt,rt5036-ldo4",},
634 {.compatible = "rt,rt5036-lsw1",},
635 {.compatible = "rt,rt5036-lsw2",},
639 static struct platform_driver rt5036_regulator_driver = {
641 .name = RT5036_DEV_NAME "-regulator",
642 .owner = THIS_MODULE,
643 .of_match_table = rt_match_table,
645 .probe = rt5036_regulator_probe,
646 .remove = rt5036_regulator_remove,
649 static int __init rt5036_regulator_init(void)
651 return platform_driver_register(&rt5036_regulator_driver);
653 subsys_initcall(rt5036_regulator_init);
655 static void __exit rt5036_regulator_exit(void)
657 platform_driver_unregister(&rt5036_regulator_driver);
659 module_exit(rt5036_regulator_exit);
661 MODULE_LICENSE("GPL");
662 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
663 MODULE_DESCRIPTION("Regulator driver for RT5036");
664 MODULE_ALIAS("platform:" RT5036_DEV_NAME "-regulator");
665 MODULE_VERSION(RT5036_DRV_VER);