1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright (C) 2025 Andreas Kemnade 3 4 /* Datasheet: https://www.ti.com/lit/gpn/tps65185 */ 5 6 #include <linux/cleanup.h> 7 #include <linux/completion.h> 8 #include <linux/delay.h> 9 #include <linux/gpio/consumer.h> 10 #include <linux/i2c.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/hwmon.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/property.h> 16 #include <linux/regulator/consumer.h> 17 #include <linux/regulator/driver.h> 18 #include <linux/regulator/machine.h> 19 #include <linux/regmap.h> 20 21 #define TPS65185_REG_TMST_VALUE 0 22 #define TPS65185_REG_ENABLE 1 23 #define TPS65185_REG_VADJ 2 24 #define TPS65185_REG_VCOM1 3 25 #define TPS65185_REG_VCOM2 4 26 #define TPS65185_REG_INT_EN1 5 27 #define TPS65185_REG_INT_EN2 6 28 #define TPS65185_REG_INT1 7 29 #define TPS65185_REG_INT2 8 30 #define TPS65185_REG_TMST1 0xd 31 #define TPS65185_REG_TMST2 0xe 32 #define TPS65185_REG_PG 0xf 33 #define TPS65185_REG_REVID 0x10 34 35 #define TPS65185_READ_THERM BIT(7) 36 #define TPS65185_CONV_END BIT(5) 37 38 #define TPS65185_ENABLE_ACTIVE BIT(7) 39 #define TPS65185_ENABLE_STANDBY BIT(6) 40 41 #define PGOOD_TIMEOUT_MSECS 200 42 43 struct tps65185_data { 44 struct device *dev; 45 struct regmap *regmap; 46 struct gpio_desc *pgood_gpio; 47 struct gpio_desc *pwrup_gpio; 48 struct gpio_desc *vcom_ctrl_gpio; 49 struct gpio_desc *wakeup_gpio; 50 struct completion pgood_completion; 51 int pgood_irq; 52 struct completion tmst_completion; 53 }; 54 55 static const struct hwmon_channel_info *tps65185_info[] = { 56 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ), 57 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT), 58 NULL 59 }; 60 61 static int tps65185_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 62 u32 attr, int channel, long *temp) 63 { 64 struct tps65185_data *data = dev_get_drvdata(dev); 65 unsigned int val; 66 int ret; 67 68 reinit_completion(&data->tmst_completion); 69 /* start acquisition */ 70 regmap_update_bits(data->regmap, TPS65185_REG_TMST1, 71 TPS65185_READ_THERM, TPS65185_READ_THERM); 72 wait_for_completion_timeout(&data->tmst_completion, 73 msecs_to_jiffies(PGOOD_TIMEOUT_MSECS)); 74 ret = regmap_read(data->regmap, TPS65185_REG_TMST1, &val); 75 if (!(val & TPS65185_CONV_END)) 76 return -ETIMEDOUT; 77 78 ret = regmap_read(data->regmap, TPS65185_REG_TMST_VALUE, &val); 79 if (ret) 80 return ret; 81 82 *temp = (s8)val * 1000; 83 84 return 0; 85 } 86 87 static umode_t tps65185_hwmon_is_visible(const void *data, 88 enum hwmon_sensor_types type, 89 u32 attr, int channel) 90 { 91 return 0444; 92 } 93 94 static const struct hwmon_ops tps65185_hwmon_ops = { 95 .is_visible = tps65185_hwmon_is_visible, 96 .read = tps65185_hwmon_read, 97 }; 98 99 static const struct hwmon_chip_info tps65185_chip_info = { 100 .ops = &tps65185_hwmon_ops, 101 .info = tps65185_info, 102 }; 103 104 static bool tps65185_volatile_reg(struct device *dev, unsigned int reg) 105 { 106 switch (reg) { 107 case TPS65185_REG_TMST_VALUE: 108 case TPS65185_REG_ENABLE: 109 case TPS65185_REG_VCOM2: 110 case TPS65185_REG_INT1: 111 case TPS65185_REG_INT2: 112 case TPS65185_REG_TMST1: 113 return true; 114 default: 115 return false; 116 } 117 } 118 119 static const struct regmap_config regmap_config = { 120 .reg_bits = 8, 121 .val_bits = 8, 122 .max_register = 0x10, 123 .cache_type = REGCACHE_MAPLE, 124 .volatile_reg = tps65185_volatile_reg, 125 }; 126 127 static const struct regulator_ops tps65185_v3p3ops = { 128 .list_voltage = regulator_list_voltage_linear, 129 .enable = regulator_enable_regmap, 130 .disable = regulator_disable_regmap, 131 .is_enabled = regulator_is_enabled_regmap, 132 }; 133 134 static int tps65185_check_powergood(struct regulator_dev *rdev) 135 { 136 struct tps65185_data *data = rdev_get_drvdata(rdev); 137 138 return gpiod_get_value_cansleep(data->pgood_gpio); 139 } 140 141 static int tps65185_vposneg_get_voltage_sel(struct regulator_dev *rdev) 142 { 143 int ret; 144 145 ret = regulator_get_voltage_sel_regmap(rdev); 146 if (ret < 0) 147 return ret; 148 149 /* highest value is lowest voltage */ 150 return 6 - ret; 151 } 152 153 static int tps65185_vposneg_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector) 154 { 155 return regulator_set_voltage_sel_regmap(rdev, 6 - selector); 156 } 157 158 static irqreturn_t pgood_handler(int irq, void *dev_id) 159 { 160 struct tps65185_data *data = dev_id; 161 162 complete(&data->pgood_completion); 163 164 return IRQ_HANDLED; 165 } 166 167 static int tps65185_vposneg_enable(struct regulator_dev *rdev) 168 { 169 struct tps65185_data *data = rdev_get_drvdata(rdev); 170 int ret; 171 172 reinit_completion(&data->pgood_completion); 173 if (data->pwrup_gpio) 174 ret = gpiod_set_value_cansleep(data->pwrup_gpio, 1); 175 else 176 ret = regmap_update_bits(data->regmap, TPS65185_REG_ENABLE, 177 TPS65185_ENABLE_ACTIVE, 178 TPS65185_ENABLE_ACTIVE); 179 180 if (ret) 181 return ret; 182 183 dev_dbg(data->dev, "turning on..."); 184 wait_for_completion_timeout(&data->pgood_completion, 185 msecs_to_jiffies(PGOOD_TIMEOUT_MSECS)); 186 dev_dbg(data->dev, "turned on"); 187 ret = gpiod_get_value_cansleep(data->pgood_gpio); 188 if (ret < 0) 189 return ret; 190 if (!ret) 191 return -ETIMEDOUT; 192 193 return 0; 194 } 195 196 static int tps65185_vposneg_disable(struct regulator_dev *rdev) 197 { 198 struct tps65185_data *data = rdev_get_drvdata(rdev); 199 int ret; 200 201 if (data->pwrup_gpio) 202 ret = gpiod_set_value_cansleep(data->pwrup_gpio, 0); 203 else 204 ret = regmap_update_bits(data->regmap, TPS65185_REG_ENABLE, 205 TPS65185_ENABLE_STANDBY, 206 TPS65185_ENABLE_STANDBY); 207 208 return ret; 209 } 210 211 static int tps65185_vcom_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector) 212 { 213 struct tps65185_data *data = rdev_get_drvdata(rdev); 214 int ret; 215 216 ret = regmap_update_bits(data->regmap, TPS65185_REG_VCOM2, BIT(0), selector >> 8); 217 if (ret < 0) 218 return ret; 219 220 return regmap_write(data->regmap, TPS65185_REG_VCOM1, selector & 0xFF); 221 } 222 223 static int tps65185_vcom_get_voltage_sel(struct regulator_dev *rdev) 224 { 225 struct tps65185_data *data = rdev_get_drvdata(rdev); 226 int ret; 227 unsigned int sel, sel2; 228 229 ret = regmap_read(data->regmap, TPS65185_REG_VCOM1, &sel); 230 if (ret < 0) 231 return ret; 232 233 ret = regmap_read(data->regmap, TPS65185_REG_VCOM2, &sel2); 234 if (ret < 0) 235 return ret; 236 237 if (sel2 & BIT(0)) 238 sel |= 0x100; 239 240 return sel; 241 } 242 243 static const struct regulator_ops tps65185_vcom_ops = { 244 .list_voltage = regulator_list_voltage_linear, 245 .map_voltage = regulator_map_voltage_linear, 246 .set_voltage_sel = tps65185_vcom_set_voltage_sel, 247 .get_voltage_sel = tps65185_vcom_get_voltage_sel, 248 }; 249 250 static const struct regulator_ops tps65185_vposneg_ops = { 251 .list_voltage = regulator_list_voltage_linear, 252 .map_voltage = regulator_map_voltage_linear, 253 .enable = tps65185_vposneg_enable, 254 .disable = tps65185_vposneg_disable, 255 .is_enabled = tps65185_check_powergood, 256 .set_voltage_sel = tps65185_vposneg_set_voltage_sel, 257 .get_voltage_sel = tps65185_vposneg_get_voltage_sel, 258 }; 259 260 static const struct regulator_desc regulators[] = { 261 { 262 .name = "v3p3", 263 .of_match = of_match_ptr("v3p3"), 264 .regulators_node = of_match_ptr("regulators"), 265 .id = 0, 266 .ops = &tps65185_v3p3ops, 267 .type = REGULATOR_VOLTAGE, 268 .owner = THIS_MODULE, 269 .enable_reg = TPS65185_REG_ENABLE, 270 .enable_mask = BIT(5), 271 .n_voltages = 1, 272 .min_uV = 3300000, 273 }, 274 { 275 .name = "vposneg", 276 .of_match = of_match_ptr("vposneg"), 277 .regulators_node = of_match_ptr("regulators"), 278 .id = 1, 279 .ops = &tps65185_vposneg_ops, 280 .type = REGULATOR_VOLTAGE, 281 .owner = THIS_MODULE, 282 .n_voltages = 4, 283 .vsel_reg = TPS65185_REG_VADJ, 284 .vsel_mask = 0x7, 285 .min_uV = 14250000, 286 .uV_step = 250000, 287 } 288 }; 289 290 static const struct regulator_desc vcom_regulator_desc = { 291 .name = "vcom", 292 .of_match = of_match_ptr("vcom"), 293 .regulators_node = of_match_ptr("regulators"), 294 .supply_name = "vposneg", 295 .id = 2, 296 .ops = &tps65185_vcom_ops, 297 .type = REGULATOR_VOLTAGE, 298 .owner = THIS_MODULE, 299 .n_voltages = 511, 300 .min_uV = 0, 301 .uV_step = 10000, 302 }; 303 304 static irqreturn_t tps65185_irq_thread(int irq, void *dev_id) 305 { 306 struct tps65185_data *data = dev_id; 307 unsigned int int_status_1, int_status_2; 308 int ret; 309 310 /* read both status to have irq cleared */ 311 ret = regmap_read(data->regmap, TPS65185_REG_INT1, &int_status_1); 312 if (ret) 313 return IRQ_NONE; 314 315 ret = regmap_read(data->regmap, TPS65185_REG_INT2, &int_status_2); 316 if (ret) 317 return IRQ_NONE; 318 319 if (int_status_2 & BIT(0)) 320 complete(&data->tmst_completion); 321 322 dev_dbg(data->dev, "irq status %02x %02x\n", int_status_1, int_status_2); 323 324 if (int_status_1 || int_status_2) 325 return IRQ_HANDLED; 326 327 return IRQ_NONE; 328 } 329 330 static int tps65185_probe(struct i2c_client *client) 331 { 332 struct tps65185_data *data; 333 struct regulator_config config = { }; 334 struct regulator_dev *rdev; 335 int ret = 0; 336 int i; 337 338 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 339 if (!data) 340 return -ENOMEM; 341 342 data->regmap = devm_regmap_init_i2c(client, ®map_config); 343 if (IS_ERR(data->regmap)) 344 return dev_err_probe(&client->dev, PTR_ERR(data->regmap), 345 "failed to allocate regmap!\n"); 346 347 data->pgood_gpio = devm_gpiod_get(&client->dev, "pwr-good", GPIOD_IN); 348 if (IS_ERR(data->pgood_gpio)) 349 return dev_err_probe(&client->dev, 350 PTR_ERR(data->pgood_gpio), 351 "failed to get power good gpio\n"); 352 353 data->pgood_irq = gpiod_to_irq(data->pgood_gpio); 354 if (data->pgood_irq < 0) 355 return data->pgood_irq; 356 357 data->pwrup_gpio = devm_gpiod_get_optional(&client->dev, "enable", GPIOD_OUT_LOW); 358 if (IS_ERR(data->pwrup_gpio)) 359 return dev_err_probe(&client->dev, PTR_ERR(data->pwrup_gpio), 360 "failed to get pwrup gpio\n"); 361 362 data->wakeup_gpio = devm_gpiod_get_optional(&client->dev, "wakeup", GPIOD_OUT_HIGH); 363 if (IS_ERR(data->wakeup_gpio)) 364 return dev_err_probe(&client->dev, 365 PTR_ERR(data->wakeup_gpio), 366 "failed to get wakeup gpio\n"); 367 368 data->vcom_ctrl_gpio = devm_gpiod_get_optional(&client->dev, "vcom-ctrl", GPIOD_OUT_LOW); 369 if (IS_ERR(data->vcom_ctrl_gpio)) 370 return dev_err_probe(&client->dev, 371 PTR_ERR(data->vcom_ctrl_gpio), 372 "failed to get vcm ctrl gpio\n"); 373 374 ret = devm_regulator_get_enable(&client->dev, "vin"); 375 if (ret) 376 return dev_err_probe(&client->dev, ret, 377 "failed to get vin regulator\n"); 378 379 // TPS65185x PMIC for E Ink Vizplex Enabled Electronic Paper Display Chapter 7.6 Figure 2: 380 // "Minimum delay time between WAKEUP rising edge and IC ready to accept I2C transaction." 381 // https://www.ti.com/lit/ds/symlink/tps65185.pdf 382 usleep_range(1800, 3000); 383 384 data->dev = &client->dev; 385 i2c_set_clientdata(client, data); 386 387 init_completion(&data->pgood_completion); 388 init_completion(&data->tmst_completion); 389 390 ret = devm_request_threaded_irq(&client->dev, data->pgood_irq, NULL, 391 pgood_handler, 392 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 393 "PGOOD", data); 394 if (ret) 395 return ret; 396 397 if (client->irq) { 398 ret = devm_request_threaded_irq(&client->dev, client->irq, 399 NULL, tps65185_irq_thread, 400 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 401 "tps65185", data); 402 if (ret) 403 return ret; 404 } 405 406 ret = regmap_update_bits(data->regmap, TPS65185_REG_INT_EN2, BIT(0), BIT(0)); 407 if (ret) 408 return dev_err_probe(&client->dev, ret, 409 "failed to enable temp irq\n"); 410 411 config.driver_data = data; 412 config.dev = &client->dev; 413 config.regmap = data->regmap; 414 415 for (i = 0; i < ARRAY_SIZE(regulators); i++) { 416 rdev = devm_regulator_register(&client->dev, ®ulators[i], 417 &config); 418 if (IS_ERR(rdev)) 419 return dev_err_probe(&client->dev, PTR_ERR(rdev), 420 "failed to register %s regulator\n", 421 regulators[i].name); 422 } 423 424 config.ena_gpiod = data->vcom_ctrl_gpio; 425 rdev = devm_regulator_register(&client->dev, &vcom_regulator_desc, &config); 426 if (IS_ERR(rdev)) 427 return dev_err_probe(&client->dev, PTR_ERR(rdev), 428 "failed to register vcom regulator\n"); 429 430 if (IS_REACHABLE(CONFIG_HWMON)) { 431 struct device *hwmon_dev; 432 433 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "tps65185", data, 434 &tps65185_chip_info, NULL); 435 if (IS_ERR(hwmon_dev)) 436 dev_notice(&client->dev, "failed to register hwmon\n"); 437 } 438 439 return 0; 440 } 441 442 static const struct of_device_id tps65185_dt_ids[] = { 443 { 444 .compatible = "ti,tps65185", 445 }, { 446 /* sentinel */ 447 } 448 }; 449 MODULE_DEVICE_TABLE(of, tps65185_dt_ids); 450 451 static struct i2c_driver tps65185_i2c_driver = { 452 .driver = { 453 .name = "tps65185", 454 .of_match_table = tps65185_dt_ids, 455 }, 456 .probe = tps65185_probe, 457 }; 458 459 module_i2c_driver(tps65185_i2c_driver); 460 461 /* Module information */ 462 MODULE_DESCRIPTION("TPS65185 regulator driver"); 463 MODULE_LICENSE("GPL"); 464 465