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