1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Device driver for RT5739 regulator 4 * 5 * Copyright (C) 2023 Richtek Technology Corp. 6 * 7 * Author: ChiYuan Huang <cy_huang@richtek.com> 8 */ 9 10 #include <linux/bits.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/i2c.h> 13 #include <linux/kernel.h> 14 #include <linux/property.h> 15 #include <linux/regmap.h> 16 #include <linux/regulator/driver.h> 17 #include <linux/regulator/of_regulator.h> 18 19 #define RT5739_AUTO_MODE 0 20 #define RT5739_FPWM_MODE 1 21 22 #define RT5739_REG_NSEL0 0x00 23 #define RT5739_REG_NSEL1 0x01 24 #define RT5739_REG_CNTL1 0x02 25 #define RT5739_REG_ID1 0x03 26 #define RT5739_REG_ID2 0x04 27 #define RT5739_REG_MON 0x05 28 #define RT5739_REG_CNTL2 0x06 29 #define RT5739_REG_CNTL4 0x08 30 31 #define RT5739_VSEL_MASK GENMASK(7, 0) 32 #define RT5739_MODEVSEL1_MASK BIT(1) 33 #define RT5739_MODEVSEL0_MASK BIT(0) 34 #define RT5739_VID_MASK GENMASK(7, 5) 35 #define RT5739_DID_MASK GENMASK(3, 0) 36 #define RT5739_ACTD_MASK BIT(7) 37 #define RT5739_ENVSEL1_MASK BIT(1) 38 #define RT5739_ENVSEL0_MASK BIT(0) 39 40 #define RT5733_CHIPDIE_ID 0x1 41 #define RT5733_VOLT_MINUV 270000 42 #define RT5733_VOLT_MAXUV 1401250 43 #define RT5733_VOLT_STPUV 6250 44 #define RT5733_N_VOLTS 182 45 46 #define RT5739_VOLT_MINUV 300000 47 #define RT5739_VOLT_MAXUV 1300000 48 #define RT5739_VOLT_STPUV 5000 49 #define RT5739_N_VOLTS 201 50 #define RT5739_I2CRDY_TIMEUS 1000 51 52 static int rt5739_set_mode(struct regulator_dev *rdev, unsigned int mode) 53 { 54 const struct regulator_desc *desc = rdev->desc; 55 struct regmap *regmap = rdev_get_regmap(rdev); 56 unsigned int mask, val; 57 58 if (desc->vsel_reg == RT5739_REG_NSEL0) 59 mask = RT5739_MODEVSEL0_MASK; 60 else 61 mask = RT5739_MODEVSEL1_MASK; 62 63 switch (mode) { 64 case REGULATOR_MODE_FAST: 65 val = mask; 66 break; 67 case REGULATOR_MODE_NORMAL: 68 val = 0; 69 break; 70 default: 71 return -EINVAL; 72 } 73 74 return regmap_update_bits(regmap, RT5739_REG_CNTL1, mask, val); 75 } 76 77 static unsigned int rt5739_get_mode(struct regulator_dev *rdev) 78 { 79 const struct regulator_desc *desc = rdev->desc; 80 struct regmap *regmap = rdev_get_regmap(rdev); 81 unsigned int mask, val; 82 int ret; 83 84 if (desc->vsel_reg == RT5739_REG_NSEL0) 85 mask = RT5739_MODEVSEL0_MASK; 86 else 87 mask = RT5739_MODEVSEL1_MASK; 88 89 ret = regmap_read(regmap, RT5739_REG_CNTL1, &val); 90 if (ret) 91 return REGULATOR_MODE_INVALID; 92 93 if (val & mask) 94 return REGULATOR_MODE_FAST; 95 96 return REGULATOR_MODE_NORMAL; 97 } 98 99 static int rt5739_set_suspend_voltage(struct regulator_dev *rdev, int uV) 100 { 101 const struct regulator_desc *desc = rdev->desc; 102 struct regmap *regmap = rdev_get_regmap(rdev); 103 unsigned int reg, vsel; 104 int max_uV; 105 106 max_uV = desc->min_uV + desc->uV_step * (desc->n_voltages - 1); 107 108 if (uV < desc->min_uV || uV > max_uV) 109 return -EINVAL; 110 111 if (desc->vsel_reg == RT5739_REG_NSEL0) 112 reg = RT5739_REG_NSEL1; 113 else 114 reg = RT5739_REG_NSEL0; 115 116 vsel = (uV - desc->min_uV) / desc->uV_step; 117 return regmap_write(regmap, reg, vsel); 118 } 119 120 static int rt5739_set_suspend_enable(struct regulator_dev *rdev) 121 { 122 const struct regulator_desc *desc = rdev->desc; 123 struct regmap *regmap = rdev_get_regmap(rdev); 124 unsigned int mask; 125 126 if (desc->vsel_reg == RT5739_REG_NSEL0) 127 mask = RT5739_ENVSEL1_MASK; 128 else 129 mask = RT5739_ENVSEL0_MASK; 130 131 return regmap_update_bits(regmap, desc->enable_reg, mask, mask); 132 } 133 134 static int rt5739_set_suspend_disable(struct regulator_dev *rdev) 135 { 136 const struct regulator_desc *desc = rdev->desc; 137 struct regmap *regmap = rdev_get_regmap(rdev); 138 unsigned int mask; 139 140 if (desc->vsel_reg == RT5739_REG_NSEL0) 141 mask = RT5739_ENVSEL1_MASK; 142 else 143 mask = RT5739_ENVSEL0_MASK; 144 145 return regmap_update_bits(regmap, desc->enable_reg, mask, 0); 146 } 147 148 static int rt5739_set_suspend_mode(struct regulator_dev *rdev, 149 unsigned int mode) 150 { 151 const struct regulator_desc *desc = rdev->desc; 152 struct regmap *regmap = rdev_get_regmap(rdev); 153 unsigned int mask, val; 154 155 if (desc->vsel_reg == RT5739_REG_NSEL0) 156 mask = RT5739_MODEVSEL1_MASK; 157 else 158 mask = RT5739_MODEVSEL0_MASK; 159 160 switch (mode) { 161 case REGULATOR_MODE_FAST: 162 val = mask; 163 break; 164 case REGULATOR_MODE_NORMAL: 165 val = 0; 166 break; 167 default: 168 return -EINVAL; 169 } 170 171 return regmap_update_bits(regmap, RT5739_REG_CNTL1, mask, val); 172 } 173 174 static const struct regulator_ops rt5739_regulator_ops = { 175 .list_voltage = regulator_list_voltage_linear, 176 .get_voltage_sel = regulator_get_voltage_sel_regmap, 177 .set_voltage_sel = regulator_set_voltage_sel_regmap, 178 .enable = regulator_enable_regmap, 179 .disable = regulator_disable_regmap, 180 .is_enabled = regulator_is_enabled_regmap, 181 .set_active_discharge = regulator_set_active_discharge_regmap, 182 .set_mode = rt5739_set_mode, 183 .get_mode = rt5739_get_mode, 184 .set_suspend_voltage = rt5739_set_suspend_voltage, 185 .set_suspend_enable = rt5739_set_suspend_enable, 186 .set_suspend_disable = rt5739_set_suspend_disable, 187 .set_suspend_mode = rt5739_set_suspend_mode, 188 }; 189 190 static unsigned int rt5739_of_map_mode(unsigned int mode) 191 { 192 switch (mode) { 193 case RT5739_AUTO_MODE: 194 return REGULATOR_MODE_NORMAL; 195 case RT5739_FPWM_MODE: 196 return REGULATOR_MODE_FAST; 197 default: 198 return REGULATOR_MODE_INVALID; 199 } 200 } 201 202 static void rt5739_init_regulator_desc(struct regulator_desc *desc, 203 bool vsel_active_high, u8 did) 204 { 205 /* Fixed */ 206 desc->name = "rt5739-regulator"; 207 desc->owner = THIS_MODULE; 208 desc->ops = &rt5739_regulator_ops; 209 desc->vsel_mask = RT5739_VSEL_MASK; 210 desc->enable_reg = RT5739_REG_CNTL2; 211 desc->active_discharge_reg = RT5739_REG_CNTL1; 212 desc->active_discharge_mask = RT5739_ACTD_MASK; 213 desc->active_discharge_on = RT5739_ACTD_MASK; 214 desc->of_map_mode = rt5739_of_map_mode; 215 216 /* Assigned by vsel level */ 217 if (vsel_active_high) { 218 desc->vsel_reg = RT5739_REG_NSEL1; 219 desc->enable_mask = RT5739_ENVSEL1_MASK; 220 } else { 221 desc->vsel_reg = RT5739_REG_NSEL0; 222 desc->enable_mask = RT5739_ENVSEL0_MASK; 223 } 224 225 /* Assigned by CHIPDIE ID */ 226 switch (did) { 227 case RT5733_CHIPDIE_ID: 228 desc->n_voltages = RT5733_N_VOLTS; 229 desc->min_uV = RT5733_VOLT_MINUV; 230 desc->uV_step = RT5733_VOLT_STPUV; 231 break; 232 default: 233 desc->n_voltages = RT5739_N_VOLTS; 234 desc->min_uV = RT5739_VOLT_MINUV; 235 desc->uV_step = RT5739_VOLT_STPUV; 236 break; 237 } 238 } 239 240 static bool rt5739_volatile_reg(struct device *dev, unsigned int reg) 241 { 242 return reg == RT5739_REG_MON; 243 } 244 245 static const struct regmap_config rt5739_regmap_config = { 246 .name = "rt5739", 247 .reg_bits = 8, 248 .val_bits = 8, 249 .max_register = RT5739_REG_CNTL4, 250 .cache_type = REGCACHE_MAPLE, 251 .volatile_reg = rt5739_volatile_reg, 252 }; 253 254 static int rt5739_probe(struct i2c_client *i2c) 255 { 256 struct device *dev = &i2c->dev; 257 struct regulator_desc *desc; 258 struct regmap *regmap; 259 struct gpio_desc *enable_gpio; 260 struct regulator_config cfg = {}; 261 struct regulator_dev *rdev; 262 bool vsel_acth; 263 unsigned int vid; 264 int ret; 265 266 desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL); 267 if (!desc) 268 return -ENOMEM; 269 270 enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH); 271 if (IS_ERR(enable_gpio)) 272 return dev_err_probe(dev, PTR_ERR(enable_gpio), "Failed to get 'enable' gpio\n"); 273 else if (enable_gpio) 274 usleep_range(RT5739_I2CRDY_TIMEUS, RT5739_I2CRDY_TIMEUS + 1000); 275 276 regmap = devm_regmap_init_i2c(i2c, &rt5739_regmap_config); 277 if (IS_ERR(regmap)) 278 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n"); 279 280 ret = regmap_read(regmap, RT5739_REG_ID1, &vid); 281 if (ret) 282 return dev_err_probe(dev, ret, "Failed to read VID\n"); 283 284 /* RT5739: (VID & MASK) must be 0 */ 285 if (vid & RT5739_VID_MASK) 286 return dev_err_probe(dev, -ENODEV, "Incorrect VID (0x%02x)\n", vid); 287 288 vsel_acth = device_property_read_bool(dev, "richtek,vsel-active-high"); 289 290 rt5739_init_regulator_desc(desc, vsel_acth, vid & RT5739_DID_MASK); 291 292 cfg.dev = dev; 293 cfg.of_node = dev_of_node(dev); 294 cfg.init_data = of_get_regulator_init_data(dev, dev_of_node(dev), desc); 295 rdev = devm_regulator_register(dev, desc, &cfg); 296 if (IS_ERR(rdev)) 297 return dev_err_probe(dev, PTR_ERR(rdev), "Failed to register regulator\n"); 298 299 return 0; 300 } 301 302 static const struct of_device_id rt5739_device_table[] = { 303 { .compatible = "richtek,rt5733" }, 304 { .compatible = "richtek,rt5739" }, 305 { /* sentinel */ } 306 }; 307 MODULE_DEVICE_TABLE(of, rt5739_device_table); 308 309 static struct i2c_driver rt5739_driver = { 310 .driver = { 311 .name = "rt5739", 312 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 313 .of_match_table = rt5739_device_table, 314 }, 315 .probe = rt5739_probe, 316 }; 317 module_i2c_driver(rt5739_driver); 318 319 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 320 MODULE_DESCRIPTION("Richtek RT5739 regulator driver"); 321 MODULE_LICENSE("GPL"); 322