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