1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/delay.h> 4 #include <linux/gpio/consumer.h> 5 #include <linux/i2c.h> 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/property.h> 9 #include <linux/regmap.h> 10 #include <linux/regulator/driver.h> 11 #include <linux/regulator/of_regulator.h> 12 13 #define RT6160_MODE_AUTO 0 14 #define RT6160_MODE_FPWM 1 15 16 #define RT6160_REG_CNTL 0x01 17 #define RT6160_REG_STATUS 0x02 18 #define RT6160_REG_DEVID 0x03 19 #define RT6160_REG_VSELL 0x04 20 #define RT6160_REG_VSELH 0x05 21 #define RT6160_NUM_REGS (RT6160_REG_VSELH + 1) 22 23 #define RT6160_FPWM_MASK BIT(3) 24 #define RT6160_RAMPRATE_MASK GENMASK(1, 0) 25 #define RT6160_VID_MASK GENMASK(7, 4) 26 #define RT6160_VSEL_MASK GENMASK(6, 0) 27 #define RT6160_HDSTAT_MASK BIT(4) 28 #define RT6160_UVSTAT_MASK BIT(3) 29 #define RT6160_OCSTAT_MASK BIT(2) 30 #define RT6160_TSDSTAT_MASK BIT(1) 31 #define RT6160_PGSTAT_MASK BIT(0) 32 33 #define RT6160_VENDOR_ID 0xA0 34 #define RT6160_VOUT_MINUV 2025000 35 #define RT6160_VOUT_MAXUV 5200000 36 #define RT6160_VOUT_STPUV 25000 37 #define RT6160_N_VOUTS ((RT6160_VOUT_MAXUV - RT6160_VOUT_MINUV) / RT6160_VOUT_STPUV + 1) 38 39 #define RT6160_I2CRDY_TIMEUS 100 40 41 struct rt6160_priv { 42 struct regulator_desc desc; 43 struct gpio_desc *enable_gpio; 44 struct regmap *regmap; 45 bool enable_state; 46 }; 47 48 static const unsigned int rt6160_ramp_tables[] = { 49 1000, 2500, 5000, 10000 50 }; 51 52 static int rt6160_enable(struct regulator_dev *rdev) 53 { 54 struct rt6160_priv *priv = rdev_get_drvdata(rdev); 55 56 if (!priv->enable_gpio) 57 return 0; 58 59 gpiod_set_value_cansleep(priv->enable_gpio, 1); 60 priv->enable_state = true; 61 62 usleep_range(RT6160_I2CRDY_TIMEUS, RT6160_I2CRDY_TIMEUS + 100); 63 64 regcache_cache_only(priv->regmap, false); 65 return regcache_sync(priv->regmap); 66 } 67 68 static int rt6160_disable(struct regulator_dev *rdev) 69 { 70 struct rt6160_priv *priv = rdev_get_drvdata(rdev); 71 72 if (!priv->enable_gpio) 73 return -EINVAL; 74 75 /* Mark regcache as dirty and cache only before HW disabled */ 76 regcache_cache_only(priv->regmap, true); 77 regcache_mark_dirty(priv->regmap); 78 79 priv->enable_state = false; 80 gpiod_set_value_cansleep(priv->enable_gpio, 0); 81 82 return 0; 83 } 84 85 static int rt6160_is_enabled(struct regulator_dev *rdev) 86 { 87 struct rt6160_priv *priv = rdev_get_drvdata(rdev); 88 89 return priv->enable_state ? 1 : 0; 90 } 91 92 static int rt6160_set_mode(struct regulator_dev *rdev, unsigned int mode) 93 { 94 struct regmap *regmap = rdev_get_regmap(rdev); 95 unsigned int mode_val; 96 97 switch (mode) { 98 case REGULATOR_MODE_FAST: 99 mode_val = RT6160_FPWM_MASK; 100 break; 101 case REGULATOR_MODE_NORMAL: 102 mode_val = 0; 103 break; 104 default: 105 dev_err(&rdev->dev, "mode not supported\n"); 106 return -EINVAL; 107 } 108 109 return regmap_update_bits(regmap, RT6160_REG_CNTL, RT6160_FPWM_MASK, mode_val); 110 } 111 112 static unsigned int rt6160_get_mode(struct regulator_dev *rdev) 113 { 114 struct regmap *regmap = rdev_get_regmap(rdev); 115 unsigned int val; 116 int ret; 117 118 ret = regmap_read(regmap, RT6160_REG_CNTL, &val); 119 if (ret) 120 return ret; 121 122 if (val & RT6160_FPWM_MASK) 123 return REGULATOR_MODE_FAST; 124 125 return REGULATOR_MODE_NORMAL; 126 } 127 128 static int rt6160_set_suspend_voltage(struct regulator_dev *rdev, int uV) 129 { 130 struct regmap *regmap = rdev_get_regmap(rdev); 131 unsigned int suspend_vsel_reg; 132 int vsel; 133 134 vsel = regulator_map_voltage_linear(rdev, uV, uV); 135 if (vsel < 0) 136 return vsel; 137 138 if (rdev->desc->vsel_reg == RT6160_REG_VSELL) 139 suspend_vsel_reg = RT6160_REG_VSELH; 140 else 141 suspend_vsel_reg = RT6160_REG_VSELL; 142 143 return regmap_update_bits(regmap, suspend_vsel_reg, 144 RT6160_VSEL_MASK, vsel); 145 } 146 147 static int rt6160_get_error_flags(struct regulator_dev *rdev, unsigned int *flags) 148 { 149 struct regmap *regmap = rdev_get_regmap(rdev); 150 unsigned int val, events = 0; 151 int ret; 152 153 ret = regmap_read(regmap, RT6160_REG_STATUS, &val); 154 if (ret) 155 return ret; 156 157 if (val & (RT6160_HDSTAT_MASK | RT6160_TSDSTAT_MASK)) 158 events |= REGULATOR_ERROR_OVER_TEMP; 159 160 if (val & RT6160_UVSTAT_MASK) 161 events |= REGULATOR_ERROR_UNDER_VOLTAGE; 162 163 if (val & RT6160_OCSTAT_MASK) 164 events |= REGULATOR_ERROR_OVER_CURRENT; 165 166 if (val & RT6160_PGSTAT_MASK) 167 events |= REGULATOR_ERROR_FAIL; 168 169 *flags = events; 170 return 0; 171 } 172 173 static const struct regulator_ops rt6160_regulator_ops = { 174 .list_voltage = regulator_list_voltage_linear, 175 .set_voltage_sel = regulator_set_voltage_sel_regmap, 176 .get_voltage_sel = regulator_get_voltage_sel_regmap, 177 178 .enable = rt6160_enable, 179 .disable = rt6160_disable, 180 .is_enabled = rt6160_is_enabled, 181 182 .set_mode = rt6160_set_mode, 183 .get_mode = rt6160_get_mode, 184 .set_suspend_voltage = rt6160_set_suspend_voltage, 185 .set_ramp_delay = regulator_set_ramp_delay_regmap, 186 .get_error_flags = rt6160_get_error_flags, 187 }; 188 189 static unsigned int rt6160_of_map_mode(unsigned int mode) 190 { 191 switch (mode) { 192 case RT6160_MODE_FPWM: 193 return REGULATOR_MODE_FAST; 194 case RT6160_MODE_AUTO: 195 return REGULATOR_MODE_NORMAL; 196 } 197 198 return REGULATOR_MODE_INVALID; 199 } 200 201 static bool rt6160_is_accessible_reg(struct device *dev, unsigned int reg) 202 { 203 if (reg >= RT6160_REG_CNTL && reg <= RT6160_REG_VSELH) 204 return true; 205 return false; 206 } 207 208 static bool rt6160_is_volatile_reg(struct device *dev, unsigned int reg) 209 { 210 if (reg == RT6160_REG_STATUS) 211 return true; 212 return false; 213 } 214 215 static const struct regmap_config rt6160_regmap_config = { 216 .reg_bits = 8, 217 .val_bits = 8, 218 .max_register = RT6160_REG_VSELH, 219 .num_reg_defaults_raw = RT6160_NUM_REGS, 220 .cache_type = REGCACHE_FLAT, 221 222 .writeable_reg = rt6160_is_accessible_reg, 223 .readable_reg = rt6160_is_accessible_reg, 224 .volatile_reg = rt6160_is_volatile_reg, 225 }; 226 227 static int rt6160_probe(struct i2c_client *i2c) 228 { 229 struct rt6160_priv *priv; 230 struct regulator_config regulator_cfg = {}; 231 struct regulator_dev *rdev; 232 bool vsel_active_low; 233 unsigned int devid; 234 int ret; 235 236 priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL); 237 if (!priv) 238 return -ENOMEM; 239 240 vsel_active_low = 241 device_property_present(&i2c->dev, "richtek,vsel-active-low"); 242 243 priv->enable_gpio = devm_gpiod_get_optional(&i2c->dev, "enable", GPIOD_OUT_HIGH); 244 if (IS_ERR(priv->enable_gpio)) { 245 dev_err(&i2c->dev, "Failed to get 'enable' gpio\n"); 246 return PTR_ERR(priv->enable_gpio); 247 } 248 priv->enable_state = true; 249 250 usleep_range(RT6160_I2CRDY_TIMEUS, RT6160_I2CRDY_TIMEUS + 100); 251 252 priv->regmap = devm_regmap_init_i2c(i2c, &rt6160_regmap_config); 253 if (IS_ERR(priv->regmap)) { 254 ret = PTR_ERR(priv->regmap); 255 dev_err(&i2c->dev, "Failed to init regmap (%d)\n", ret); 256 return ret; 257 } 258 259 ret = regmap_read(priv->regmap, RT6160_REG_DEVID, &devid); 260 if (ret) 261 return ret; 262 263 if ((devid & RT6160_VID_MASK) != RT6160_VENDOR_ID) { 264 dev_err(&i2c->dev, "VID not correct [0x%02x]\n", devid); 265 return -ENODEV; 266 } 267 268 priv->desc.name = "rt6160-buckboost"; 269 priv->desc.type = REGULATOR_VOLTAGE; 270 priv->desc.owner = THIS_MODULE; 271 priv->desc.min_uV = RT6160_VOUT_MINUV; 272 priv->desc.uV_step = RT6160_VOUT_STPUV; 273 if (vsel_active_low) 274 priv->desc.vsel_reg = RT6160_REG_VSELL; 275 else 276 priv->desc.vsel_reg = RT6160_REG_VSELH; 277 priv->desc.vsel_mask = RT6160_VSEL_MASK; 278 priv->desc.n_voltages = RT6160_N_VOUTS; 279 priv->desc.ramp_reg = RT6160_REG_CNTL; 280 priv->desc.ramp_mask = RT6160_RAMPRATE_MASK; 281 priv->desc.ramp_delay_table = rt6160_ramp_tables; 282 priv->desc.n_ramp_values = ARRAY_SIZE(rt6160_ramp_tables); 283 priv->desc.of_map_mode = rt6160_of_map_mode; 284 priv->desc.ops = &rt6160_regulator_ops; 285 286 regulator_cfg.dev = &i2c->dev; 287 regulator_cfg.of_node = i2c->dev.of_node; 288 regulator_cfg.regmap = priv->regmap; 289 regulator_cfg.driver_data = priv; 290 regulator_cfg.init_data = of_get_regulator_init_data(&i2c->dev, i2c->dev.of_node, 291 &priv->desc); 292 293 rdev = devm_regulator_register(&i2c->dev, &priv->desc, ®ulator_cfg); 294 if (IS_ERR(rdev)) { 295 dev_err(&i2c->dev, "Failed to register regulator\n"); 296 return PTR_ERR(rdev); 297 } 298 299 return 0; 300 } 301 302 static const struct of_device_id __maybe_unused rt6160_of_match_table[] = { 303 { .compatible = "richtek,rt6160", }, 304 {} 305 }; 306 MODULE_DEVICE_TABLE(of, rt6160_of_match_table); 307 308 static struct i2c_driver rt6160_driver = { 309 .driver = { 310 .name = "rt6160", 311 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 312 .of_match_table = rt6160_of_match_table, 313 }, 314 .probe = rt6160_probe, 315 }; 316 module_i2c_driver(rt6160_driver); 317 318 MODULE_DESCRIPTION("Richtek RT6160 voltage regulator driver"); 319 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 320 MODULE_LICENSE("GPL v2"); 321