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