1 /* 2 * tps65023-regulator.c 3 * 4 * Supports TPS65023 Regulator 5 * 6 * Copyright (C) 2009 Texas Instrument Incorporated - http://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 /* Supported voltage values for regulators */ 90 static const unsigned int VCORE_VSEL_table[] = { 91 800000, 825000, 850000, 875000, 92 900000, 925000, 950000, 975000, 93 1000000, 1025000, 1050000, 1075000, 94 1100000, 1125000, 1150000, 1175000, 95 1200000, 1225000, 1250000, 1275000, 96 1300000, 1325000, 1350000, 1375000, 97 1400000, 1425000, 1450000, 1475000, 98 1500000, 1525000, 1550000, 1600000, 99 }; 100 101 static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = { 102 3300000, 103 }; 104 105 static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = { 106 1800000, 107 }; 108 109 /* Supported voltage values for LDO regulators for tps65020 */ 110 static const unsigned int TPS65020_LDO_VSEL_table[] = { 111 1000000, 1050000, 1100000, 1300000, 112 1800000, 2500000, 3000000, 3300000, 113 }; 114 115 /* Supported voltage values for LDO regulators 116 * for tps65021 and tps65023 */ 117 static const unsigned int TPS65023_LDO1_VSEL_table[] = { 118 1000000, 1100000, 1300000, 1800000, 119 2200000, 2600000, 2800000, 3150000, 120 }; 121 122 static const unsigned int TPS65023_LDO2_VSEL_table[] = { 123 1050000, 1200000, 1300000, 1800000, 124 2500000, 2800000, 3000000, 3300000, 125 }; 126 127 /* Regulator specific details */ 128 struct tps_info { 129 const char *name; 130 u8 table_len; 131 const unsigned int *table; 132 }; 133 134 /* PMIC details */ 135 struct tps_pmic { 136 struct regulator_desc desc[TPS65023_NUM_REGULATOR]; 137 struct regulator_dev *rdev[TPS65023_NUM_REGULATOR]; 138 const struct tps_info *info[TPS65023_NUM_REGULATOR]; 139 struct regmap *regmap; 140 u8 core_regulator; 141 }; 142 143 /* Struct passed as driver data */ 144 struct tps_driver_data { 145 const struct tps_info *info; 146 u8 core_regulator; 147 }; 148 149 static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev) 150 { 151 struct tps_pmic *tps = rdev_get_drvdata(dev); 152 int dcdc = rdev_get_id(dev); 153 154 if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3) 155 return -EINVAL; 156 157 if (dcdc != tps->core_regulator) 158 return 0; 159 160 return regulator_get_voltage_sel_regmap(dev); 161 } 162 163 static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev, 164 unsigned selector) 165 { 166 struct tps_pmic *tps = rdev_get_drvdata(dev); 167 int dcdc = rdev_get_id(dev); 168 169 if (dcdc != tps->core_regulator) 170 return -EINVAL; 171 172 return regulator_set_voltage_sel_regmap(dev, selector); 173 } 174 175 /* Operations permitted on VDCDCx */ 176 static const struct regulator_ops tps65023_dcdc_ops = { 177 .is_enabled = regulator_is_enabled_regmap, 178 .enable = regulator_enable_regmap, 179 .disable = regulator_disable_regmap, 180 .get_voltage_sel = tps65023_dcdc_get_voltage_sel, 181 .set_voltage_sel = tps65023_dcdc_set_voltage_sel, 182 .list_voltage = regulator_list_voltage_table, 183 .map_voltage = regulator_map_voltage_ascend, 184 }; 185 186 /* Operations permitted on LDOx */ 187 static const struct regulator_ops tps65023_ldo_ops = { 188 .is_enabled = regulator_is_enabled_regmap, 189 .enable = regulator_enable_regmap, 190 .disable = regulator_disable_regmap, 191 .get_voltage_sel = regulator_get_voltage_sel_regmap, 192 .set_voltage_sel = regulator_set_voltage_sel_regmap, 193 .list_voltage = regulator_list_voltage_table, 194 .map_voltage = regulator_map_voltage_ascend, 195 }; 196 197 static const struct regmap_config tps65023_regmap_config = { 198 .reg_bits = 8, 199 .val_bits = 8, 200 }; 201 202 static int tps_65023_probe(struct i2c_client *client, 203 const struct i2c_device_id *id) 204 { 205 const struct tps_driver_data *drv_data = (void *)id->driver_data; 206 const struct tps_info *info = drv_data->info; 207 struct regulator_config config = { }; 208 struct regulator_init_data *init_data; 209 struct regulator_dev *rdev; 210 struct tps_pmic *tps; 211 int i; 212 int error; 213 214 /** 215 * init_data points to array of regulator_init structures 216 * coming from the board-evm file. 217 */ 218 init_data = dev_get_platdata(&client->dev); 219 if (!init_data) 220 return -EIO; 221 222 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); 223 if (!tps) 224 return -ENOMEM; 225 226 tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config); 227 if (IS_ERR(tps->regmap)) { 228 error = PTR_ERR(tps->regmap); 229 dev_err(&client->dev, "Failed to allocate register map: %d\n", 230 error); 231 return error; 232 } 233 234 /* common for all regulators */ 235 tps->core_regulator = drv_data->core_regulator; 236 237 for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) { 238 /* Store regulator specific information */ 239 tps->info[i] = info; 240 241 tps->desc[i].name = info->name; 242 tps->desc[i].id = i; 243 tps->desc[i].n_voltages = info->table_len; 244 tps->desc[i].volt_table = info->table; 245 tps->desc[i].ops = (i > TPS65023_DCDC_3 ? 246 &tps65023_ldo_ops : &tps65023_dcdc_ops); 247 tps->desc[i].type = REGULATOR_VOLTAGE; 248 tps->desc[i].owner = THIS_MODULE; 249 250 tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL; 251 switch (i) { 252 case TPS65023_LDO_1: 253 tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; 254 tps->desc[i].vsel_mask = 0x07; 255 tps->desc[i].enable_mask = 1 << 1; 256 break; 257 case TPS65023_LDO_2: 258 tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; 259 tps->desc[i].vsel_mask = 0x70; 260 tps->desc[i].enable_mask = 1 << 2; 261 break; 262 default: /* DCDCx */ 263 tps->desc[i].enable_mask = 264 1 << (TPS65023_NUM_REGULATOR - i); 265 tps->desc[i].vsel_reg = TPS65023_REG_DEF_CORE; 266 tps->desc[i].vsel_mask = info->table_len - 1; 267 tps->desc[i].apply_reg = TPS65023_REG_CON_CTRL2; 268 tps->desc[i].apply_bit = TPS65023_REG_CTRL2_GO; 269 } 270 271 config.dev = &client->dev; 272 config.init_data = init_data; 273 config.driver_data = tps; 274 config.regmap = tps->regmap; 275 276 /* Register the regulators */ 277 rdev = devm_regulator_register(&client->dev, &tps->desc[i], 278 &config); 279 if (IS_ERR(rdev)) { 280 dev_err(&client->dev, "failed to register %s\n", 281 id->name); 282 return PTR_ERR(rdev); 283 } 284 285 /* Save regulator for cleanup */ 286 tps->rdev[i] = rdev; 287 } 288 289 i2c_set_clientdata(client, tps); 290 291 /* Enable setting output voltage by I2C */ 292 regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2, 293 TPS65023_REG_CTRL2_CORE_ADJ, 294 TPS65023_REG_CTRL2_CORE_ADJ); 295 296 return 0; 297 } 298 299 static const struct tps_info tps65020_regs[] = { 300 { 301 .name = "VDCDC1", 302 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 303 .table = DCDC_FIXED_3300000_VSEL_table, 304 }, 305 { 306 .name = "VDCDC2", 307 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 308 .table = DCDC_FIXED_1800000_VSEL_table, 309 }, 310 { 311 .name = "VDCDC3", 312 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 313 .table = VCORE_VSEL_table, 314 }, 315 { 316 .name = "LDO1", 317 .table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table), 318 .table = TPS65020_LDO_VSEL_table, 319 }, 320 { 321 .name = "LDO2", 322 .table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table), 323 .table = TPS65020_LDO_VSEL_table, 324 }, 325 }; 326 327 static const struct tps_info tps65021_regs[] = { 328 { 329 .name = "VDCDC1", 330 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 331 .table = DCDC_FIXED_3300000_VSEL_table, 332 }, 333 { 334 .name = "VDCDC2", 335 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 336 .table = DCDC_FIXED_1800000_VSEL_table, 337 }, 338 { 339 .name = "VDCDC3", 340 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 341 .table = VCORE_VSEL_table, 342 }, 343 { 344 .name = "LDO1", 345 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table), 346 .table = TPS65023_LDO1_VSEL_table, 347 }, 348 { 349 .name = "LDO2", 350 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table), 351 .table = TPS65023_LDO2_VSEL_table, 352 }, 353 }; 354 355 static const struct tps_info tps65023_regs[] = { 356 { 357 .name = "VDCDC1", 358 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 359 .table = VCORE_VSEL_table, 360 }, 361 { 362 .name = "VDCDC2", 363 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 364 .table = DCDC_FIXED_3300000_VSEL_table, 365 }, 366 { 367 .name = "VDCDC3", 368 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 369 .table = DCDC_FIXED_1800000_VSEL_table, 370 }, 371 { 372 .name = "LDO1", 373 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table), 374 .table = TPS65023_LDO1_VSEL_table, 375 }, 376 { 377 .name = "LDO2", 378 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table), 379 .table = TPS65023_LDO2_VSEL_table, 380 }, 381 }; 382 383 static struct tps_driver_data tps65020_drv_data = { 384 .info = tps65020_regs, 385 .core_regulator = TPS65023_DCDC_3, 386 }; 387 388 static struct tps_driver_data tps65021_drv_data = { 389 .info = tps65021_regs, 390 .core_regulator = TPS65023_DCDC_3, 391 }; 392 393 static struct tps_driver_data tps65023_drv_data = { 394 .info = tps65023_regs, 395 .core_regulator = TPS65023_DCDC_1, 396 }; 397 398 static const struct i2c_device_id tps_65023_id[] = { 399 {.name = "tps65023", 400 .driver_data = (unsigned long) &tps65023_drv_data}, 401 {.name = "tps65021", 402 .driver_data = (unsigned long) &tps65021_drv_data,}, 403 {.name = "tps65020", 404 .driver_data = (unsigned long) &tps65020_drv_data}, 405 { }, 406 }; 407 408 MODULE_DEVICE_TABLE(i2c, tps_65023_id); 409 410 static struct i2c_driver tps_65023_i2c_driver = { 411 .driver = { 412 .name = "tps65023", 413 .owner = THIS_MODULE, 414 }, 415 .probe = tps_65023_probe, 416 .id_table = tps_65023_id, 417 }; 418 419 static int __init tps_65023_init(void) 420 { 421 return i2c_add_driver(&tps_65023_i2c_driver); 422 } 423 subsys_initcall(tps_65023_init); 424 425 static void __exit tps_65023_cleanup(void) 426 { 427 i2c_del_driver(&tps_65023_i2c_driver); 428 } 429 module_exit(tps_65023_cleanup); 430 431 MODULE_AUTHOR("Texas Instruments"); 432 MODULE_DESCRIPTION("TPS65023 voltage regulator driver"); 433 MODULE_LICENSE("GPL v2"); 434