Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Regulator driver for Rockchip RK805/RK808/RK818
0004  *
0005  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
0006  *
0007  * Author: Chris Zhong <zyw@rock-chips.com>
0008  * Author: Zhang Qing <zhangqing@rock-chips.com>
0009  *
0010  * Copyright (C) 2016 PHYTEC Messtechnik GmbH
0011  *
0012  * Author: Wadim Egorov <w.egorov@phytec.de>
0013  */
0014 
0015 #include <linux/delay.h>
0016 #include <linux/gpio.h>
0017 #include <linux/i2c.h>
0018 #include <linux/module.h>
0019 #include <linux/of_device.h>
0020 #include <linux/of_gpio.h>
0021 #include <linux/mfd/rk808.h>
0022 #include <linux/regulator/driver.h>
0023 #include <linux/regulator/of_regulator.h>
0024 #include <linux/gpio/consumer.h>
0025 
0026 /* Field Definitions */
0027 #define RK808_BUCK_VSEL_MASK    0x3f
0028 #define RK808_BUCK4_VSEL_MASK   0xf
0029 #define RK808_LDO_VSEL_MASK 0x1f
0030 
0031 #define RK809_BUCK5_VSEL_MASK       0x7
0032 
0033 #define RK817_LDO_VSEL_MASK     0x7f
0034 #define RK817_BOOST_VSEL_MASK       0x7
0035 #define RK817_BUCK_VSEL_MASK        0x7f
0036 
0037 #define RK818_BUCK_VSEL_MASK        0x3f
0038 #define RK818_BUCK4_VSEL_MASK       0x1f
0039 #define RK818_LDO_VSEL_MASK     0x1f
0040 #define RK818_LDO3_ON_VSEL_MASK     0xf
0041 #define RK818_BOOST_ON_VSEL_MASK    0xe0
0042 
0043 /* Ramp rate definitions for buck1 / buck2 only */
0044 #define RK808_RAMP_RATE_OFFSET      3
0045 #define RK808_RAMP_RATE_MASK        (3 << RK808_RAMP_RATE_OFFSET)
0046 #define RK808_RAMP_RATE_2MV_PER_US  (0 << RK808_RAMP_RATE_OFFSET)
0047 #define RK808_RAMP_RATE_4MV_PER_US  (1 << RK808_RAMP_RATE_OFFSET)
0048 #define RK808_RAMP_RATE_6MV_PER_US  (2 << RK808_RAMP_RATE_OFFSET)
0049 #define RK808_RAMP_RATE_10MV_PER_US (3 << RK808_RAMP_RATE_OFFSET)
0050 
0051 #define RK808_DVS2_POL      BIT(2)
0052 #define RK808_DVS1_POL      BIT(1)
0053 
0054 /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
0055 #define RK808_SLP_REG_OFFSET 1
0056 
0057 /* Offset from XXX_ON_VSEL to XXX_DVS_VSEL */
0058 #define RK808_DVS_REG_OFFSET 2
0059 
0060 /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
0061 #define RK808_SLP_SET_OFF_REG_OFFSET 2
0062 
0063 /* max steps for increase voltage of Buck1/2, equal 100mv*/
0064 #define MAX_STEPS_ONE_TIME 8
0065 
0066 #define ENABLE_MASK(id)         (BIT(id) | BIT(4 + (id)))
0067 #define DISABLE_VAL(id)         (BIT(4 + (id)))
0068 
0069 #define RK817_BOOST_DESC(_id, _match, _supply, _min, _max, _step, _vreg,\
0070     _vmask, _ereg, _emask, _enval, _disval, _etime, m_drop)     \
0071     {                           \
0072         .name       = (_match),             \
0073         .supply_name    = (_supply),                \
0074         .of_match   = of_match_ptr(_match),         \
0075         .regulators_node = of_match_ptr("regulators"),      \
0076         .type       = REGULATOR_VOLTAGE,            \
0077         .id     = (_id),                \
0078         .n_voltages = (((_max) - (_min)) / (_step) + 1),    \
0079         .owner      = THIS_MODULE,              \
0080         .min_uV     = (_min) * 1000,            \
0081         .uV_step    = (_step) * 1000,           \
0082         .vsel_reg   = (_vreg),              \
0083         .vsel_mask  = (_vmask),             \
0084         .enable_reg = (_ereg),              \
0085         .enable_mask    = (_emask),             \
0086         .enable_val     = (_enval),             \
0087         .disable_val     = (_disval),               \
0088         .enable_time    = (_etime),             \
0089         .min_dropout_uV = (m_drop) * 1000,          \
0090         .ops        = &rk817_boost_ops,         \
0091     }
0092 
0093 #define RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg,  \
0094     _vmask, _ereg, _emask, _enval, _disval, _etime, _ops)       \
0095     {                               \
0096         .name       = (_match),             \
0097         .supply_name    = (_supply),                \
0098         .of_match   = of_match_ptr(_match),         \
0099         .regulators_node = of_match_ptr("regulators"),      \
0100         .type       = REGULATOR_VOLTAGE,            \
0101         .id     = (_id),                \
0102         .n_voltages = (((_max) - (_min)) / (_step) + 1),    \
0103         .owner      = THIS_MODULE,              \
0104         .min_uV     = (_min) * 1000,            \
0105         .uV_step    = (_step) * 1000,           \
0106         .vsel_reg   = (_vreg),              \
0107         .vsel_mask  = (_vmask),             \
0108         .enable_reg = (_ereg),              \
0109         .enable_mask    = (_emask),             \
0110         .enable_val     = (_enval),             \
0111         .disable_val     = (_disval),               \
0112         .enable_time    = (_etime),             \
0113         .ops        = _ops,         \
0114     }
0115 
0116 #define RK805_DESC(_id, _match, _supply, _min, _max, _step, _vreg,  \
0117     _vmask, _ereg, _emask, _etime)                  \
0118     RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg,  \
0119     _vmask, _ereg, _emask, 0, 0, _etime, &rk805_reg_ops)
0120 
0121 #define RK8XX_DESC(_id, _match, _supply, _min, _max, _step, _vreg,  \
0122     _vmask, _ereg, _emask, _etime)                  \
0123     RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg,  \
0124     _vmask, _ereg, _emask, 0, 0, _etime, &rk808_reg_ops)
0125 
0126 #define RK817_DESC(_id, _match, _supply, _min, _max, _step, _vreg,  \
0127     _vmask, _ereg, _emask, _disval, _etime)             \
0128     RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg,  \
0129     _vmask, _ereg, _emask, _emask, _disval, _etime, &rk817_reg_ops)
0130 
0131 #define RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask,   \
0132     _enval, _disval, _ops)                      \
0133     {                               \
0134         .name       = (_match),             \
0135         .supply_name    = (_supply),                \
0136         .of_match   = of_match_ptr(_match),         \
0137         .regulators_node = of_match_ptr("regulators"),      \
0138         .type       = REGULATOR_VOLTAGE,            \
0139         .id     = (_id),                \
0140         .enable_reg = (_ereg),              \
0141         .enable_mask    = (_emask),             \
0142         .enable_val     = (_enval),             \
0143         .disable_val     = (_disval),               \
0144         .owner      = THIS_MODULE,              \
0145         .ops        = _ops                  \
0146     }
0147 
0148 #define RK817_DESC_SWITCH(_id, _match, _supply, _ereg, _emask,      \
0149     _disval)                            \
0150     RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask,   \
0151     _emask, _disval, &rk817_switch_ops)
0152 
0153 #define RK8XX_DESC_SWITCH(_id, _match, _supply, _ereg, _emask)      \
0154     RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask,   \
0155     0, 0, &rk808_switch_ops)
0156 
0157 struct rk808_regulator_data {
0158     struct gpio_desc *dvs_gpio[2];
0159 };
0160 
0161 static const struct linear_range rk808_ldo3_voltage_ranges[] = {
0162     REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000),
0163     REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0),
0164 };
0165 
0166 #define RK809_BUCK5_SEL_CNT     (8)
0167 
0168 static const struct linear_range rk809_buck5_voltage_ranges[] = {
0169     REGULATOR_LINEAR_RANGE(1500000, 0, 0, 0),
0170     REGULATOR_LINEAR_RANGE(1800000, 1, 3, 200000),
0171     REGULATOR_LINEAR_RANGE(2800000, 4, 5, 200000),
0172     REGULATOR_LINEAR_RANGE(3300000, 6, 7, 300000),
0173 };
0174 
0175 #define RK817_BUCK1_MIN0 500000
0176 #define RK817_BUCK1_MAX0 1500000
0177 
0178 #define RK817_BUCK1_MIN1 1600000
0179 #define RK817_BUCK1_MAX1 2400000
0180 
0181 #define RK817_BUCK3_MAX1 3400000
0182 
0183 #define RK817_BUCK1_STP0 12500
0184 #define RK817_BUCK1_STP1 100000
0185 
0186 #define RK817_BUCK1_SEL0 ((RK817_BUCK1_MAX0 - RK817_BUCK1_MIN0) /\
0187                           RK817_BUCK1_STP0)
0188 #define RK817_BUCK1_SEL1 ((RK817_BUCK1_MAX1 - RK817_BUCK1_MIN1) /\
0189                           RK817_BUCK1_STP1)
0190 
0191 #define RK817_BUCK3_SEL1 ((RK817_BUCK3_MAX1 - RK817_BUCK1_MIN1) /\
0192                           RK817_BUCK1_STP1)
0193 
0194 #define RK817_BUCK1_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK1_SEL1 + 1)
0195 #define RK817_BUCK3_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK3_SEL1 + 1)
0196 
0197 static const struct linear_range rk817_buck1_voltage_ranges[] = {
0198     REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
0199                    RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
0200     REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
0201                    RK817_BUCK1_SEL_CNT, RK817_BUCK1_STP1),
0202 };
0203 
0204 static const struct linear_range rk817_buck3_voltage_ranges[] = {
0205     REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
0206                    RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
0207     REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
0208                    RK817_BUCK3_SEL_CNT, RK817_BUCK1_STP1),
0209 };
0210 
0211 static const unsigned int rk808_buck1_2_ramp_table[] = {
0212     2000, 4000, 6000, 10000
0213 };
0214 
0215 /* RK817 RK809 */
0216 static const unsigned int rk817_buck1_4_ramp_table[] = {
0217     3000, 6300, 12500, 25000
0218 };
0219 
0220 static int rk808_buck1_2_get_voltage_sel_regmap(struct regulator_dev *rdev)
0221 {
0222     struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
0223     int id = rdev_get_id(rdev);
0224     struct gpio_desc *gpio = pdata->dvs_gpio[id];
0225     unsigned int val;
0226     int ret;
0227 
0228     if (!gpio || gpiod_get_value(gpio) == 0)
0229         return regulator_get_voltage_sel_regmap(rdev);
0230 
0231     ret = regmap_read(rdev->regmap,
0232               rdev->desc->vsel_reg + RK808_DVS_REG_OFFSET,
0233               &val);
0234     if (ret != 0)
0235         return ret;
0236 
0237     val &= rdev->desc->vsel_mask;
0238     val >>= ffs(rdev->desc->vsel_mask) - 1;
0239 
0240     return val;
0241 }
0242 
0243 static int rk808_buck1_2_i2c_set_voltage_sel(struct regulator_dev *rdev,
0244                          unsigned sel)
0245 {
0246     int ret, delta_sel;
0247     unsigned int old_sel, tmp, val, mask = rdev->desc->vsel_mask;
0248 
0249     ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
0250     if (ret != 0)
0251         return ret;
0252 
0253     tmp = val & ~mask;
0254     old_sel = val & mask;
0255     old_sel >>= ffs(mask) - 1;
0256     delta_sel = sel - old_sel;
0257 
0258     /*
0259      * If directly modify the register to change the voltage, we will face
0260      * the risk of overshoot. Put it into a multi-step, can effectively
0261      * avoid this problem, a step is 100mv here.
0262      */
0263     while (delta_sel > MAX_STEPS_ONE_TIME) {
0264         old_sel += MAX_STEPS_ONE_TIME;
0265         val = old_sel << (ffs(mask) - 1);
0266         val |= tmp;
0267 
0268         /*
0269          * i2c is 400kHz (2.5us per bit) and we must transmit _at least_
0270          * 3 bytes (24 bits) plus start and stop so 26 bits.  So we've
0271          * got more than 65 us between each voltage change and thus
0272          * won't ramp faster than ~1500 uV / us.
0273          */
0274         ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
0275         delta_sel = sel - old_sel;
0276     }
0277 
0278     sel <<= ffs(mask) - 1;
0279     val = tmp | sel;
0280     ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
0281 
0282     /*
0283      * When we change the voltage register directly, the ramp rate is about
0284      * 100000uv/us, wait 1us to make sure the target voltage to be stable,
0285      * so we needn't wait extra time after that.
0286      */
0287     udelay(1);
0288 
0289     return ret;
0290 }
0291 
0292 static int rk808_buck1_2_set_voltage_sel(struct regulator_dev *rdev,
0293                      unsigned sel)
0294 {
0295     struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
0296     int id = rdev_get_id(rdev);
0297     struct gpio_desc *gpio = pdata->dvs_gpio[id];
0298     unsigned int reg = rdev->desc->vsel_reg;
0299     unsigned old_sel;
0300     int ret, gpio_level;
0301 
0302     if (!gpio)
0303         return rk808_buck1_2_i2c_set_voltage_sel(rdev, sel);
0304 
0305     gpio_level = gpiod_get_value(gpio);
0306     if (gpio_level == 0) {
0307         reg += RK808_DVS_REG_OFFSET;
0308         ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &old_sel);
0309     } else {
0310         ret = regmap_read(rdev->regmap,
0311                   reg + RK808_DVS_REG_OFFSET,
0312                   &old_sel);
0313     }
0314 
0315     if (ret != 0)
0316         return ret;
0317 
0318     sel <<= ffs(rdev->desc->vsel_mask) - 1;
0319     sel |= old_sel & ~rdev->desc->vsel_mask;
0320 
0321     ret = regmap_write(rdev->regmap, reg, sel);
0322     if (ret)
0323         return ret;
0324 
0325     gpiod_set_value(gpio, !gpio_level);
0326 
0327     return ret;
0328 }
0329 
0330 static int rk808_buck1_2_set_voltage_time_sel(struct regulator_dev *rdev,
0331                        unsigned int old_selector,
0332                        unsigned int new_selector)
0333 {
0334     struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
0335     int id = rdev_get_id(rdev);
0336     struct gpio_desc *gpio = pdata->dvs_gpio[id];
0337 
0338     /* if there is no dvs1/2 pin, we don't need wait extra time here. */
0339     if (!gpio)
0340         return 0;
0341 
0342     return regulator_set_voltage_time_sel(rdev, old_selector, new_selector);
0343 }
0344 
0345 static int rk808_set_suspend_voltage(struct regulator_dev *rdev, int uv)
0346 {
0347     unsigned int reg;
0348     int sel = regulator_map_voltage_linear(rdev, uv, uv);
0349 
0350     if (sel < 0)
0351         return -EINVAL;
0352 
0353     reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
0354 
0355     return regmap_update_bits(rdev->regmap, reg,
0356                   rdev->desc->vsel_mask,
0357                   sel);
0358 }
0359 
0360 static int rk808_set_suspend_voltage_range(struct regulator_dev *rdev, int uv)
0361 {
0362     unsigned int reg;
0363     int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
0364 
0365     if (sel < 0)
0366         return -EINVAL;
0367 
0368     reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
0369 
0370     return regmap_update_bits(rdev->regmap, reg,
0371                   rdev->desc->vsel_mask,
0372                   sel);
0373 }
0374 
0375 static int rk805_set_suspend_enable(struct regulator_dev *rdev)
0376 {
0377     unsigned int reg;
0378 
0379     reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
0380 
0381     return regmap_update_bits(rdev->regmap, reg,
0382                   rdev->desc->enable_mask,
0383                   rdev->desc->enable_mask);
0384 }
0385 
0386 static int rk805_set_suspend_disable(struct regulator_dev *rdev)
0387 {
0388     unsigned int reg;
0389 
0390     reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
0391 
0392     return regmap_update_bits(rdev->regmap, reg,
0393                   rdev->desc->enable_mask,
0394                   0);
0395 }
0396 
0397 static int rk808_set_suspend_enable(struct regulator_dev *rdev)
0398 {
0399     unsigned int reg;
0400 
0401     reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
0402 
0403     return regmap_update_bits(rdev->regmap, reg,
0404                   rdev->desc->enable_mask,
0405                   0);
0406 }
0407 
0408 static int rk808_set_suspend_disable(struct regulator_dev *rdev)
0409 {
0410     unsigned int reg;
0411 
0412     reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
0413 
0414     return regmap_update_bits(rdev->regmap, reg,
0415                   rdev->desc->enable_mask,
0416                   rdev->desc->enable_mask);
0417 }
0418 
0419 static int rk817_set_suspend_enable_ctrl(struct regulator_dev *rdev,
0420                      unsigned int en)
0421 {
0422     unsigned int reg;
0423     int id = rdev_get_id(rdev);
0424     unsigned int id_slp, msk, val;
0425 
0426     if (id >= RK817_ID_DCDC1 && id <= RK817_ID_DCDC4)
0427         id_slp = id;
0428     else if (id >= RK817_ID_LDO1 && id <= RK817_ID_LDO8)
0429         id_slp = 8 + (id - RK817_ID_LDO1);
0430     else if (id >= RK817_ID_LDO9 && id <= RK809_ID_SW2)
0431         id_slp = 4 + (id - RK817_ID_LDO9);
0432     else
0433         return -EINVAL;
0434 
0435     reg = RK817_POWER_SLP_EN_REG(id_slp / 8);
0436 
0437     msk = BIT(id_slp % 8);
0438     if (en)
0439         val = msk;
0440     else
0441         val = 0;
0442 
0443     return regmap_update_bits(rdev->regmap, reg, msk, val);
0444 }
0445 
0446 static int rk817_set_suspend_enable(struct regulator_dev *rdev)
0447 {
0448     return rk817_set_suspend_enable_ctrl(rdev, 1);
0449 }
0450 
0451 static int rk817_set_suspend_disable(struct regulator_dev *rdev)
0452 {
0453     return rk817_set_suspend_enable_ctrl(rdev, 0);
0454 }
0455 
0456 static int rk8xx_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode)
0457 {
0458     unsigned int reg;
0459 
0460     reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
0461 
0462     switch (mode) {
0463     case REGULATOR_MODE_FAST:
0464         return regmap_update_bits(rdev->regmap, reg,
0465                       PWM_MODE_MSK, FPWM_MODE);
0466     case REGULATOR_MODE_NORMAL:
0467         return regmap_update_bits(rdev->regmap, reg,
0468                       PWM_MODE_MSK, AUTO_PWM_MODE);
0469     default:
0470         dev_err(&rdev->dev, "do not support this mode\n");
0471         return -EINVAL;
0472     }
0473 
0474     return 0;
0475 }
0476 
0477 static int rk8xx_set_mode(struct regulator_dev *rdev, unsigned int mode)
0478 {
0479     switch (mode) {
0480     case REGULATOR_MODE_FAST:
0481         return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
0482                       PWM_MODE_MSK, FPWM_MODE);
0483     case REGULATOR_MODE_NORMAL:
0484         return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
0485                       PWM_MODE_MSK, AUTO_PWM_MODE);
0486     default:
0487         dev_err(&rdev->dev, "do not support this mode\n");
0488         return -EINVAL;
0489     }
0490 
0491     return 0;
0492 }
0493 
0494 static unsigned int rk8xx_get_mode(struct regulator_dev *rdev)
0495 {
0496     unsigned int val;
0497     int err;
0498 
0499     err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
0500     if (err)
0501         return err;
0502 
0503     if (val & FPWM_MODE)
0504         return REGULATOR_MODE_FAST;
0505     else
0506         return REGULATOR_MODE_NORMAL;
0507 }
0508 
0509 static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev)
0510 {
0511     unsigned int val;
0512     int ret;
0513 
0514     ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
0515     if (ret != 0)
0516         return ret;
0517 
0518     /* add write mask bit */
0519     val |= (rdev->desc->enable_mask & 0xf0);
0520     val &= rdev->desc->enable_mask;
0521 
0522     if (rdev->desc->enable_is_inverted) {
0523         if (rdev->desc->enable_val)
0524             return val != rdev->desc->enable_val;
0525         return (val == 0);
0526     }
0527     if (rdev->desc->enable_val)
0528         return val == rdev->desc->enable_val;
0529     return val != 0;
0530 }
0531 
0532 static unsigned int rk8xx_regulator_of_map_mode(unsigned int mode)
0533 {
0534     switch (mode) {
0535     case 1:
0536         return REGULATOR_MODE_FAST;
0537     case 2:
0538         return REGULATOR_MODE_NORMAL;
0539     default:
0540         return REGULATOR_MODE_INVALID;
0541     }
0542 }
0543 
0544 static const struct regulator_ops rk805_reg_ops = {
0545     .list_voltage           = regulator_list_voltage_linear,
0546     .map_voltage            = regulator_map_voltage_linear,
0547     .get_voltage_sel        = regulator_get_voltage_sel_regmap,
0548     .set_voltage_sel        = regulator_set_voltage_sel_regmap,
0549     .enable                 = regulator_enable_regmap,
0550     .disable                = regulator_disable_regmap,
0551     .is_enabled             = regulator_is_enabled_regmap,
0552     .set_suspend_voltage    = rk808_set_suspend_voltage,
0553     .set_suspend_enable     = rk805_set_suspend_enable,
0554     .set_suspend_disable    = rk805_set_suspend_disable,
0555 };
0556 
0557 static const struct regulator_ops rk805_switch_ops = {
0558     .enable                 = regulator_enable_regmap,
0559     .disable                = regulator_disable_regmap,
0560     .is_enabled             = regulator_is_enabled_regmap,
0561     .set_suspend_enable     = rk805_set_suspend_enable,
0562     .set_suspend_disable    = rk805_set_suspend_disable,
0563 };
0564 
0565 static const struct regulator_ops rk808_buck1_2_ops = {
0566     .list_voltage       = regulator_list_voltage_linear,
0567     .map_voltage        = regulator_map_voltage_linear,
0568     .get_voltage_sel    = rk808_buck1_2_get_voltage_sel_regmap,
0569     .set_voltage_sel    = rk808_buck1_2_set_voltage_sel,
0570     .set_voltage_time_sel   = rk808_buck1_2_set_voltage_time_sel,
0571     .enable         = regulator_enable_regmap,
0572     .disable        = regulator_disable_regmap,
0573     .is_enabled     = regulator_is_enabled_regmap,
0574     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0575     .set_suspend_voltage    = rk808_set_suspend_voltage,
0576     .set_suspend_enable = rk808_set_suspend_enable,
0577     .set_suspend_disable    = rk808_set_suspend_disable,
0578 };
0579 
0580 static const struct regulator_ops rk808_reg_ops = {
0581     .list_voltage       = regulator_list_voltage_linear,
0582     .map_voltage        = regulator_map_voltage_linear,
0583     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0584     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0585     .enable         = regulator_enable_regmap,
0586     .disable        = regulator_disable_regmap,
0587     .is_enabled     = regulator_is_enabled_regmap,
0588     .set_suspend_voltage    = rk808_set_suspend_voltage,
0589     .set_suspend_enable = rk808_set_suspend_enable,
0590     .set_suspend_disable    = rk808_set_suspend_disable,
0591 };
0592 
0593 static const struct regulator_ops rk808_reg_ops_ranges = {
0594     .list_voltage       = regulator_list_voltage_linear_range,
0595     .map_voltage        = regulator_map_voltage_linear_range,
0596     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0597     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0598     .enable         = regulator_enable_regmap,
0599     .disable        = regulator_disable_regmap,
0600     .is_enabled     = regulator_is_enabled_regmap,
0601     .set_suspend_voltage    = rk808_set_suspend_voltage_range,
0602     .set_suspend_enable = rk808_set_suspend_enable,
0603     .set_suspend_disable    = rk808_set_suspend_disable,
0604 };
0605 
0606 static const struct regulator_ops rk808_switch_ops = {
0607     .enable         = regulator_enable_regmap,
0608     .disable        = regulator_disable_regmap,
0609     .is_enabled     = regulator_is_enabled_regmap,
0610     .set_suspend_enable = rk808_set_suspend_enable,
0611     .set_suspend_disable    = rk808_set_suspend_disable,
0612 };
0613 
0614 static const struct linear_range rk805_buck_1_2_voltage_ranges[] = {
0615     REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500),
0616     REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000),
0617     REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0),
0618 };
0619 
0620 static const struct regulator_ops rk809_buck5_ops_range = {
0621     .list_voltage       = regulator_list_voltage_linear_range,
0622     .map_voltage        = regulator_map_voltage_linear_range,
0623     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0624     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0625     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0626     .enable         = regulator_enable_regmap,
0627     .disable        = regulator_disable_regmap,
0628     .is_enabled     = rk8xx_is_enabled_wmsk_regmap,
0629     .set_suspend_voltage    = rk808_set_suspend_voltage_range,
0630     .set_suspend_enable = rk817_set_suspend_enable,
0631     .set_suspend_disable    = rk817_set_suspend_disable,
0632 };
0633 
0634 static const struct regulator_ops rk817_reg_ops = {
0635     .list_voltage       = regulator_list_voltage_linear,
0636     .map_voltage        = regulator_map_voltage_linear,
0637     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0638     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0639     .enable         = regulator_enable_regmap,
0640     .disable        = regulator_disable_regmap,
0641     .is_enabled     = rk8xx_is_enabled_wmsk_regmap,
0642     .set_suspend_voltage    = rk808_set_suspend_voltage,
0643     .set_suspend_enable = rk817_set_suspend_enable,
0644     .set_suspend_disable    = rk817_set_suspend_disable,
0645 };
0646 
0647 static const struct regulator_ops rk817_boost_ops = {
0648     .list_voltage       = regulator_list_voltage_linear,
0649     .map_voltage        = regulator_map_voltage_linear,
0650     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0651     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0652     .enable         = regulator_enable_regmap,
0653     .disable        = regulator_disable_regmap,
0654     .is_enabled     = rk8xx_is_enabled_wmsk_regmap,
0655     .set_suspend_enable = rk817_set_suspend_enable,
0656     .set_suspend_disable    = rk817_set_suspend_disable,
0657 };
0658 
0659 static const struct regulator_ops rk817_buck_ops_range = {
0660     .list_voltage       = regulator_list_voltage_linear_range,
0661     .map_voltage        = regulator_map_voltage_linear_range,
0662     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0663     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0664     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0665     .enable         = regulator_enable_regmap,
0666     .disable        = regulator_disable_regmap,
0667     .is_enabled     = rk8xx_is_enabled_wmsk_regmap,
0668     .set_mode       = rk8xx_set_mode,
0669     .get_mode       = rk8xx_get_mode,
0670     .set_suspend_mode   = rk8xx_set_suspend_mode,
0671     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0672     .set_suspend_voltage    = rk808_set_suspend_voltage_range,
0673     .set_suspend_enable = rk817_set_suspend_enable,
0674     .set_suspend_disable    = rk817_set_suspend_disable,
0675 };
0676 
0677 static const struct regulator_ops rk817_switch_ops = {
0678     .enable         = regulator_enable_regmap,
0679     .disable        = regulator_disable_regmap,
0680     .is_enabled     = rk8xx_is_enabled_wmsk_regmap,
0681     .set_suspend_enable = rk817_set_suspend_enable,
0682     .set_suspend_disable    = rk817_set_suspend_disable,
0683 };
0684 
0685 static const struct regulator_desc rk805_reg[] = {
0686     {
0687         .name = "DCDC_REG1",
0688         .supply_name = "vcc1",
0689         .of_match = of_match_ptr("DCDC_REG1"),
0690         .regulators_node = of_match_ptr("regulators"),
0691         .id = RK805_ID_DCDC1,
0692         .ops = &rk808_reg_ops_ranges,
0693         .type = REGULATOR_VOLTAGE,
0694         .n_voltages = 64,
0695         .linear_ranges = rk805_buck_1_2_voltage_ranges,
0696         .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
0697         .vsel_reg = RK805_BUCK1_ON_VSEL_REG,
0698         .vsel_mask = RK818_BUCK_VSEL_MASK,
0699         .enable_reg = RK805_DCDC_EN_REG,
0700         .enable_mask = BIT(0),
0701         .owner = THIS_MODULE,
0702     }, {
0703         .name = "DCDC_REG2",
0704         .supply_name = "vcc2",
0705         .of_match = of_match_ptr("DCDC_REG2"),
0706         .regulators_node = of_match_ptr("regulators"),
0707         .id = RK805_ID_DCDC2,
0708         .ops = &rk808_reg_ops_ranges,
0709         .type = REGULATOR_VOLTAGE,
0710         .n_voltages = 64,
0711         .linear_ranges = rk805_buck_1_2_voltage_ranges,
0712         .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
0713         .vsel_reg = RK805_BUCK2_ON_VSEL_REG,
0714         .vsel_mask = RK818_BUCK_VSEL_MASK,
0715         .enable_reg = RK805_DCDC_EN_REG,
0716         .enable_mask = BIT(1),
0717         .owner = THIS_MODULE,
0718     }, {
0719         .name = "DCDC_REG3",
0720         .supply_name = "vcc3",
0721         .of_match = of_match_ptr("DCDC_REG3"),
0722         .regulators_node = of_match_ptr("regulators"),
0723         .id = RK805_ID_DCDC3,
0724         .ops = &rk805_switch_ops,
0725         .type = REGULATOR_VOLTAGE,
0726         .n_voltages = 1,
0727         .enable_reg = RK805_DCDC_EN_REG,
0728         .enable_mask = BIT(2),
0729         .owner = THIS_MODULE,
0730     },
0731 
0732     RK805_DESC(RK805_ID_DCDC4, "DCDC_REG4", "vcc4", 800, 3400, 100,
0733         RK805_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
0734         RK805_DCDC_EN_REG, BIT(3), 0),
0735 
0736     RK805_DESC(RK805_ID_LDO1, "LDO_REG1", "vcc5", 800, 3400, 100,
0737         RK805_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
0738         BIT(0), 400),
0739     RK805_DESC(RK805_ID_LDO2, "LDO_REG2", "vcc5", 800, 3400, 100,
0740         RK805_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
0741         BIT(1), 400),
0742     RK805_DESC(RK805_ID_LDO3, "LDO_REG3", "vcc6", 800, 3400, 100,
0743         RK805_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
0744         BIT(2), 400),
0745 };
0746 
0747 static const struct regulator_desc rk808_reg[] = {
0748     {
0749         .name = "DCDC_REG1",
0750         .supply_name = "vcc1",
0751         .of_match = of_match_ptr("DCDC_REG1"),
0752         .regulators_node = of_match_ptr("regulators"),
0753         .id = RK808_ID_DCDC1,
0754         .ops = &rk808_buck1_2_ops,
0755         .type = REGULATOR_VOLTAGE,
0756         .min_uV = 712500,
0757         .uV_step = 12500,
0758         .n_voltages = 64,
0759         .vsel_reg = RK808_BUCK1_ON_VSEL_REG,
0760         .vsel_mask = RK808_BUCK_VSEL_MASK,
0761         .enable_reg = RK808_DCDC_EN_REG,
0762         .enable_mask = BIT(0),
0763         .ramp_reg = RK808_BUCK1_CONFIG_REG,
0764         .ramp_mask = RK808_RAMP_RATE_MASK,
0765         .ramp_delay_table = rk808_buck1_2_ramp_table,
0766         .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table),
0767         .owner = THIS_MODULE,
0768     }, {
0769         .name = "DCDC_REG2",
0770         .supply_name = "vcc2",
0771         .of_match = of_match_ptr("DCDC_REG2"),
0772         .regulators_node = of_match_ptr("regulators"),
0773         .id = RK808_ID_DCDC2,
0774         .ops = &rk808_buck1_2_ops,
0775         .type = REGULATOR_VOLTAGE,
0776         .min_uV = 712500,
0777         .uV_step = 12500,
0778         .n_voltages = 64,
0779         .vsel_reg = RK808_BUCK2_ON_VSEL_REG,
0780         .vsel_mask = RK808_BUCK_VSEL_MASK,
0781         .enable_reg = RK808_DCDC_EN_REG,
0782         .enable_mask = BIT(1),
0783         .ramp_reg = RK808_BUCK2_CONFIG_REG,
0784         .ramp_mask = RK808_RAMP_RATE_MASK,
0785         .ramp_delay_table = rk808_buck1_2_ramp_table,
0786         .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table),
0787         .owner = THIS_MODULE,
0788     }, {
0789         .name = "DCDC_REG3",
0790         .supply_name = "vcc3",
0791         .of_match = of_match_ptr("DCDC_REG3"),
0792         .regulators_node = of_match_ptr("regulators"),
0793         .id = RK808_ID_DCDC3,
0794         .ops = &rk808_switch_ops,
0795         .type = REGULATOR_VOLTAGE,
0796         .n_voltages = 1,
0797         .enable_reg = RK808_DCDC_EN_REG,
0798         .enable_mask = BIT(2),
0799         .owner = THIS_MODULE,
0800     },
0801     RK8XX_DESC(RK808_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3300, 100,
0802         RK808_BUCK4_ON_VSEL_REG, RK808_BUCK4_VSEL_MASK,
0803         RK808_DCDC_EN_REG, BIT(3), 0),
0804     RK8XX_DESC(RK808_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
0805         RK808_LDO1_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0806         BIT(0), 400),
0807     RK8XX_DESC(RK808_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
0808         RK808_LDO2_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0809         BIT(1), 400),
0810     {
0811         .name = "LDO_REG3",
0812         .supply_name = "vcc7",
0813         .of_match = of_match_ptr("LDO_REG3"),
0814         .regulators_node = of_match_ptr("regulators"),
0815         .id = RK808_ID_LDO3,
0816         .ops = &rk808_reg_ops_ranges,
0817         .type = REGULATOR_VOLTAGE,
0818         .n_voltages = 16,
0819         .linear_ranges = rk808_ldo3_voltage_ranges,
0820         .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
0821         .vsel_reg = RK808_LDO3_ON_VSEL_REG,
0822         .vsel_mask = RK808_BUCK4_VSEL_MASK,
0823         .enable_reg = RK808_LDO_EN_REG,
0824         .enable_mask = BIT(2),
0825         .enable_time = 400,
0826         .owner = THIS_MODULE,
0827     },
0828     RK8XX_DESC(RK808_ID_LDO4, "LDO_REG4", "vcc9", 1800, 3400, 100,
0829         RK808_LDO4_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0830         BIT(3), 400),
0831     RK8XX_DESC(RK808_ID_LDO5, "LDO_REG5", "vcc9", 1800, 3400, 100,
0832         RK808_LDO5_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0833         BIT(4), 400),
0834     RK8XX_DESC(RK808_ID_LDO6, "LDO_REG6", "vcc10", 800, 2500, 100,
0835         RK808_LDO6_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0836         BIT(5), 400),
0837     RK8XX_DESC(RK808_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
0838         RK808_LDO7_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0839         BIT(6), 400),
0840     RK8XX_DESC(RK808_ID_LDO8, "LDO_REG8", "vcc11", 1800, 3400, 100,
0841         RK808_LDO8_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
0842         BIT(7), 400),
0843     RK8XX_DESC_SWITCH(RK808_ID_SWITCH1, "SWITCH_REG1", "vcc8",
0844         RK808_DCDC_EN_REG, BIT(5)),
0845     RK8XX_DESC_SWITCH(RK808_ID_SWITCH2, "SWITCH_REG2", "vcc12",
0846         RK808_DCDC_EN_REG, BIT(6)),
0847 };
0848 
0849 static const struct regulator_desc rk809_reg[] = {
0850     {
0851         .name = "DCDC_REG1",
0852         .supply_name = "vcc1",
0853         .of_match = of_match_ptr("DCDC_REG1"),
0854         .regulators_node = of_match_ptr("regulators"),
0855         .id = RK817_ID_DCDC1,
0856         .ops = &rk817_buck_ops_range,
0857         .type = REGULATOR_VOLTAGE,
0858         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
0859         .linear_ranges = rk817_buck1_voltage_ranges,
0860         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
0861         .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
0862         .vsel_mask = RK817_BUCK_VSEL_MASK,
0863         .enable_reg = RK817_POWER_EN_REG(0),
0864         .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
0865         .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
0866         .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
0867         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1),
0868         .ramp_mask = RK817_RAMP_RATE_MASK,
0869         .ramp_delay_table = rk817_buck1_4_ramp_table,
0870         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
0871         .of_map_mode = rk8xx_regulator_of_map_mode,
0872         .owner = THIS_MODULE,
0873     }, {
0874         .name = "DCDC_REG2",
0875         .supply_name = "vcc2",
0876         .of_match = of_match_ptr("DCDC_REG2"),
0877         .regulators_node = of_match_ptr("regulators"),
0878         .id = RK817_ID_DCDC2,
0879         .ops = &rk817_buck_ops_range,
0880         .type = REGULATOR_VOLTAGE,
0881         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
0882         .linear_ranges = rk817_buck1_voltage_ranges,
0883         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
0884         .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
0885         .vsel_mask = RK817_BUCK_VSEL_MASK,
0886         .enable_reg = RK817_POWER_EN_REG(0),
0887         .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
0888         .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
0889         .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
0890         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2),
0891         .ramp_mask = RK817_RAMP_RATE_MASK,
0892         .ramp_delay_table = rk817_buck1_4_ramp_table,
0893         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
0894         .of_map_mode = rk8xx_regulator_of_map_mode,
0895         .owner = THIS_MODULE,
0896     }, {
0897         .name = "DCDC_REG3",
0898         .supply_name = "vcc3",
0899         .of_match = of_match_ptr("DCDC_REG3"),
0900         .regulators_node = of_match_ptr("regulators"),
0901         .id = RK817_ID_DCDC3,
0902         .ops = &rk817_buck_ops_range,
0903         .type = REGULATOR_VOLTAGE,
0904         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
0905         .linear_ranges = rk817_buck1_voltage_ranges,
0906         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
0907         .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
0908         .vsel_mask = RK817_BUCK_VSEL_MASK,
0909         .enable_reg = RK817_POWER_EN_REG(0),
0910         .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
0911         .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
0912         .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
0913         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3),
0914         .ramp_mask = RK817_RAMP_RATE_MASK,
0915         .ramp_delay_table = rk817_buck1_4_ramp_table,
0916         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
0917         .of_map_mode = rk8xx_regulator_of_map_mode,
0918         .owner = THIS_MODULE,
0919     }, {
0920         .name = "DCDC_REG4",
0921         .supply_name = "vcc4",
0922         .of_match = of_match_ptr("DCDC_REG4"),
0923         .regulators_node = of_match_ptr("regulators"),
0924         .id = RK817_ID_DCDC4,
0925         .ops = &rk817_buck_ops_range,
0926         .type = REGULATOR_VOLTAGE,
0927         .n_voltages = RK817_BUCK3_SEL_CNT + 1,
0928         .linear_ranges = rk817_buck3_voltage_ranges,
0929         .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
0930         .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
0931         .vsel_mask = RK817_BUCK_VSEL_MASK,
0932         .enable_reg = RK817_POWER_EN_REG(0),
0933         .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
0934         .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
0935         .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
0936         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4),
0937         .ramp_mask = RK817_RAMP_RATE_MASK,
0938         .ramp_delay_table = rk817_buck1_4_ramp_table,
0939         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
0940         .of_map_mode = rk8xx_regulator_of_map_mode,
0941         .owner = THIS_MODULE,
0942     },
0943     {
0944         .name = "DCDC_REG5",
0945         .supply_name = "vcc9",
0946         .of_match = of_match_ptr("DCDC_REG5"),
0947         .regulators_node = of_match_ptr("regulators"),
0948         .id = RK809_ID_DCDC5,
0949         .ops = &rk809_buck5_ops_range,
0950         .type = REGULATOR_VOLTAGE,
0951         .n_voltages = RK809_BUCK5_SEL_CNT,
0952         .linear_ranges = rk809_buck5_voltage_ranges,
0953         .n_linear_ranges = ARRAY_SIZE(rk809_buck5_voltage_ranges),
0954         .vsel_reg = RK809_BUCK5_CONFIG(0),
0955         .vsel_mask = RK809_BUCK5_VSEL_MASK,
0956         .enable_reg = RK817_POWER_EN_REG(3),
0957         .enable_mask = ENABLE_MASK(1),
0958         .enable_val = ENABLE_MASK(1),
0959         .disable_val = DISABLE_VAL(1),
0960         .of_map_mode = rk8xx_regulator_of_map_mode,
0961         .owner = THIS_MODULE,
0962     },
0963     RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
0964            RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
0965            RK817_POWER_EN_REG(1), ENABLE_MASK(0),
0966            DISABLE_VAL(0), 400),
0967     RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
0968            RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
0969            RK817_POWER_EN_REG(1), ENABLE_MASK(1),
0970            DISABLE_VAL(1), 400),
0971     RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
0972            RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
0973            RK817_POWER_EN_REG(1), ENABLE_MASK(2),
0974            DISABLE_VAL(2), 400),
0975     RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
0976            RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
0977            RK817_POWER_EN_REG(1), ENABLE_MASK(3),
0978            DISABLE_VAL(3), 400),
0979     RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
0980            RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
0981            RK817_POWER_EN_REG(2), ENABLE_MASK(0),
0982            DISABLE_VAL(0), 400),
0983     RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
0984            RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
0985            RK817_POWER_EN_REG(2), ENABLE_MASK(1),
0986            DISABLE_VAL(1), 400),
0987     RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
0988            RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
0989            RK817_POWER_EN_REG(2), ENABLE_MASK(2),
0990            DISABLE_VAL(2), 400),
0991     RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
0992            RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
0993            RK817_POWER_EN_REG(2), ENABLE_MASK(3),
0994            DISABLE_VAL(3), 400),
0995     RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
0996            RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
0997            RK817_POWER_EN_REG(3), ENABLE_MASK(0),
0998            DISABLE_VAL(0), 400),
0999     RK817_DESC_SWITCH(RK809_ID_SW1, "SWITCH_REG1", "vcc9",
1000               RK817_POWER_EN_REG(3), ENABLE_MASK(2),
1001               DISABLE_VAL(2)),
1002     RK817_DESC_SWITCH(RK809_ID_SW2, "SWITCH_REG2", "vcc8",
1003               RK817_POWER_EN_REG(3), ENABLE_MASK(3),
1004               DISABLE_VAL(3)),
1005 };
1006 
1007 static const struct regulator_desc rk817_reg[] = {
1008     {
1009         .name = "DCDC_REG1",
1010         .supply_name = "vcc1",
1011         .of_match = of_match_ptr("DCDC_REG1"),
1012         .regulators_node = of_match_ptr("regulators"),
1013         .id = RK817_ID_DCDC1,
1014         .ops = &rk817_buck_ops_range,
1015         .type = REGULATOR_VOLTAGE,
1016         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1017         .linear_ranges = rk817_buck1_voltage_ranges,
1018         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1019         .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
1020         .vsel_mask = RK817_BUCK_VSEL_MASK,
1021         .enable_reg = RK817_POWER_EN_REG(0),
1022         .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
1023         .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
1024         .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
1025         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1),
1026         .ramp_mask = RK817_RAMP_RATE_MASK,
1027         .ramp_delay_table = rk817_buck1_4_ramp_table,
1028         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1029         .of_map_mode = rk8xx_regulator_of_map_mode,
1030         .owner = THIS_MODULE,
1031     }, {
1032         .name = "DCDC_REG2",
1033         .supply_name = "vcc2",
1034         .of_match = of_match_ptr("DCDC_REG2"),
1035         .regulators_node = of_match_ptr("regulators"),
1036         .id = RK817_ID_DCDC2,
1037         .ops = &rk817_buck_ops_range,
1038         .type = REGULATOR_VOLTAGE,
1039         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1040         .linear_ranges = rk817_buck1_voltage_ranges,
1041         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1042         .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
1043         .vsel_mask = RK817_BUCK_VSEL_MASK,
1044         .enable_reg = RK817_POWER_EN_REG(0),
1045         .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
1046         .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
1047         .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
1048         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2),
1049         .ramp_mask = RK817_RAMP_RATE_MASK,
1050         .ramp_delay_table = rk817_buck1_4_ramp_table,
1051         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1052         .of_map_mode = rk8xx_regulator_of_map_mode,
1053         .owner = THIS_MODULE,
1054     }, {
1055         .name = "DCDC_REG3",
1056         .supply_name = "vcc3",
1057         .of_match = of_match_ptr("DCDC_REG3"),
1058         .regulators_node = of_match_ptr("regulators"),
1059         .id = RK817_ID_DCDC3,
1060         .ops = &rk817_buck_ops_range,
1061         .type = REGULATOR_VOLTAGE,
1062         .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1063         .linear_ranges = rk817_buck1_voltage_ranges,
1064         .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1065         .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
1066         .vsel_mask = RK817_BUCK_VSEL_MASK,
1067         .enable_reg = RK817_POWER_EN_REG(0),
1068         .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
1069         .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
1070         .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
1071         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3),
1072         .ramp_mask = RK817_RAMP_RATE_MASK,
1073         .ramp_delay_table = rk817_buck1_4_ramp_table,
1074         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1075         .of_map_mode = rk8xx_regulator_of_map_mode,
1076         .owner = THIS_MODULE,
1077     }, {
1078         .name = "DCDC_REG4",
1079         .supply_name = "vcc4",
1080         .of_match = of_match_ptr("DCDC_REG4"),
1081         .regulators_node = of_match_ptr("regulators"),
1082         .id = RK817_ID_DCDC4,
1083         .ops = &rk817_buck_ops_range,
1084         .type = REGULATOR_VOLTAGE,
1085         .n_voltages = RK817_BUCK3_SEL_CNT + 1,
1086         .linear_ranges = rk817_buck3_voltage_ranges,
1087         .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
1088         .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
1089         .vsel_mask = RK817_BUCK_VSEL_MASK,
1090         .enable_reg = RK817_POWER_EN_REG(0),
1091         .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
1092         .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
1093         .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
1094         .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4),
1095         .ramp_mask = RK817_RAMP_RATE_MASK,
1096         .ramp_delay_table = rk817_buck1_4_ramp_table,
1097         .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1098         .of_map_mode = rk8xx_regulator_of_map_mode,
1099         .owner = THIS_MODULE,
1100     },
1101     RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
1102            RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
1103            RK817_POWER_EN_REG(1), ENABLE_MASK(0),
1104            DISABLE_VAL(0), 400),
1105     RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
1106            RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
1107            RK817_POWER_EN_REG(1), ENABLE_MASK(1),
1108            DISABLE_VAL(1), 400),
1109     RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
1110            RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
1111            RK817_POWER_EN_REG(1), ENABLE_MASK(2),
1112            DISABLE_VAL(2), 400),
1113     RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
1114            RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
1115            RK817_POWER_EN_REG(1), ENABLE_MASK(3),
1116            DISABLE_VAL(3), 400),
1117     RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
1118            RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
1119            RK817_POWER_EN_REG(2), ENABLE_MASK(0),
1120            DISABLE_VAL(0), 400),
1121     RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
1122            RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
1123            RK817_POWER_EN_REG(2), ENABLE_MASK(1),
1124            DISABLE_VAL(1), 400),
1125     RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
1126            RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
1127            RK817_POWER_EN_REG(2), ENABLE_MASK(2),
1128            DISABLE_VAL(2), 400),
1129     RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
1130            RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
1131            RK817_POWER_EN_REG(2), ENABLE_MASK(3),
1132            DISABLE_VAL(3), 400),
1133     RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
1134            RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
1135            RK817_POWER_EN_REG(3), ENABLE_MASK(0),
1136            DISABLE_VAL(0), 400),
1137     RK817_BOOST_DESC(RK817_ID_BOOST, "BOOST", "vcc8", 4700, 5400, 100,
1138              RK817_BOOST_OTG_CFG, RK817_BOOST_VSEL_MASK,
1139              RK817_POWER_EN_REG(3), ENABLE_MASK(1), ENABLE_MASK(1),
1140            DISABLE_VAL(1), 400, 3500 - 5400),
1141     RK817_DESC_SWITCH(RK817_ID_BOOST_OTG_SW, "OTG_SWITCH", "vcc9",
1142               RK817_POWER_EN_REG(3), ENABLE_MASK(2),
1143               DISABLE_VAL(2)),
1144 };
1145 
1146 static const struct regulator_desc rk818_reg[] = {
1147     {
1148         .name = "DCDC_REG1",
1149         .supply_name = "vcc1",
1150         .of_match = of_match_ptr("DCDC_REG1"),
1151         .regulators_node = of_match_ptr("regulators"),
1152         .id = RK818_ID_DCDC1,
1153         .ops = &rk808_reg_ops,
1154         .type = REGULATOR_VOLTAGE,
1155         .min_uV = 712500,
1156         .uV_step = 12500,
1157         .n_voltages = 64,
1158         .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
1159         .vsel_mask = RK818_BUCK_VSEL_MASK,
1160         .enable_reg = RK818_DCDC_EN_REG,
1161         .enable_mask = BIT(0),
1162         .owner = THIS_MODULE,
1163     }, {
1164         .name = "DCDC_REG2",
1165         .supply_name = "vcc2",
1166         .of_match = of_match_ptr("DCDC_REG2"),
1167         .regulators_node = of_match_ptr("regulators"),
1168         .id = RK818_ID_DCDC2,
1169         .ops = &rk808_reg_ops,
1170         .type = REGULATOR_VOLTAGE,
1171         .min_uV = 712500,
1172         .uV_step = 12500,
1173         .n_voltages = 64,
1174         .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
1175         .vsel_mask = RK818_BUCK_VSEL_MASK,
1176         .enable_reg = RK818_DCDC_EN_REG,
1177         .enable_mask = BIT(1),
1178         .owner = THIS_MODULE,
1179     }, {
1180         .name = "DCDC_REG3",
1181         .supply_name = "vcc3",
1182         .of_match = of_match_ptr("DCDC_REG3"),
1183         .regulators_node = of_match_ptr("regulators"),
1184         .id = RK818_ID_DCDC3,
1185         .ops = &rk808_switch_ops,
1186         .type = REGULATOR_VOLTAGE,
1187         .n_voltages = 1,
1188         .enable_reg = RK818_DCDC_EN_REG,
1189         .enable_mask = BIT(2),
1190         .owner = THIS_MODULE,
1191     },
1192     RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100,
1193         RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
1194         RK818_DCDC_EN_REG, BIT(3), 0),
1195     RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100,
1196         RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK,
1197         RK818_DCDC_EN_REG, BIT(4), 0),
1198     RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
1199         RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1200         BIT(0), 400),
1201     RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
1202         RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1203         BIT(1), 400),
1204     {
1205         .name = "LDO_REG3",
1206         .supply_name = "vcc7",
1207         .of_match = of_match_ptr("LDO_REG3"),
1208         .regulators_node = of_match_ptr("regulators"),
1209         .id = RK818_ID_LDO3,
1210         .ops = &rk808_reg_ops_ranges,
1211         .type = REGULATOR_VOLTAGE,
1212         .n_voltages = 16,
1213         .linear_ranges = rk808_ldo3_voltage_ranges,
1214         .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
1215         .vsel_reg = RK818_LDO3_ON_VSEL_REG,
1216         .vsel_mask = RK818_LDO3_ON_VSEL_MASK,
1217         .enable_reg = RK818_LDO_EN_REG,
1218         .enable_mask = BIT(2),
1219         .enable_time = 400,
1220         .owner = THIS_MODULE,
1221     },
1222     RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100,
1223         RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1224         BIT(3), 400),
1225     RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100,
1226         RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1227         BIT(4), 400),
1228     RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100,
1229         RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1230         BIT(5), 400),
1231     RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
1232         RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1233         BIT(6), 400),
1234     RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100,
1235         RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
1236         BIT(7), 400),
1237     RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100,
1238         RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1239         RK818_DCDC_EN_REG, BIT(5), 400),
1240     RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9",
1241         RK818_DCDC_EN_REG, BIT(6)),
1242     RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v",
1243         RK818_H5V_EN_REG, BIT(0)),
1244     RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb",
1245         RK818_DCDC_EN_REG, BIT(7)),
1246 };
1247 
1248 static int rk808_regulator_dt_parse_pdata(struct device *dev,
1249                    struct device *client_dev,
1250                    struct regmap *map,
1251                    struct rk808_regulator_data *pdata)
1252 {
1253     struct device_node *np;
1254     int tmp, ret = 0, i;
1255 
1256     np = of_get_child_by_name(client_dev->of_node, "regulators");
1257     if (!np)
1258         return -ENXIO;
1259 
1260     for (i = 0; i < ARRAY_SIZE(pdata->dvs_gpio); i++) {
1261         pdata->dvs_gpio[i] =
1262             devm_gpiod_get_index_optional(client_dev, "dvs", i,
1263                               GPIOD_OUT_LOW);
1264         if (IS_ERR(pdata->dvs_gpio[i])) {
1265             ret = PTR_ERR(pdata->dvs_gpio[i]);
1266             dev_err(dev, "failed to get dvs%d gpio (%d)\n", i, ret);
1267             goto dt_parse_end;
1268         }
1269 
1270         if (!pdata->dvs_gpio[i]) {
1271             dev_info(dev, "there is no dvs%d gpio\n", i);
1272             continue;
1273         }
1274 
1275         tmp = i ? RK808_DVS2_POL : RK808_DVS1_POL;
1276         ret = regmap_update_bits(map, RK808_IO_POL_REG, tmp,
1277                 gpiod_is_active_low(pdata->dvs_gpio[i]) ?
1278                 0 : tmp);
1279     }
1280 
1281 dt_parse_end:
1282     of_node_put(np);
1283     return ret;
1284 }
1285 
1286 static int rk808_regulator_probe(struct platform_device *pdev)
1287 {
1288     struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
1289     struct i2c_client *client = rk808->i2c;
1290     struct regulator_config config = {};
1291     struct regulator_dev *rk808_rdev;
1292     struct rk808_regulator_data *pdata;
1293     const struct regulator_desc *regulators;
1294     int ret, i, nregulators;
1295 
1296     pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1297     if (!pdata)
1298         return -ENOMEM;
1299 
1300     ret = rk808_regulator_dt_parse_pdata(&pdev->dev, &client->dev,
1301                          rk808->regmap, pdata);
1302     if (ret < 0)
1303         return ret;
1304 
1305     platform_set_drvdata(pdev, pdata);
1306 
1307     switch (rk808->variant) {
1308     case RK805_ID:
1309         regulators = rk805_reg;
1310         nregulators = RK805_NUM_REGULATORS;
1311         break;
1312     case RK808_ID:
1313         regulators = rk808_reg;
1314         nregulators = RK808_NUM_REGULATORS;
1315         break;
1316     case RK809_ID:
1317         regulators = rk809_reg;
1318         nregulators = RK809_NUM_REGULATORS;
1319         break;
1320     case RK817_ID:
1321         regulators = rk817_reg;
1322         nregulators = RK817_NUM_REGULATORS;
1323         break;
1324     case RK818_ID:
1325         regulators = rk818_reg;
1326         nregulators = RK818_NUM_REGULATORS;
1327         break;
1328     default:
1329         dev_err(&client->dev, "unsupported RK8XX ID %lu\n",
1330             rk808->variant);
1331         return -EINVAL;
1332     }
1333 
1334     config.dev = &client->dev;
1335     config.driver_data = pdata;
1336     config.regmap = rk808->regmap;
1337 
1338     /* Instantiate the regulators */
1339     for (i = 0; i < nregulators; i++) {
1340         rk808_rdev = devm_regulator_register(&pdev->dev,
1341                              &regulators[i], &config);
1342         if (IS_ERR(rk808_rdev)) {
1343             dev_err(&client->dev,
1344                 "failed to register %d regulator\n", i);
1345             return PTR_ERR(rk808_rdev);
1346         }
1347     }
1348 
1349     return 0;
1350 }
1351 
1352 static struct platform_driver rk808_regulator_driver = {
1353     .probe = rk808_regulator_probe,
1354     .driver = {
1355         .name = "rk808-regulator"
1356     },
1357 };
1358 
1359 module_platform_driver(rk808_regulator_driver);
1360 
1361 MODULE_DESCRIPTION("regulator driver for the RK805/RK808/RK818 series PMICs");
1362 MODULE_AUTHOR("Tony xie <tony.xie@rock-chips.com>");
1363 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
1364 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
1365 MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
1366 MODULE_LICENSE("GPL");
1367 MODULE_ALIAS("platform:rk808-regulator");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!