drivers/power/supply/ltc4162-l-charger.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Driver for Analog Devices (Linear Technology) LTC4162-L charger IC.
   4  *  Copyright (C) 2020, Topic Embedded Products
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/delay.h>
   9 #include <linux/of.h>
  10 #include <linux/pm_runtime.h>
  11 #include <linux/power_supply.h>
  12 #include <linux/i2c.h>
  13 #include <linux/regmap.h>
  14
  15 /* Registers (names based on what datasheet uses) */
  16 #define LTC4162L_EN_LIMIT_ALERTS_REG            0x0D
  17 #define LTC4162L_EN_CHARGER_STATE_ALERTS_REG    0x0E
  18 #define LTC4162L_EN_CHARGE_STATUS_ALERTS_REG    0x0F
  19 #define LTC4162L_CONFIG_BITS_REG                0x14
  20 #define LTC4162L_IIN_LIMIT_TARGET               0x15
  21 #define LTC4162L_ARM_SHIP_MODE                  0x19
  22 #define LTC4162L_CHARGE_CURRENT_SETTING         0X1A
  23 #define LTC4162L_VCHARGE_SETTING                0X1B
  24 #define LTC4162L_C_OVER_X_THRESHOLD             0x1C
  25 #define LTC4162L_MAX_CV_TIME                    0X1D
  26 #define LTC4162L_MAX_CHARGE_TIME                0X1E
  27 #define LTC4162L_CHARGER_CONFIG_BITS            0x29
  28 #define LTC4162L_CHARGER_STATE                  0x34
  29 #define LTC4162L_CHARGE_STATUS                  0x35
  30 #define LTC4162L_LIMIT_ALERTS_REG               0x36
  31 #define LTC4162L_CHARGER_STATE_ALERTS_REG       0x37
  32 #define LTC4162L_CHARGE_STATUS_ALERTS_REG       0x38
  33 #define LTC4162L_SYSTEM_STATUS_REG              0x39
  34 #define LTC4162L_VBAT                           0x3A
  35 #define LTC4162L_VIN                            0x3B
  36 #define LTC4162L_VOUT                           0x3C
  37 #define LTC4162L_IBAT                           0x3D
  38 #define LTC4162L_IIN                            0x3E
  39 #define LTC4162L_DIE_TEMPERATURE                0x3F
  40 #define LTC4162L_THERMISTOR_VOLTAGE             0x40
  41 #define LTC4162L_BSR                            0x41
  42 #define LTC4162L_JEITA_REGION                   0x42
  43 #define LTC4162L_CHEM_CELLS_REG                 0x43
  44 #define LTC4162L_ICHARGE_DAC                    0x44
  45 #define LTC4162L_VCHARGE_DAC                    0x45
  46 #define LTC4162L_IIN_LIMIT_DAC                  0x46
  47 #define LTC4162L_VBAT_FILT                      0x47
  48 #define LTC4162L_INPUT_UNDERVOLTAGE_DAC         0x4B
  49
  50 /* Enumeration as in datasheet. Individual bits are mutually exclusive. */
  51 enum ltc4162l_state {
  52         battery_detection = 2048,
  53         charger_suspended = 256,
  54         precharge = 128,   /* trickle on low bat voltage */
  55         cc_cv_charge = 64, /* normal charge */
  56         ntc_pause = 32,
  57         timer_term = 16,
  58         c_over_x_term = 8, /* battery is full */
  59         max_charge_time_fault = 4,
  60         bat_missing_fault = 2,
  61         bat_short_fault = 1
  62 };
  63
  64 /* Individual bits are mutually exclusive. Only active in charging states.*/
  65 enum ltc4162l_charge_status {
  66         ilim_reg_active = 32,
  67         thermal_reg_active = 16,
  68         vin_uvcl_active = 8,
  69         iin_limit_active = 4,
  70         constant_current = 2,
  71         constant_voltage = 1,
  72         charger_off = 0
  73 };
  74
  75 /* Magic number to write to ARM_SHIP_MODE register */
  76 #define LTC4162L_ARM_SHIP_MODE_MAGIC 21325
  77
  78 struct ltc4162l_info {
  79         struct i2c_client       *client;
  80         struct regmap           *regmap;
  81         struct power_supply     *charger;
  82         u32 rsnsb;      /* Series resistor that sets charge current, microOhm */
  83         u32 rsnsi;      /* Series resistor to measure input current, microOhm */
  84         u8 cell_count;  /* Number of connected cells, 0 while unknown */
  85 };
  86
  87 static u8 ltc4162l_get_cell_count(struct ltc4162l_info *info)
  88 {
  89         int ret;
  90         unsigned int val;
  91
  92         /* Once read successfully */
  93         if (info->cell_count)
  94                 return info->cell_count;
  95
  96         ret = regmap_read(info->regmap, LTC4162L_CHEM_CELLS_REG, &val);
  97         if (ret)
  98                 return 0;
  99
 100         /* Lower 4 bits is the cell count, or 0 if the chip doesn't know yet */
 101         val &= 0x0f;
 102         if (!val)
 103                 return 0;
 104
 105         /* Once determined, keep the value */
 106         info->cell_count = val;
 107
 108         return val;
 109 };
 110
 111 /* Convert enum value to POWER_SUPPLY_STATUS value */
 112 static int ltc4162l_state_decode(enum ltc4162l_state value)
 113 {
 114         switch (value) {
 115         case precharge:
 116         case cc_cv_charge:
 117                 return POWER_SUPPLY_STATUS_CHARGING;
 118         case c_over_x_term:
 119                 return POWER_SUPPLY_STATUS_FULL;
 120         case bat_missing_fault:
 121         case bat_short_fault:
 122                 return POWER_SUPPLY_STATUS_UNKNOWN;
 123         default:
 124                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 125         }
 126 };
 127
 128 static int ltc4162l_get_status(struct ltc4162l_info *info,
 129                                union power_supply_propval *val)
 130 {
 131         unsigned int regval;
 132         int ret;
 133
 134         ret = regmap_read(info->regmap, LTC4162L_CHARGER_STATE, &regval);
 135         if (ret) {
 136                 dev_err(&info->client->dev, "Failed to read CHARGER_STATE\n");
 137                 return ret;
 138         }
 139
 140         val->intval = ltc4162l_state_decode(regval);
 141
 142         return 0;
 143 }
 144
 145 static int ltc4162l_charge_status_decode(enum ltc4162l_charge_status value)
 146 {
 147         if (!value)
 148                 return POWER_SUPPLY_CHARGE_TYPE_NONE;
 149
 150         /* constant voltage/current and input_current limit are "fast" modes */
 151         if (value <= iin_limit_active)
 152                 return POWER_SUPPLY_CHARGE_TYPE_FAST;
 153
 154         /* Anything that's not fast we'll return as trickle */
 155         return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
 156 }
 157
 158 static int ltc4162l_get_charge_type(struct ltc4162l_info *info,
 159                                     union power_supply_propval *val)
 160 {
 161         unsigned int regval;
 162         int ret;
 163
 164         ret = regmap_read(info->regmap, LTC4162L_CHARGE_STATUS, &regval);
 165         if (ret)
 166                 return ret;
 167
 168         val->intval = ltc4162l_charge_status_decode(regval);
 169
 170         return 0;
 171 }
 172
 173 static int ltc4162l_state_to_health(enum ltc4162l_state value)
 174 {
 175         switch (value) {
 176         case ntc_pause:
 177                 return POWER_SUPPLY_HEALTH_OVERHEAT;
 178         case timer_term:
 179                 return POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 180         case max_charge_time_fault:
 181                 return POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
 182         case bat_missing_fault:
 183                 return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 184         case bat_short_fault:
 185                 return POWER_SUPPLY_HEALTH_DEAD;
 186         default:
 187                 return POWER_SUPPLY_HEALTH_GOOD;
 188         }
 189 }
 190
 191 static int ltc4162l_get_health(struct ltc4162l_info *info,
 192                                union power_supply_propval *val)
 193 {
 194         unsigned int regval;
 195         int ret;
 196
 197         ret = regmap_read(info->regmap, LTC4162L_CHARGER_STATE, &regval);
 198         if (ret)
 199                 return ret;
 200
 201         val->intval = ltc4162l_state_to_health(regval);
 202
 203         return 0;
 204 }
 205
 206 static int ltc4162l_get_online(struct ltc4162l_info *info,
 207                                union power_supply_propval *val)
 208 {
 209         unsigned int regval;
 210         int ret;
 211
 212         ret = regmap_read(info->regmap, LTC4162L_SYSTEM_STATUS_REG, &regval);
 213         if (ret)
 214                 return ret;
 215
 216         /* BIT(2) indicates if input voltage is sufficient to charge */
 217         val->intval = !!(regval & BIT(2));
 218
 219         return 0;
 220 }
 221
 222 static int ltc4162l_get_vbat(struct ltc4162l_info *info,
 223                                   unsigned int reg,
 224                                   union power_supply_propval *val)
 225 {
 226         unsigned int regval;
 227         int ret;
 228
 229         ret = regmap_read(info->regmap, reg, &regval);
 230         if (ret)
 231                 return ret;
 232
 233         /* cell_count × 192.4μV/LSB */
 234         regval *= 1924;
 235         regval *= ltc4162l_get_cell_count(info);
 236         regval /= 10;
 237         val->intval = regval;
 238
 239         return 0;
 240 }
 241
 242 static int ltc4162l_get_ibat(struct ltc4162l_info *info,
 243                              union power_supply_propval *val)
 244 {
 245         unsigned int regval;
 246         int ret;
 247
 248         ret = regmap_read(info->regmap, LTC4162L_IBAT, &regval);
 249         if (ret)
 250                 return ret;
 251
 252         /* Signed 16-bit number, 1.466μV / RSNSB amperes/LSB. */
 253         ret = (s16)(regval & 0xFFFF);
 254         val->intval = 100 * mult_frac(ret, 14660, (int)info->rsnsb);
 255
 256         return 0;
 257 }
 258
 259
 260 static int ltc4162l_get_input_voltage(struct ltc4162l_info *info,
 261                                       union power_supply_propval *val)
 262 {
 263         unsigned int regval;
 264         int ret;
 265
 266         ret = regmap_read(info->regmap, LTC4162L_VIN, &regval);
 267         if (ret)
 268                 return ret;
 269
 270         /* 1.649mV/LSB */
 271         val->intval =  regval * 1694;
 272
 273         return 0;
 274 }
 275
 276 static int ltc4162l_get_input_current(struct ltc4162l_info *info,
 277                                       union power_supply_propval *val)
 278 {
 279         unsigned int regval;
 280         int ret;
 281
 282         ret = regmap_read(info->regmap, LTC4162L_IIN, &regval);
 283         if (ret)
 284                 return ret;
 285
 286         /* Signed 16-bit number, 1.466μV / RSNSI amperes/LSB. */
 287         ret = (s16)(regval & 0xFFFF);
 288         ret *= 14660;
 289         ret /= info->rsnsi;
 290         ret *= 100;
 291
 292         val->intval = ret;
 293
 294         return 0;
 295 }
 296
 297 static int ltc4162l_get_icharge(struct ltc4162l_info *info,
 298                                 unsigned int reg,
 299                                 union power_supply_propval *val)
 300 {
 301         unsigned int regval;
 302         int ret;
 303
 304         ret = regmap_read(info->regmap, reg, &regval);
 305         if (ret)
 306                 return ret;
 307
 308         regval &= BIT(6) - 1; /* Only the lower 5 bits */
 309
 310         /* The charge current servo level: (icharge_dac + 1) × 1mV/RSNSB */
 311         ++regval;
 312         val->intval = 10000u * mult_frac(regval, 100000u, info->rsnsb);
 313
 314         return 0;
 315 }
 316
 317 static int ltc4162l_set_icharge(struct ltc4162l_info *info,
 318                                 unsigned int reg,
 319                                 unsigned int value)
 320 {
 321         value = mult_frac(value, info->rsnsb, 100000u);
 322         value /= 10000u;
 323
 324         /* Round to lowest possible */
 325         if (value)
 326                 --value;
 327
 328         if (value > 31)
 329                 return -EINVAL;
 330
 331         return regmap_write(info->regmap, reg, value);
 332 }
 333
 334
 335 static int ltc4162l_get_vcharge(struct ltc4162l_info *info,
 336                                 unsigned int reg,
 337                                 union power_supply_propval *val)
 338 {
 339         unsigned int regval;
 340         int ret;
 341         u32 voltage;
 342
 343         ret = regmap_read(info->regmap, reg, &regval);
 344         if (ret)
 345                 return ret;
 346
 347         regval &= BIT(6) - 1; /* Only the lower 5 bits */
 348
 349         /*
 350          * charge voltage setting can be computed from
 351          * cell_count × (vcharge_setting × 12.5mV + 3.8125V)
 352          * where vcharge_setting ranges from 0 to 31 (4.2V max).
 353          */
 354         voltage = 3812500 + (regval * 12500);
 355         voltage *= ltc4162l_get_cell_count(info);
 356         val->intval = voltage;
 357
 358         return 0;
 359 }
 360
 361 static int ltc4162l_set_vcharge(struct ltc4162l_info *info,
 362                                 unsigned int reg,
 363                                 unsigned int value)
 364 {
 365         u8 cell_count = ltc4162l_get_cell_count(info);
 366
 367         if (!cell_count)
 368                 return -EBUSY; /* Not available yet, try again later */
 369
 370         value /= cell_count;
 371
 372         if (value < 3812500)
 373                 return -EINVAL;
 374
 375         value -= 3812500;
 376         value /= 12500;
 377
 378         if (value > 31)
 379                 return -EINVAL;
 380
 381         return regmap_write(info->regmap, reg, value);
 382 }
 383
 384 static int ltc4162l_get_iin_limit_dac(struct ltc4162l_info *info,
 385                                      union power_supply_propval *val)
 386 {
 387         unsigned int regval;
 388         int ret;
 389
 390         ret = regmap_read(info->regmap, LTC4162L_IIN_LIMIT_DAC, &regval);
 391         if (ret)
 392                 return ret;
 393
 394         regval &= BIT(6) - 1; /* Only 6 bits */
 395
 396         /* (iin_limit_dac + 1) × 500μV / RSNSI */
 397         ++regval;
 398         regval *= 5000000u;
 399         regval /= info->rsnsi;
 400         val->intval = 100u * regval;
 401
 402         return 0;
 403 }
 404
 405 static int ltc4162l_set_iin_limit(struct ltc4162l_info *info,
 406                                   unsigned int value)
 407 {
 408         unsigned int regval;
 409
 410         regval = mult_frac(value, info->rsnsi, 50000u);
 411         regval /= 10000u;
 412         if (regval)
 413                 --regval;
 414         if (regval > 63)
 415                 regval = 63;
 416
 417         return regmap_write(info->regmap, LTC4162L_IIN_LIMIT_TARGET, regval);
 418 }
 419
 420 static int ltc4162l_get_die_temp(struct ltc4162l_info *info,
 421                                  union power_supply_propval *val)
 422 {
 423         unsigned int regval;
 424         int ret;
 425
 426         ret = regmap_read(info->regmap, LTC4162L_DIE_TEMPERATURE, &regval);
 427         if (ret)
 428                 return ret;
 429
 430         /* die_temp × 0.0215°C/LSB - 264.4°C */
 431         ret = (s16)(regval & 0xFFFF);
 432         ret *= 215;
 433         ret /= 100; /* Centidegrees scale */
 434         ret -= 26440;
 435         val->intval = ret;
 436
 437         return 0;
 438 }
 439
 440 static int ltc4162l_get_term_current(struct ltc4162l_info *info,
 441                                      union power_supply_propval *val)
 442 {
 443         unsigned int regval;
 444         int ret;
 445
 446         ret = regmap_read(info->regmap, LTC4162L_CHARGER_CONFIG_BITS, &regval);
 447         if (ret)
 448                 return ret;
 449
 450         /* Check if C_OVER_X_THRESHOLD is enabled */
 451         if (!(regval & BIT(2))) {
 452                 val->intval = 0;
 453                 return 0;
 454         }
 455
 456         ret = regmap_read(info->regmap, LTC4162L_C_OVER_X_THRESHOLD, &regval);
 457         if (ret)
 458                 return ret;
 459
 460         /* 1.466μV / RSNSB amperes/LSB */
 461         regval *= 14660u;
 462         regval /= info->rsnsb;
 463         val->intval = 100 * regval;
 464
 465         return 0;
 466 }
 467
 468 static int ltc4162l_set_term_current(struct ltc4162l_info *info,
 469                                      unsigned int value)
 470 {
 471         int ret;
 472         unsigned int regval;
 473
 474         if (!value) {
 475                 /* Disable en_c_over_x_term when set to zero */
 476                 return regmap_update_bits(info->regmap,
 477                                           LTC4162L_CHARGER_CONFIG_BITS,
 478                                           BIT(2), 0);
 479         }
 480
 481         regval = mult_frac(value, info->rsnsb, 14660u);
 482         regval /= 100u;
 483
 484         ret =  regmap_write(info->regmap, LTC4162L_C_OVER_X_THRESHOLD, regval);
 485         if (ret)
 486                 return ret;
 487
 488         /* Set en_c_over_x_term after changing the threshold value */
 489         return regmap_update_bits(info->regmap, LTC4162L_CHARGER_CONFIG_BITS,
 490                                   BIT(2), BIT(2));
 491 }
 492
 493 /* Custom properties */
 494 static const char * const ltc4162l_charge_status_name[] = {
 495         "ilim_reg_active", /* 32 */
 496         "thermal_reg_active",
 497         "vin_uvcl_active",
 498         "iin_limit_active",
 499         "constant_current",
 500         "constant_voltage",
 501         "charger_off" /* 0 */
 502 };
 503
 504 static ssize_t charge_status_show(struct device *dev,
 505                                   struct device_attribute *attr, char *buf)
 506 {
 507         struct power_supply *psy = to_power_supply(dev);
 508         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 509         const char *result = ltc4162l_charge_status_name[
 510                                 ARRAY_SIZE(ltc4162l_charge_status_name) - 1];
 511         unsigned int regval;
 512         unsigned int mask;
 513         unsigned int index;
 514         int ret;
 515
 516         ret = regmap_read(info->regmap, LTC4162L_CHARGE_STATUS, &regval);
 517         if (ret)
 518                 return ret;
 519
 520         /* Only one bit is set according to datasheet, let's be safe here */
 521         for (mask = 32, index = 0; mask != 0; mask >>= 1, ++index) {
 522                 if (regval & mask) {
 523                         result = ltc4162l_charge_status_name[index];
 524                         break;
 525                 }
 526         }
 527
 528         return sysfs_emit(buf, "%s\n", result);
 529 }
 530 static DEVICE_ATTR_RO(charge_status);
 531
 532 static ssize_t vbat_show(struct device *dev,
 533                                   struct device_attribute *attr, char *buf)
 534 {
 535         struct power_supply *psy = to_power_supply(dev);
 536         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 537         union power_supply_propval val;
 538         int ret;
 539
 540         ret = ltc4162l_get_vbat(info, LTC4162L_VBAT, &val);
 541         if (ret)
 542                 return ret;
 543
 544         return sysfs_emit(buf, "%d\n", val.intval);
 545 }
 546 static DEVICE_ATTR_RO(vbat);
 547
 548 static ssize_t vbat_avg_show(struct device *dev,
 549                                   struct device_attribute *attr, char *buf)
 550 {
 551         struct power_supply *psy = to_power_supply(dev);
 552         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 553         union power_supply_propval val;
 554         int ret;
 555
 556         ret = ltc4162l_get_vbat(info, LTC4162L_VBAT_FILT, &val);
 557         if (ret)
 558                 return ret;
 559
 560         return sysfs_emit(buf, "%d\n", val.intval);
 561 }
 562 static DEVICE_ATTR_RO(vbat_avg);
 563
 564 static ssize_t ibat_show(struct device *dev,
 565                                   struct device_attribute *attr, char *buf)
 566 {
 567         struct power_supply *psy = to_power_supply(dev);
 568         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 569         union power_supply_propval val;
 570         int ret;
 571
 572         ret = ltc4162l_get_ibat(info, &val);
 573         if (ret)
 574                 return ret;
 575
 576         return sysfs_emit(buf, "%d\n", val.intval);
 577 }
 578 static DEVICE_ATTR_RO(ibat);
 579
 580 static ssize_t force_telemetry_show(struct device *dev,
 581                                     struct device_attribute *attr, char *buf)
 582 {
 583         struct power_supply *psy = to_power_supply(dev);
 584         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 585         unsigned int regval;
 586         int ret;
 587
 588         ret = regmap_read(info->regmap, LTC4162L_CONFIG_BITS_REG, &regval);
 589         if (ret)
 590                 return ret;
 591
 592         return sysfs_emit(buf, "%u\n", regval & BIT(2) ? 1 : 0);
 593 }
 594
 595 static ssize_t force_telemetry_store(struct device *dev,
 596         struct device_attribute *attr,
 597         const char *buf,
 598         size_t count)
 599 {
 600         struct power_supply *psy = to_power_supply(dev);
 601         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 602         int ret;
 603         unsigned int value;
 604
 605         ret = kstrtouint(buf, 0, &value);
 606         if (ret < 0)
 607                 return ret;
 608
 609         ret = regmap_update_bits(info->regmap, LTC4162L_CONFIG_BITS_REG,
 610                                  BIT(2), value ? BIT(2) : 0);
 611         if (ret < 0)
 612                 return ret;
 613
 614         return count;
 615 }
 616
 617 static DEVICE_ATTR_RW(force_telemetry);
 618
 619 static ssize_t arm_ship_mode_show(struct device *dev,
 620                                     struct device_attribute *attr, char *buf)
 621 {
 622         struct power_supply *psy = to_power_supply(dev);
 623         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 624         unsigned int regval;
 625         int ret;
 626
 627         ret = regmap_read(info->regmap, LTC4162L_ARM_SHIP_MODE, &regval);
 628         if (ret)
 629                 return ret;
 630
 631         return sysfs_emit(buf, "%u\n",
 632                 regval == LTC4162L_ARM_SHIP_MODE_MAGIC ? 1 : 0);
 633 }
 634
 635 static ssize_t arm_ship_mode_store(struct device *dev,
 636         struct device_attribute *attr,
 637         const char *buf,
 638         size_t count)
 639 {
 640         struct power_supply *psy = to_power_supply(dev);
 641         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 642         int ret;
 643         unsigned int value;
 644
 645         ret = kstrtouint(buf, 0, &value);
 646         if (ret < 0)
 647                 return ret;
 648
 649         ret = regmap_write(info->regmap, LTC4162L_ARM_SHIP_MODE,
 650                                 value ? LTC4162L_ARM_SHIP_MODE_MAGIC : 0);
 651         if (ret < 0)
 652                 return ret;
 653
 654         return count;
 655 }
 656
 657 static DEVICE_ATTR_RW(arm_ship_mode);
 658
 659 static struct attribute *ltc4162l_sysfs_entries[] = {
 660         &dev_attr_charge_status.attr,
 661         &dev_attr_ibat.attr,
 662         &dev_attr_vbat.attr,
 663         &dev_attr_vbat_avg.attr,
 664         &dev_attr_force_telemetry.attr,
 665         &dev_attr_arm_ship_mode.attr,
 666         NULL,
 667 };
 668
 669 static const struct attribute_group ltc4162l_attr_group = {
 670         .name   = NULL, /* put in device directory */
 671         .attrs  = ltc4162l_sysfs_entries,
 672 };
 673
 674 static const struct attribute_group *ltc4162l_attr_groups[] = {
 675         &ltc4162l_attr_group,
 676         NULL,
 677 };
 678
 679 static int ltc4162l_get_property(struct power_supply *psy,
 680                                  enum power_supply_property psp,
 681                                  union power_supply_propval *val)
 682 {
 683         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 684
 685         switch (psp) {
 686         case POWER_SUPPLY_PROP_STATUS:
 687                 return ltc4162l_get_status(info, val);
 688         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 689                 return ltc4162l_get_charge_type(info, val);
 690         case POWER_SUPPLY_PROP_HEALTH:
 691                 return ltc4162l_get_health(info, val);
 692         case POWER_SUPPLY_PROP_ONLINE:
 693                 return ltc4162l_get_online(info, val);
 694         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 695                 return ltc4162l_get_input_voltage(info, val);
 696         case POWER_SUPPLY_PROP_CURRENT_NOW:
 697                 return ltc4162l_get_input_current(info, val);
 698         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 699                 return ltc4162l_get_icharge(info,
 700                                 LTC4162L_ICHARGE_DAC, val);
 701         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 702                 return ltc4162l_get_icharge(info,
 703                                 LTC4162L_CHARGE_CURRENT_SETTING, val);
 704         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 705                 return ltc4162l_get_vcharge(info,
 706                                 LTC4162L_VCHARGE_DAC, val);
 707         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 708                 return ltc4162l_get_vcharge(info,
 709                                 LTC4162L_VCHARGE_SETTING, val);
 710         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 711                 return ltc4162l_get_iin_limit_dac(info, val);
 712         case POWER_SUPPLY_PROP_TEMP:
 713                 return ltc4162l_get_die_temp(info, val);
 714         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 715                 return ltc4162l_get_term_current(info, val);
 716         default:
 717                 return -EINVAL;
 718         }
 719 }
 720
 721 static int ltc4162l_set_property(struct power_supply *psy,
 722                                          enum power_supply_property psp,
 723                                          const union power_supply_propval *val)
 724 {
 725         struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 726
 727         switch (psp) {
 728         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 729                 return ltc4162l_set_icharge(info,
 730                                 LTC4162L_CHARGE_CURRENT_SETTING, val->intval);
 731         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 732                 return ltc4162l_set_vcharge(info,
 733                                 LTC4162L_VCHARGE_SETTING, val->intval);
 734         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 735                 return ltc4162l_set_iin_limit(info, val->intval);
 736         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 737                 return ltc4162l_set_term_current(info, val->intval);
 738         default:
 739                 return -EINVAL;
 740         }
 741 }
 742
 743 static int ltc4162l_property_is_writeable(struct power_supply *psy,
 744                                                 enum power_supply_property psp)
 745 {
 746         switch (psp) {
 747         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 748         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 749         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 750         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 751                 return 1;
 752         default:
 753                 return 0;
 754         }
 755 }
 756
 757 /* Charger power supply property routines */
 758 static enum power_supply_property ltc4162l_properties[] = {
 759         POWER_SUPPLY_PROP_STATUS,
 760         POWER_SUPPLY_PROP_CHARGE_TYPE,
 761         POWER_SUPPLY_PROP_HEALTH,
 762         POWER_SUPPLY_PROP_ONLINE,
 763         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 764         POWER_SUPPLY_PROP_CURRENT_NOW,
 765         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 766         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 767         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 768         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 769         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 770         POWER_SUPPLY_PROP_TEMP,
 771         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
 772 };
 773
 774 static const struct power_supply_desc ltc4162l_desc = {
 775         .name           = "ltc4162-l",
 776         .type           = POWER_SUPPLY_TYPE_MAINS,
 777         .properties     = ltc4162l_properties,
 778         .num_properties = ARRAY_SIZE(ltc4162l_properties),
 779         .get_property   = ltc4162l_get_property,
 780         .set_property   = ltc4162l_set_property,
 781         .property_is_writeable = ltc4162l_property_is_writeable,
 782 };
 783
 784 static bool ltc4162l_is_writeable_reg(struct device *dev, unsigned int reg)
 785 {
 786         /* all registers up to this one are writeable */
 787         if (reg <= LTC4162L_CHARGER_CONFIG_BITS)
 788                 return true;
 789
 790         /* The ALERTS registers can be written to clear alerts */
 791         if (reg >= LTC4162L_LIMIT_ALERTS_REG &&
 792             reg <= LTC4162L_CHARGE_STATUS_ALERTS_REG)
 793                 return true;
 794
 795         return false;
 796 }
 797
 798 static bool ltc4162l_is_volatile_reg(struct device *dev, unsigned int reg)
 799 {
 800         /* all registers after this one are read-only status registers */
 801         return reg > LTC4162L_CHARGER_CONFIG_BITS;
 802 }
 803
 804 static const struct regmap_config ltc4162l_regmap_config = {
 805         .reg_bits       = 8,
 806         .val_bits       = 16,
 807         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 808         .writeable_reg  = ltc4162l_is_writeable_reg,
 809         .volatile_reg   = ltc4162l_is_volatile_reg,
 810         .max_register   = LTC4162L_INPUT_UNDERVOLTAGE_DAC,
 811         .cache_type     = REGCACHE_RBTREE,
 812 };
 813
 814 static void ltc4162l_clear_interrupts(struct ltc4162l_info *info)
 815 {
 816         /* Acknowledge interrupt to chip by clearing all events */
 817         regmap_write(info->regmap, LTC4162L_LIMIT_ALERTS_REG, 0);
 818         regmap_write(info->regmap, LTC4162L_CHARGER_STATE_ALERTS_REG, 0);
 819         regmap_write(info->regmap, LTC4162L_CHARGE_STATUS_ALERTS_REG, 0);
 820 }
 821
 822 static int ltc4162l_probe(struct i2c_client *client)
 823 {
 824         struct i2c_adapter *adapter = client->adapter;
 825         struct device *dev = &client->dev;
 826         struct ltc4162l_info *info;
 827         struct power_supply_config ltc4162l_config = {};
 828         u32 value;
 829         int ret;
 830
 831         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
 832                 dev_err(dev, "No support for SMBUS_WORD_DATA\n");
 833                 return -ENODEV;
 834         }
 835         info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
 836         if (!info)
 837                 return -ENOMEM;
 838
 839         info->client = client;
 840         i2c_set_clientdata(client, info);
 841
 842         info->regmap = devm_regmap_init_i2c(client, &ltc4162l_regmap_config);
 843         if (IS_ERR(info->regmap)) {
 844                 dev_err(dev, "Failed to initialize register map\n");
 845                 return PTR_ERR(info->regmap);
 846         }
 847
 848         ret = device_property_read_u32(dev, "lltc,rsnsb-micro-ohms",
 849                                        &info->rsnsb);
 850         if (ret) {
 851                 dev_err(dev, "Missing lltc,rsnsb-micro-ohms property\n");
 852                 return ret;
 853         }
 854         if (!info->rsnsb)
 855                 return -EINVAL;
 856
 857         ret = device_property_read_u32(dev, "lltc,rsnsi-micro-ohms",
 858                                        &info->rsnsi);
 859         if (ret) {
 860                 dev_err(dev, "Missing lltc,rsnsi-micro-ohms property\n");
 861                 return ret;
 862         }
 863         if (!info->rsnsi)
 864                 return -EINVAL;
 865
 866         if (!device_property_read_u32(dev, "lltc,cell-count", &value))
 867                 info->cell_count = value;
 868
 869         ltc4162l_config.of_node = dev->of_node;
 870         ltc4162l_config.drv_data = info;
 871         ltc4162l_config.attr_grp = ltc4162l_attr_groups;
 872
 873         info->charger = devm_power_supply_register(dev, &ltc4162l_desc,
 874                                                    &ltc4162l_config);
 875         if (IS_ERR(info->charger)) {
 876                 dev_err(dev, "Failed to register charger\n");
 877                 return PTR_ERR(info->charger);
 878         }
 879
 880         /* Disable the threshold alerts, we're not using them */
 881         regmap_write(info->regmap, LTC4162L_EN_LIMIT_ALERTS_REG, 0);
 882
 883         /* Enable interrupts on all status changes */
 884         regmap_write(info->regmap, LTC4162L_EN_CHARGER_STATE_ALERTS_REG,
 885                      0x1fff);
 886         regmap_write(info->regmap, LTC4162L_EN_CHARGE_STATUS_ALERTS_REG, 0x1f);
 887
 888         ltc4162l_clear_interrupts(info);
 889
 890         return 0;
 891 }
 892
 893 static void ltc4162l_alert(struct i2c_client *client,
 894                            enum i2c_alert_protocol type, unsigned int flag)
 895 {
 896         struct ltc4162l_info *info = i2c_get_clientdata(client);
 897
 898         if (type != I2C_PROTOCOL_SMBUS_ALERT)
 899                 return;
 900
 901         ltc4162l_clear_interrupts(info);
 902         power_supply_changed(info->charger);
 903 }
 904
 905 static const struct i2c_device_id ltc4162l_i2c_id_table[] = {
 906         { "ltc4162-l" },
 907         { }
 908 };
 909 MODULE_DEVICE_TABLE(i2c, ltc4162l_i2c_id_table);
 910
 911 static const struct of_device_id ltc4162l_of_match[] __maybe_unused = {
 912         { .compatible = "lltc,ltc4162-l", },
 913         { },
 914 };
 915 MODULE_DEVICE_TABLE(of, ltc4162l_of_match);
 916
 917 static struct i2c_driver ltc4162l_driver = {
 918         .probe          = ltc4162l_probe,
 919         .alert          = ltc4162l_alert,
 920         .id_table       = ltc4162l_i2c_id_table,
 921         .driver = {
 922                 .name           = "ltc4162-l-charger",
 923                 .of_match_table = of_match_ptr(ltc4162l_of_match),
 924         },
 925 };
 926 module_i2c_driver(ltc4162l_driver);
 927
 928 MODULE_LICENSE("GPL");
 929 MODULE_AUTHOR("Mike Looijmans <mike.looijmans@topic.nl>");
 930 MODULE_DESCRIPTION("LTC4162-L charger driver");