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 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 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 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 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 215 return -EIO; 216 217 /** 218 * init_data points to array of regulator_init structures 219 * coming from the board-evm file. 220 */ 221 init_data = dev_get_platdata(&client->dev); 222 if (!init_data) 223 return -EIO; 224 225 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); 226 if (!tps) 227 return -ENOMEM; 228 229 tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config); 230 if (IS_ERR(tps->regmap)) { 231 error = PTR_ERR(tps->regmap); 232 dev_err(&client->dev, "Failed to allocate register map: %d\n", 233 error); 234 return error; 235 } 236 237 /* common for all regulators */ 238 tps->core_regulator = drv_data->core_regulator; 239 240 for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) { 241 /* Store regulator specific information */ 242 tps->info[i] = info; 243 244 tps->desc[i].name = info->name; 245 tps->desc[i].id = i; 246 tps->desc[i].n_voltages = info->table_len; 247 tps->desc[i].volt_table = info->table; 248 tps->desc[i].ops = (i > TPS65023_DCDC_3 ? 249 &tps65023_ldo_ops : &tps65023_dcdc_ops); 250 tps->desc[i].type = REGULATOR_VOLTAGE; 251 tps->desc[i].owner = THIS_MODULE; 252 253 tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL; 254 switch (i) { 255 case TPS65023_LDO_1: 256 tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; 257 tps->desc[i].vsel_mask = 0x07; 258 tps->desc[i].enable_mask = 1 << 1; 259 break; 260 case TPS65023_LDO_2: 261 tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; 262 tps->desc[i].vsel_mask = 0x70; 263 tps->desc[i].enable_mask = 1 << 2; 264 break; 265 default: /* DCDCx */ 266 tps->desc[i].enable_mask = 267 1 << (TPS65023_NUM_REGULATOR - i); 268 tps->desc[i].vsel_reg = TPS65023_REG_DEF_CORE; 269 tps->desc[i].vsel_mask = info->table_len - 1; 270 tps->desc[i].apply_reg = TPS65023_REG_CON_CTRL2; 271 tps->desc[i].apply_bit = TPS65023_REG_CTRL2_GO; 272 } 273 274 config.dev = &client->dev; 275 config.init_data = init_data; 276 config.driver_data = tps; 277 config.regmap = tps->regmap; 278 279 /* Register the regulators */ 280 rdev = regulator_register(&tps->desc[i], &config); 281 if (IS_ERR(rdev)) { 282 dev_err(&client->dev, "failed to register %s\n", 283 id->name); 284 error = PTR_ERR(rdev); 285 goto fail; 286 } 287 288 /* Save regulator for cleanup */ 289 tps->rdev[i] = rdev; 290 } 291 292 i2c_set_clientdata(client, tps); 293 294 /* Enable setting output voltage by I2C */ 295 regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2, 296 TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ); 297 298 return 0; 299 300 fail: 301 while (--i >= 0) 302 regulator_unregister(tps->rdev[i]); 303 return error; 304 } 305 306 static int tps_65023_remove(struct i2c_client *client) 307 { 308 struct tps_pmic *tps = i2c_get_clientdata(client); 309 int i; 310 311 for (i = 0; i < TPS65023_NUM_REGULATOR; i++) 312 regulator_unregister(tps->rdev[i]); 313 return 0; 314 } 315 316 static const struct tps_info tps65020_regs[] = { 317 { 318 .name = "VDCDC1", 319 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 320 .table = DCDC_FIXED_3300000_VSEL_table, 321 }, 322 { 323 .name = "VDCDC2", 324 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 325 .table = DCDC_FIXED_1800000_VSEL_table, 326 }, 327 { 328 .name = "VDCDC3", 329 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 330 .table = VCORE_VSEL_table, 331 }, 332 { 333 .name = "LDO1", 334 .table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table), 335 .table = TPS65020_LDO_VSEL_table, 336 }, 337 { 338 .name = "LDO2", 339 .table_len = ARRAY_SIZE(TPS65020_LDO_VSEL_table), 340 .table = TPS65020_LDO_VSEL_table, 341 }, 342 }; 343 344 static const struct tps_info tps65021_regs[] = { 345 { 346 .name = "VDCDC1", 347 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 348 .table = DCDC_FIXED_3300000_VSEL_table, 349 }, 350 { 351 .name = "VDCDC2", 352 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 353 .table = DCDC_FIXED_1800000_VSEL_table, 354 }, 355 { 356 .name = "VDCDC3", 357 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 358 .table = VCORE_VSEL_table, 359 }, 360 { 361 .name = "LDO1", 362 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table), 363 .table = TPS65023_LDO1_VSEL_table, 364 }, 365 { 366 .name = "LDO2", 367 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table), 368 .table = TPS65023_LDO2_VSEL_table, 369 }, 370 }; 371 372 static const struct tps_info tps65023_regs[] = { 373 { 374 .name = "VDCDC1", 375 .table_len = ARRAY_SIZE(VCORE_VSEL_table), 376 .table = VCORE_VSEL_table, 377 }, 378 { 379 .name = "VDCDC2", 380 .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table), 381 .table = DCDC_FIXED_3300000_VSEL_table, 382 }, 383 { 384 .name = "VDCDC3", 385 .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table), 386 .table = DCDC_FIXED_1800000_VSEL_table, 387 }, 388 { 389 .name = "LDO1", 390 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table), 391 .table = TPS65023_LDO1_VSEL_table, 392 }, 393 { 394 .name = "LDO2", 395 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table), 396 .table = TPS65023_LDO2_VSEL_table, 397 }, 398 }; 399 400 static struct tps_driver_data tps65020_drv_data = { 401 .info = tps65020_regs, 402 .core_regulator = TPS65023_DCDC_3, 403 }; 404 405 static struct tps_driver_data tps65021_drv_data = { 406 .info = tps65021_regs, 407 .core_regulator = TPS65023_DCDC_3, 408 }; 409 410 static struct tps_driver_data tps65023_drv_data = { 411 .info = tps65023_regs, 412 .core_regulator = TPS65023_DCDC_1, 413 }; 414 415 static const struct i2c_device_id tps_65023_id[] = { 416 {.name = "tps65023", 417 .driver_data = (unsigned long) &tps65023_drv_data}, 418 {.name = "tps65021", 419 .driver_data = (unsigned long) &tps65021_drv_data,}, 420 {.name = "tps65020", 421 .driver_data = (unsigned long) &tps65020_drv_data}, 422 { }, 423 }; 424 425 MODULE_DEVICE_TABLE(i2c, tps_65023_id); 426 427 static struct i2c_driver tps_65023_i2c_driver = { 428 .driver = { 429 .name = "tps65023", 430 .owner = THIS_MODULE, 431 }, 432 .probe = tps_65023_probe, 433 .remove = tps_65023_remove, 434 .id_table = tps_65023_id, 435 }; 436 437 static int __init tps_65023_init(void) 438 { 439 return i2c_add_driver(&tps_65023_i2c_driver); 440 } 441 subsys_initcall(tps_65023_init); 442 443 static void __exit tps_65023_cleanup(void) 444 { 445 i2c_del_driver(&tps_65023_i2c_driver); 446 } 447 module_exit(tps_65023_cleanup); 448 449 MODULE_AUTHOR("Texas Instruments"); 450 MODULE_DESCRIPTION("TPS65023 voltage regulator driver"); 451 MODULE_LICENSE("GPL v2"); 452