drivers/power/supply/sc2731_charger.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2018 Spreadtrum Communications Inc.
   3
   4 #include <linux/module.h>
   5 #include <linux/platform_device.h>
   6 #include <linux/power_supply.h>
   7 #include <linux/usb/phy.h>
   8 #include <linux/regmap.h>
   9 #include <linux/notifier.h>
  10 #include <linux/of.h>
  11
  12 /* PMIC global registers definition */
  13 #define SC2731_CHARGE_STATUS            0xedc
  14 #define SC2731_CHARGE_FULL              BIT(4)
  15 #define SC2731_MODULE_EN1               0xc0c
  16 #define SC2731_CHARGE_EN                BIT(5)
  17
  18 /* SC2731 switch charger registers definition */
  19 #define SC2731_CHG_CFG0                 0x0
  20 #define SC2731_CHG_CFG1                 0x4
  21 #define SC2731_CHG_CFG2                 0x8
  22 #define SC2731_CHG_CFG3                 0xc
  23 #define SC2731_CHG_CFG4                 0x10
  24 #define SC2731_CHG_CFG5                 0x28
  25
  26 /* SC2731_CHG_CFG0 register definition */
  27 #define SC2731_PRECHG_RNG_SHIFT         11
  28 #define SC2731_PRECHG_RNG_MASK          GENMASK(12, 11)
  29
  30 #define SC2731_TERMINATION_VOL_MASK     GENMASK(2, 1)
  31 #define SC2731_TERMINATION_VOL_SHIFT    1
  32 #define SC2731_TERMINATION_VOL_CAL_MASK GENMASK(8, 3)
  33 #define SC2731_TERMINATION_VOL_CAL_SHIFT        3
  34 #define SC2731_TERMINATION_CUR_MASK     GENMASK(2, 0)
  35
  36 #define SC2731_CC_EN                    BIT(13)
  37 #define SC2731_CHARGER_PD               BIT(0)
  38
  39 /* SC2731_CHG_CFG1 register definition */
  40 #define SC2731_CUR_MASK                 GENMASK(5, 0)
  41
  42 /* SC2731_CHG_CFG5 register definition */
  43 #define SC2731_CUR_LIMIT_SHIFT          8
  44 #define SC2731_CUR_LIMIT_MASK           GENMASK(9, 8)
  45
  46 /* Default current definition (unit is mA) */
  47 #define SC2731_CURRENT_LIMIT_100        100
  48 #define SC2731_CURRENT_LIMIT_500        500
  49 #define SC2731_CURRENT_LIMIT_900        900
  50 #define SC2731_CURRENT_LIMIT_2000       2000
  51 #define SC2731_CURRENT_PRECHG           450
  52 #define SC2731_CURRENT_STEP             50
  53
  54 struct sc2731_charger_info {
  55         struct device *dev;
  56         struct regmap *regmap;
  57         struct usb_phy *usb_phy;
  58         struct notifier_block usb_notify;
  59         struct power_supply *psy_usb;
  60         struct mutex lock;
  61         bool charging;
  62         u32 base;
  63 };
  64
  65 static void sc2731_charger_stop_charge(struct sc2731_charger_info *info)
  66 {
  67         regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  68                            SC2731_CC_EN, 0);
  69
  70         regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  71                            SC2731_CHARGER_PD, SC2731_CHARGER_PD);
  72 }
  73
  74 static int sc2731_charger_start_charge(struct sc2731_charger_info *info)
  75 {
  76         int ret;
  77
  78         /* Enable charger constant current mode */
  79         ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  80                                  SC2731_CC_EN, SC2731_CC_EN);
  81         if (ret)
  82                 return ret;
  83
  84         /* Start charging */
  85         return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  86                                   SC2731_CHARGER_PD, 0);
  87 }
  88
  89 static int sc2731_charger_set_current_limit(struct sc2731_charger_info *info,
  90                                             u32 limit)
  91 {
  92         u32 val;
  93
  94         if (limit <= SC2731_CURRENT_LIMIT_100)
  95                 val = 0;
  96         else if (limit <= SC2731_CURRENT_LIMIT_500)
  97                 val = 3;
  98         else if (limit <= SC2731_CURRENT_LIMIT_900)
  99                 val = 2;
 100         else
 101                 val = 1;
 102
 103         return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG5,
 104                                   SC2731_CUR_LIMIT_MASK,
 105                                   val << SC2731_CUR_LIMIT_SHIFT);
 106 }
 107
 108 static int sc2731_charger_set_current(struct sc2731_charger_info *info, u32 cur)
 109 {
 110         u32 val;
 111         int ret;
 112
 113         if (cur > SC2731_CURRENT_LIMIT_2000)
 114                 cur = SC2731_CURRENT_LIMIT_2000;
 115         else if (cur < SC2731_CURRENT_PRECHG)
 116                 cur = SC2731_CURRENT_PRECHG;
 117
 118         /* Calculate the step value, each step is 50 mA */
 119         val = (cur - SC2731_CURRENT_PRECHG) / SC2731_CURRENT_STEP;
 120
 121         /* Set pre-charge current as 450 mA */
 122         ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
 123                                  SC2731_PRECHG_RNG_MASK,
 124                                  0x3 << SC2731_PRECHG_RNG_SHIFT);
 125         if (ret)
 126                 return ret;
 127
 128         return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG1,
 129                                   SC2731_CUR_MASK, val);
 130 }
 131
 132 static int sc2731_charger_get_status(struct sc2731_charger_info *info)
 133 {
 134         u32 val;
 135         int ret;
 136
 137         ret = regmap_read(info->regmap, SC2731_CHARGE_STATUS, &val);
 138         if (ret)
 139                 return ret;
 140
 141         if (val & SC2731_CHARGE_FULL)
 142                 return POWER_SUPPLY_STATUS_FULL;
 143
 144         return POWER_SUPPLY_STATUS_CHARGING;
 145 }
 146
 147 static int sc2731_charger_get_current(struct sc2731_charger_info *info,
 148                                       u32 *cur)
 149 {
 150         int ret;
 151         u32 val;
 152
 153         ret = regmap_read(info->regmap, info->base + SC2731_CHG_CFG1, &val);
 154         if (ret)
 155                 return ret;
 156
 157         val &= SC2731_CUR_MASK;
 158         *cur = val * SC2731_CURRENT_STEP + SC2731_CURRENT_PRECHG;
 159
 160         return 0;
 161 }
 162
 163 static int sc2731_charger_get_current_limit(struct sc2731_charger_info *info,
 164                                             u32 *cur)
 165 {
 166         int ret;
 167         u32 val;
 168
 169         ret = regmap_read(info->regmap, info->base + SC2731_CHG_CFG5, &val);
 170         if (ret)
 171                 return ret;
 172
 173         val = (val & SC2731_CUR_LIMIT_MASK) >> SC2731_CUR_LIMIT_SHIFT;
 174
 175         switch (val) {
 176         case 0:
 177                 *cur = SC2731_CURRENT_LIMIT_100;
 178                 break;
 179
 180         case 1:
 181                 *cur = SC2731_CURRENT_LIMIT_2000;
 182                 break;
 183
 184         case 2:
 185                 *cur = SC2731_CURRENT_LIMIT_900;
 186                 break;
 187
 188         case 3:
 189                 *cur = SC2731_CURRENT_LIMIT_500;
 190                 break;
 191
 192         default:
 193                 return -EINVAL;
 194         }
 195
 196         return 0;
 197 }
 198
 199 static int
 200 sc2731_charger_usb_set_property(struct power_supply *psy,
 201                                 enum power_supply_property psp,
 202                                 const union power_supply_propval *val)
 203 {
 204         struct sc2731_charger_info *info = power_supply_get_drvdata(psy);
 205         int ret;
 206
 207         mutex_lock(&info->lock);
 208
 209         if (!info->charging) {
 210                 mutex_unlock(&info->lock);
 211                 return -ENODEV;
 212         }
 213
 214         switch (psp) {
 215         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 216                 ret = sc2731_charger_set_current(info, val->intval / 1000);
 217                 if (ret < 0)
 218                         dev_err(info->dev, "set charge current failed\n");
 219                 break;
 220
 221         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 222                 ret = sc2731_charger_set_current_limit(info,
 223                                                        val->intval / 1000);
 224                 if (ret < 0)
 225                         dev_err(info->dev, "set input current limit failed\n");
 226                 break;
 227
 228         default:
 229                 ret = -EINVAL;
 230         }
 231
 232         mutex_unlock(&info->lock);
 233         return ret;
 234 }
 235
 236 static int sc2731_charger_usb_get_property(struct power_supply *psy,
 237                                            enum power_supply_property psp,
 238                                            union power_supply_propval *val)
 239 {
 240         struct sc2731_charger_info *info = power_supply_get_drvdata(psy);
 241         int ret = 0;
 242         u32 cur;
 243
 244         mutex_lock(&info->lock);
 245
 246         switch (psp) {
 247         case POWER_SUPPLY_PROP_STATUS:
 248                 if (info->charging)
 249                         val->intval = sc2731_charger_get_status(info);
 250                 else
 251                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 252                 break;
 253
 254         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 255                 if (!info->charging) {
 256                         val->intval = 0;
 257                 } else {
 258                         ret = sc2731_charger_get_current(info, &cur);
 259                         if (ret)
 260                                 goto out;
 261
 262                         val->intval = cur * 1000;
 263                 }
 264                 break;
 265
 266         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 267                 if (!info->charging) {
 268                         val->intval = 0;
 269                 } else {
 270                         ret = sc2731_charger_get_current_limit(info, &cur);
 271                         if (ret)
 272                                 goto out;
 273
 274                         val->intval = cur * 1000;
 275                 }
 276                 break;
 277
 278         default:
 279                 ret = -EINVAL;
 280         }
 281
 282 out:
 283         mutex_unlock(&info->lock);
 284         return ret;
 285 }
 286
 287 static int sc2731_charger_property_is_writeable(struct power_supply *psy,
 288                                                 enum power_supply_property psp)
 289 {
 290         int ret;
 291
 292         switch (psp) {
 293         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 294         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 295                 ret = 1;
 296                 break;
 297
 298         default:
 299                 ret = 0;
 300         }
 301
 302         return ret;
 303 }
 304
 305 static enum power_supply_property sc2731_usb_props[] = {
 306         POWER_SUPPLY_PROP_STATUS,
 307         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 308         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 309 };
 310
 311 static const struct power_supply_desc sc2731_charger_desc = {
 312         .name                   = "sc2731_charger",
 313         .type                   = POWER_SUPPLY_TYPE_USB,
 314         .properties             = sc2731_usb_props,
 315         .num_properties         = ARRAY_SIZE(sc2731_usb_props),
 316         .get_property           = sc2731_charger_usb_get_property,
 317         .set_property           = sc2731_charger_usb_set_property,
 318         .property_is_writeable  = sc2731_charger_property_is_writeable,
 319 };
 320
 321 static int sc2731_charger_usb_change(struct notifier_block *nb,
 322                                      unsigned long limit, void *data)
 323 {
 324         struct sc2731_charger_info *info =
 325                 container_of(nb, struct sc2731_charger_info, usb_notify);
 326         int ret = 0;
 327
 328         mutex_lock(&info->lock);
 329
 330         if (limit > 0) {
 331                 /* set current limitation and start to charge */
 332                 ret = sc2731_charger_set_current_limit(info, limit);
 333                 if (ret)
 334                         goto out;
 335
 336                 ret = sc2731_charger_set_current(info, limit);
 337                 if (ret)
 338                         goto out;
 339
 340                 ret = sc2731_charger_start_charge(info);
 341                 if (ret)
 342                         goto out;
 343
 344                 info->charging = true;
 345         } else {
 346                 /* Stop charging */
 347                 info->charging = false;
 348                 sc2731_charger_stop_charge(info);
 349         }
 350
 351 out:
 352         mutex_unlock(&info->lock);
 353         return ret;
 354 }
 355
 356 static int sc2731_charger_hw_init(struct sc2731_charger_info *info)
 357 {
 358         struct power_supply_battery_info bat_info = { };
 359         u32 term_currrent, term_voltage, cur_val, vol_val;
 360         int ret;
 361
 362         /* Enable charger module */
 363         ret = regmap_update_bits(info->regmap, SC2731_MODULE_EN1,
 364                                  SC2731_CHARGE_EN, SC2731_CHARGE_EN);
 365         if (ret)
 366                 return ret;
 367
 368         ret = power_supply_get_battery_info(info->psy_usb, &bat_info);
 369         if (ret) {
 370                 dev_warn(info->dev, "no battery information is supplied\n");
 371
 372                 /*
 373                  * If no battery information is supplied, we should set
 374                  * default charge termination current to 120 mA, and default
 375                  * charge termination voltage to 4.35V.
 376                  */
 377                 cur_val = 0x2;
 378                 vol_val = 0x1;
 379         } else {
 380                 term_currrent = bat_info.charge_term_current_ua / 1000;
 381
 382                 if (term_currrent <= 90)
 383                         cur_val = 0;
 384                 else if (term_currrent >= 265)
 385                         cur_val = 0x7;
 386                 else
 387                         cur_val = ((term_currrent - 90) / 25) + 1;
 388
 389                 term_voltage = bat_info.constant_charge_voltage_max_uv / 1000;
 390
 391                 if (term_voltage > 4500)
 392                         term_voltage = 4500;
 393
 394                 if (term_voltage > 4200)
 395                         vol_val = (term_voltage - 4200) / 100;
 396                 else
 397                         vol_val = 0;
 398         }
 399
 400         /* Set charge termination current */
 401         ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG2,
 402                                  SC2731_TERMINATION_CUR_MASK, cur_val);
 403         if (ret)
 404                 goto error;
 405
 406         /* Set charge termination voltage */
 407         ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
 408                                  SC2731_TERMINATION_VOL_MASK |
 409                                  SC2731_TERMINATION_VOL_CAL_MASK,
 410                                  (vol_val << SC2731_TERMINATION_VOL_SHIFT) |
 411                                  (0x6 << SC2731_TERMINATION_VOL_CAL_SHIFT));
 412         if (ret)
 413                 goto error;
 414
 415         return 0;
 416
 417 error:
 418         regmap_update_bits(info->regmap, SC2731_MODULE_EN1, SC2731_CHARGE_EN, 0);
 419         return ret;
 420 }
 421
 422 static int sc2731_charger_probe(struct platform_device *pdev)
 423 {
 424         struct device_node *np = pdev->dev.of_node;
 425         struct sc2731_charger_info *info;
 426         struct power_supply_config charger_cfg = { };
 427         int ret;
 428
 429         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 430         if (!info)
 431                 return -ENOMEM;
 432
 433         mutex_init(&info->lock);
 434         info->dev = &pdev->dev;
 435
 436         info->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 437         if (!info->regmap) {
 438                 dev_err(&pdev->dev, "failed to get charger regmap\n");
 439                 return -ENODEV;
 440         }
 441
 442         ret = of_property_read_u32(np, "reg", &info->base);
 443         if (ret) {
 444                 dev_err(&pdev->dev, "failed to get register address\n");
 445                 return -ENODEV;
 446         }
 447
 448         charger_cfg.drv_data = info;
 449         charger_cfg.of_node = np;
 450         info->psy_usb = devm_power_supply_register(&pdev->dev,
 451                                                    &sc2731_charger_desc,
 452                                                    &charger_cfg);
 453         if (IS_ERR(info->psy_usb)) {
 454                 dev_err(&pdev->dev, "failed to register power supply\n");
 455                 return PTR_ERR(info->psy_usb);
 456         }
 457
 458         ret = sc2731_charger_hw_init(info);
 459         if (ret)
 460                 return ret;
 461
 462         info->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "phys", 0);
 463         if (IS_ERR(info->usb_phy)) {
 464                 dev_err(&pdev->dev, "failed to find USB phy\n");
 465                 return PTR_ERR(info->usb_phy);
 466         }
 467
 468         info->usb_notify.notifier_call = sc2731_charger_usb_change;
 469         ret = usb_register_notifier(info->usb_phy, &info->usb_notify);
 470         if (ret) {
 471                 dev_err(&pdev->dev, "failed to register notifier: %d\n", ret);
 472                 return ret;
 473         }
 474
 475         return 0;
 476 }
 477
 478 static int sc2731_charger_remove(struct platform_device *pdev)
 479 {
 480         struct sc2731_charger_info *info = platform_get_drvdata(pdev);
 481
 482         usb_unregister_notifier(info->usb_phy, &info->usb_notify);
 483
 484         return 0;
 485 }
 486
 487 static const struct of_device_id sc2731_charger_of_match[] = {
 488         { .compatible = "sprd,sc2731-charger", },
 489         { }
 490 };
 491
 492 static struct platform_driver sc2731_charger_driver = {
 493         .driver = {
 494                 .name = "sc2731-charger",
 495                 .of_match_table = sc2731_charger_of_match,
 496         },
 497         .probe = sc2731_charger_probe,
 498         .remove = sc2731_charger_remove,
 499 };
 500
 501 module_platform_driver(sc2731_charger_driver);
 502
 503 MODULE_DESCRIPTION("Spreadtrum SC2731 Charger Driver");
 504 MODULE_LICENSE("GPL v2");