1 /* 2 * tps65023-regulator.c 3 * 4 * Supports TPS65023 Regulator 5 * 6 * Copyright (C) 2009 Texas Instrument Incorporated - https://www.ti.com/ 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation version 2. 11 * 12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind, 13 * whether express or implied; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/err.h> 22 #include <linux/platform_device.h> 23 #include <linux/regulator/driver.h> 24 #include <linux/regulator/machine.h> 25 #include <linux/i2c.h> 26 #include <linux/slab.h> 27 #include <linux/regmap.h> 28 29 /* Register definitions */ 30 #define TPS65023_REG_VERSION 0 31 #define TPS65023_REG_PGOODZ 1 32 #define TPS65023_REG_MASK 2 33 #define TPS65023_REG_REG_CTRL 3 34 #define TPS65023_REG_CON_CTRL 4 35 #define TPS65023_REG_CON_CTRL2 5 36 #define TPS65023_REG_DEF_CORE 6 37 #define TPS65023_REG_DEFSLEW 7 38 #define TPS65023_REG_LDO_CTRL 8 39 40 /* PGOODZ bitfields */ 41 #define TPS65023_PGOODZ_PWRFAILZ BIT(7) 42 #define TPS65023_PGOODZ_LOWBATTZ BIT(6) 43 #define TPS65023_PGOODZ_VDCDC1 BIT(5) 44 #define TPS65023_PGOODZ_VDCDC2 BIT(4) 45 #define TPS65023_PGOODZ_VDCDC3 BIT(3) 46 #define TPS65023_PGOODZ_LDO2 BIT(2) 47 #define TPS65023_PGOODZ_LDO1 BIT(1) 48 49 /* MASK bitfields */ 50 #define TPS65023_MASK_PWRFAILZ BIT(7) 51 #define TPS65023_MASK_LOWBATTZ BIT(6) 52 #define TPS65023_MASK_VDCDC1 BIT(5) 53 #define TPS65023_MASK_VDCDC2 BIT(4) 54 #define TPS65023_MASK_VDCDC3 BIT(3) 55 #define TPS65023_MASK_LDO2 BIT(2) 56 #define TPS65023_MASK_LDO1 BIT(1) 57 58 /* REG_CTRL bitfields */ 59 #define TPS65023_REG_CTRL_VDCDC1_EN BIT(5) 60 #define TPS65023_REG_CTRL_VDCDC2_EN BIT(4) 61 #define TPS65023_REG_CTRL_VDCDC3_EN BIT(3) 62 #define TPS65023_REG_CTRL_LDO2_EN BIT(2) 63 #define TPS65023_REG_CTRL_LDO1_EN BIT(1) 64 65 /* REG_CTRL2 bitfields */ 66 #define TPS65023_REG_CTRL2_GO BIT(7) 67 #define TPS65023_REG_CTRL2_CORE_ADJ BIT(6) 68 #define TPS65023_REG_CTRL2_DCDC2 BIT(2) 69 #define TPS65023_REG_CTRL2_DCDC1 BIT(1) 70 #define TPS65023_REG_CTRL2_DCDC3 BIT(0) 71 72 /* Number of step-down converters available */ 73 #define TPS65023_NUM_DCDC 3 74 /* Number of LDO voltage regulators available */ 75 #define TPS65023_NUM_LDO 2 76 /* Number of total regulators available */ 77 #define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO) 78 79 /* DCDCs */ 80 #define TPS65023_DCDC_1 0 81 #define TPS65023_DCDC_2 1 82 #define TPS65023_DCDC_3 2 83 /* LDOs */ 84 #define TPS65023_LDO_1 3 85 #define TPS65023_LDO_2 4 86 87 #define TPS65023_MAX_REG_ID TPS65023_LDO_2 88 89 #define TPS65023_REGULATOR_DCDC(_num, _t, _em) \ 90 { \ 91 .name = "VDCDC"#_num, \ 92 .of_match = of_match_ptr("VDCDC"#_num), \ 93 .regulators_node = of_match_ptr("regulators"), \ 94 .id = TPS65023_DCDC_##_num, \ 95 .n_voltages = ARRAY_SIZE(_t), \ 96 .ops = &tps65023_dcdc_ops, \ 97 .type = REGULATOR_VOLTAGE, \ 98 .owner = THIS_MODULE, \ 99 .volt_table = _t, \ 100 .vsel_reg = TPS65023_REG_DEF_CORE, \ 101 .vsel_mask = ARRAY_SIZE(_t) - 1, \ 102 .enable_mask = _em, \ 103 .enable_reg = TPS65023_REG_REG_CTRL, \ 104 .apply_reg = TPS65023_REG_CON_CTRL2, \ 105 .apply_bit = TPS65023_REG_CTRL2_GO, \ 106 } \ 107 108 #define TPS65023_REGULATOR_LDO(_num, _t, _vm) \ 109 { \ 110 .name = "LDO"#_num, \ 111 .of_match = of_match_ptr("LDO"#_num), \ 112 .regulators_node = of_match_ptr("regulators"), \ 113 .id = TPS65023_LDO_##_num, \ 114 .n_voltages = ARRAY_SIZE(_t), \ 115 .ops = &tps65023_ldo_ops, \ 116 .type = REGULATOR_VOLTAGE, \ 117 .owner = THIS_MODULE, \ 118 .volt_table = _t, \ 119 .vsel_reg = TPS65023_REG_LDO_CTRL, \ 120 .vsel_mask = _vm, \ 121 .enable_mask = 1 << (_num), \ 122 .enable_reg = TPS65023_REG_REG_CTRL, \ 123 } \ 124 125 /* Supported voltage values for regulators */ 126 static const unsigned int VCORE_VSEL_table[] = { 127 800000, 825000, 850000, 875000, 128 900000, 925000, 950000, 975000, 129 1000000, 1025000, 1050000, 1075000, 130 1100000, 1125000, 1150000, 1175000, 131 1200000, 1225000, 1250000, 1275000, 132 1300000, 1325000, 1350000, 1375000, 133 1400000, 1425000, 1450000, 1475000, 134 1500000, 1525000, 1550000, 1600000, 135 }; 136 137 static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = { 138 3300000, 139 }; 140 141 static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = { 142 1800000, 143 }; 144 145 /* Supported voltage values for LDO regulators for tps65020 */ 146 static const unsigned int TPS65020_LDO_VSEL_table[] = { 147 1000000, 1050000, 1100000, 1300000, 148 1800000, 2500000, 3000000, 3300000, 149 }; 150 151 /* Supported voltage values for LDO regulators 152 * for tps65021 and tps65023 */ 153 static const unsigned int TPS65023_LDO1_VSEL_table[] = { 154 1000000, 1100000, 1300000, 1800000, 155 2200000, 2600000, 2800000, 3150000, 156 }; 157 158 static const unsigned int TPS65023_LDO2_VSEL_table[] = { 159 1050000, 1200000, 1300000, 1800000, 160 2500000, 2800000, 3000000, 3300000, 161 }; 162 163 /* PMIC details */ 164 struct tps_pmic { 165 struct regulator_dev *rdev[TPS65023_NUM_REGULATOR]; 166 const struct tps_driver_data *driver_data; 167 struct regmap *regmap; 168 }; 169 170 /* Struct passed as driver data */ 171 struct tps_driver_data { 172 const struct regulator_desc *desc; 173 u8 core_regulator; 174 }; 175 176 static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev) 177 { 178 struct tps_pmic *tps = rdev_get_drvdata(dev); 179 int dcdc = rdev_get_id(dev); 180 181 if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3) 182 return -EINVAL; 183 184 if (dcdc != tps->driver_data->core_regulator) 185 return 0; 186 187 return regulator_get_voltage_sel_regmap(dev); 188 } 189 190 static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev, 191 unsigned selector) 192 { 193 struct tps_pmic *tps = rdev_get_drvdata(dev); 194 int dcdc = rdev_get_id(dev); 195 196 if (dcdc != tps->driver_data->core_regulator) 197 return -EINVAL; 198 199 return regulator_set_voltage_sel_regmap(dev, selector); 200 } 201 202 /* Operations permitted on VDCDCx */ 203 static const struct regulator_ops tps65023_dcdc_ops = { 204 .is_enabled = regulator_is_enabled_regmap, 205 .enable = regulator_enable_regmap, 206 .disable = regulator_disable_regmap, 207 .get_voltage_sel = tps65023_dcdc_get_voltage_sel, 208 .set_voltage_sel = tps65023_dcdc_set_voltage_sel, 209 .list_voltage = regulator_list_voltage_table, 210 .map_voltage = regulator_map_voltage_ascend, 211 }; 212 213 /* Operations permitted on LDOx */ 214 static const struct regulator_ops tps65023_ldo_ops = { 215 .is_enabled = regulator_is_enabled_regmap, 216 .enable = regulator_enable_regmap, 217 .disable = regulator_disable_regmap, 218 .get_voltage_sel = regulator_get_voltage_sel_regmap, 219 .set_voltage_sel = regulator_set_voltage_sel_regmap, 220 .list_voltage = regulator_list_voltage_table, 221 .map_voltage = regulator_map_voltage_ascend, 222 }; 223 224 static const struct regmap_config tps65023_regmap_config = { 225 .reg_bits = 8, 226 .val_bits = 8, 227 }; 228 229 static const struct regulator_desc tps65020_regulators[] = { 230 TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20), 231 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10), 232 TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08), 233 TPS65023_REGULATOR_LDO(1, TPS65020_LDO_VSEL_table, 0x07), 234 TPS65023_REGULATOR_LDO(2, TPS65020_LDO_VSEL_table, 0x70), 235 }; 236 237 static const struct regulator_desc tps65021_regulators[] = { 238 TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20), 239 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10), 240 TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08), 241 TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07), 242 TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70), 243 }; 244 245 static const struct regulator_desc tps65023_regulators[] = { 246 TPS65023_REGULATOR_DCDC(1, VCORE_VSEL_table, 0x20), 247 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_3300000_VSEL_table, 0x10), 248 TPS65023_REGULATOR_DCDC(3, DCDC_FIXED_1800000_VSEL_table, 0x08), 249 TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07), 250 TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70), 251 }; 252 253 static struct tps_driver_data tps65020_drv_data = { 254 .desc = tps65020_regulators, 255 .core_regulator = TPS65023_DCDC_3, 256 }; 257 258 static struct tps_driver_data tps65021_drv_data = { 259 .desc = tps65021_regulators, 260 .core_regulator = TPS65023_DCDC_3, 261 }; 262 263 static struct tps_driver_data tps65023_drv_data = { 264 .desc = tps65023_regulators, 265 .core_regulator = TPS65023_DCDC_1, 266 }; 267 268 static int tps_65023_probe(struct i2c_client *client, 269 const struct i2c_device_id *id) 270 { 271 struct regulator_init_data *init_data = dev_get_platdata(&client->dev); 272 struct regulator_config config = { }; 273 struct tps_pmic *tps; 274 int i; 275 int error; 276 277 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); 278 if (!tps) 279 return -ENOMEM; 280 281 tps->driver_data = (struct tps_driver_data *)id->driver_data; 282 283 tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config); 284 if (IS_ERR(tps->regmap)) { 285 error = PTR_ERR(tps->regmap); 286 dev_err(&client->dev, "Failed to allocate register map: %d\n", 287 error); 288 return error; 289 } 290 291 /* common for all regulators */ 292 config.dev = &client->dev; 293 config.driver_data = tps; 294 config.regmap = tps->regmap; 295 296 for (i = 0; i < TPS65023_NUM_REGULATOR; i++) { 297 if (init_data) 298 config.init_data = &init_data[i]; 299 300 /* Register the regulators */ 301 tps->rdev[i] = devm_regulator_register(&client->dev, 302 &tps->driver_data->desc[i], &config); 303 if (IS_ERR(tps->rdev[i])) { 304 dev_err(&client->dev, "failed to register %s\n", 305 id->name); 306 return PTR_ERR(tps->rdev[i]); 307 } 308 } 309 310 i2c_set_clientdata(client, tps); 311 312 /* Enable setting output voltage by I2C */ 313 regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2, 314 TPS65023_REG_CTRL2_CORE_ADJ, 0); 315 316 return 0; 317 } 318 319 static const struct of_device_id tps65023_of_match[] = { 320 { .compatible = "ti,tps65020", .data = &tps65020_drv_data}, 321 { .compatible = "ti,tps65021", .data = &tps65021_drv_data}, 322 { .compatible = "ti,tps65023", .data = &tps65023_drv_data}, 323 {}, 324 }; 325 MODULE_DEVICE_TABLE(of, tps65023_of_match); 326 327 static const struct i2c_device_id tps_65023_id[] = { 328 { 329 .name = "tps65023", 330 .driver_data = (kernel_ulong_t)&tps65023_drv_data 331 }, { 332 .name = "tps65021", 333 .driver_data = (kernel_ulong_t)&tps65021_drv_data 334 }, { 335 .name = "tps65020", 336 .driver_data = (kernel_ulong_t)&tps65020_drv_data 337 }, 338 { }, 339 }; 340 MODULE_DEVICE_TABLE(i2c, tps_65023_id); 341 342 static struct i2c_driver tps_65023_i2c_driver = { 343 .driver = { 344 .name = "tps65023", 345 .of_match_table = of_match_ptr(tps65023_of_match), 346 }, 347 .probe = tps_65023_probe, 348 .id_table = tps_65023_id, 349 }; 350 351 static int __init tps_65023_init(void) 352 { 353 return i2c_add_driver(&tps_65023_i2c_driver); 354 } 355 subsys_initcall(tps_65023_init); 356 357 static void __exit tps_65023_cleanup(void) 358 { 359 i2c_del_driver(&tps_65023_i2c_driver); 360 } 361 module_exit(tps_65023_cleanup); 362 363 MODULE_AUTHOR("Texas Instruments"); 364 MODULE_DESCRIPTION("TPS65023 voltage regulator driver"); 365 MODULE_LICENSE("GPL v2"); 366