drivers/power/supply/smb347-charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Summit Microelectronics SMB347 Battery Charger Driver
   4  *
   5  * Copyright (C) 2011, Intel Corporation
   6  *
   7  * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
   8  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/err.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/i2c.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/property.h>
  20 #include <linux/regmap.h>
  21 #include <linux/regulator/driver.h>
  22
  23 #include <dt-bindings/power/summit,smb347-charger.h>
  24
  25 /* Use the default compensation method */
  26 #define SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT -1
  27
  28 /* Use default factory programmed value for hard/soft temperature limit */
  29 #define SMB3XX_TEMP_USE_DEFAULT         -273
  30
  31 /*
  32  * Configuration registers. These are mirrored to volatile RAM and can be
  33  * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
  34  * reloaded from non-volatile registers after POR.
  35  */
  36 #define CFG_CHARGE_CURRENT                      0x00
  37 #define CFG_CHARGE_CURRENT_FCC_MASK             0xe0
  38 #define CFG_CHARGE_CURRENT_FCC_SHIFT            5
  39 #define CFG_CHARGE_CURRENT_PCC_MASK             0x18
  40 #define CFG_CHARGE_CURRENT_PCC_SHIFT            3
  41 #define CFG_CHARGE_CURRENT_TC_MASK              0x07
  42 #define CFG_CURRENT_LIMIT                       0x01
  43 #define CFG_CURRENT_LIMIT_DC_MASK               0xf0
  44 #define CFG_CURRENT_LIMIT_DC_SHIFT              4
  45 #define CFG_CURRENT_LIMIT_USB_MASK              0x0f
  46 #define CFG_FLOAT_VOLTAGE                       0x03
  47 #define CFG_FLOAT_VOLTAGE_FLOAT_MASK            0x3f
  48 #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK        0xc0
  49 #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT       6
  50 #define CFG_STAT                                0x05
  51 #define CFG_STAT_DISABLED                       BIT(5)
  52 #define CFG_STAT_ACTIVE_HIGH                    BIT(7)
  53 #define CFG_PIN                                 0x06
  54 #define CFG_PIN_EN_CTRL_MASK                    0x60
  55 #define CFG_PIN_EN_CTRL_ACTIVE_HIGH             0x40
  56 #define CFG_PIN_EN_CTRL_ACTIVE_LOW              0x60
  57 #define CFG_PIN_EN_APSD_IRQ                     BIT(1)
  58 #define CFG_PIN_EN_CHARGER_ERROR                BIT(2)
  59 #define CFG_PIN_EN_CTRL                         BIT(4)
  60 #define CFG_THERM                               0x07
  61 #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK    0x03
  62 #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT   0
  63 #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK   0x0c
  64 #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT  2
  65 #define CFG_THERM_MONITOR_DISABLED              BIT(4)
  66 #define CFG_SYSOK                               0x08
  67 #define CFG_SYSOK_INOK_ACTIVE_HIGH              BIT(0)
  68 #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED   BIT(2)
  69 #define CFG_OTHER                               0x09
  70 #define CFG_OTHER_RID_MASK                      0xc0
  71 #define CFG_OTHER_RID_ENABLED_AUTO_OTG          0xc0
  72 #define CFG_OTG                                 0x0a
  73 #define CFG_OTG_TEMP_THRESHOLD_MASK             0x30
  74 #define CFG_OTG_CURRENT_LIMIT_250mA             BIT(2)
  75 #define CFG_OTG_CURRENT_LIMIT_750mA             BIT(3)
  76 #define CFG_OTG_TEMP_THRESHOLD_SHIFT            4
  77 #define CFG_OTG_CC_COMPENSATION_MASK            0xc0
  78 #define CFG_OTG_CC_COMPENSATION_SHIFT           6
  79 #define CFG_TEMP_LIMIT                          0x0b
  80 #define CFG_TEMP_LIMIT_SOFT_HOT_MASK            0x03
  81 #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT           0
  82 #define CFG_TEMP_LIMIT_SOFT_COLD_MASK           0x0c
  83 #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT          2
  84 #define CFG_TEMP_LIMIT_HARD_HOT_MASK            0x30
  85 #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT           4
  86 #define CFG_TEMP_LIMIT_HARD_COLD_MASK           0xc0
  87 #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT          6
  88 #define CFG_FAULT_IRQ                           0x0c
  89 #define CFG_FAULT_IRQ_DCIN_UV                   BIT(2)
  90 #define CFG_STATUS_IRQ                          0x0d
  91 #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER     BIT(4)
  92 #define CFG_STATUS_IRQ_CHARGE_TIMEOUT           BIT(7)
  93 #define CFG_ADDRESS                             0x0e
  94
  95 /* Command registers */
  96 #define CMD_A                                   0x30
  97 #define CMD_A_CHG_ENABLED                       BIT(1)
  98 #define CMD_A_SUSPEND_ENABLED                   BIT(2)
  99 #define CMD_A_OTG_ENABLED                       BIT(4)
 100 #define CMD_A_ALLOW_WRITE                       BIT(7)
 101 #define CMD_B                                   0x31
 102 #define CMD_C                                   0x33
 103
 104 /* Interrupt Status registers */
 105 #define IRQSTAT_A                               0x35
 106 #define IRQSTAT_C                               0x37
 107 #define IRQSTAT_C_TERMINATION_STAT              BIT(0)
 108 #define IRQSTAT_C_TERMINATION_IRQ               BIT(1)
 109 #define IRQSTAT_C_TAPER_IRQ                     BIT(3)
 110 #define IRQSTAT_D                               0x38
 111 #define IRQSTAT_D_CHARGE_TIMEOUT_STAT           BIT(2)
 112 #define IRQSTAT_D_CHARGE_TIMEOUT_IRQ            BIT(3)
 113 #define IRQSTAT_E                               0x39
 114 #define IRQSTAT_E_USBIN_UV_STAT                 BIT(0)
 115 #define IRQSTAT_E_USBIN_UV_IRQ                  BIT(1)
 116 #define IRQSTAT_E_DCIN_UV_STAT                  BIT(4)
 117 #define IRQSTAT_E_DCIN_UV_IRQ                   BIT(5)
 118 #define IRQSTAT_F                               0x3a
 119
 120 /* Status registers */
 121 #define STAT_A                                  0x3b
 122 #define STAT_A_FLOAT_VOLTAGE_MASK               0x3f
 123 #define STAT_B                                  0x3c
 124 #define STAT_C                                  0x3d
 125 #define STAT_C_CHG_ENABLED                      BIT(0)
 126 #define STAT_C_HOLDOFF_STAT                     BIT(3)
 127 #define STAT_C_CHG_MASK                         0x06
 128 #define STAT_C_CHG_SHIFT                        1
 129 #define STAT_C_CHG_TERM                         BIT(5)
 130 #define STAT_C_CHARGER_ERROR                    BIT(6)
 131 #define STAT_E                                  0x3f
 132
 133 #define SMB347_MAX_REGISTER                     0x3f
 134
 135 /**
 136  * struct smb347_charger - smb347 charger instance
 137  * @dev: pointer to device
 138  * @regmap: pointer to driver regmap
 139  * @mains: power_supply instance for AC/DC power
 140  * @usb: power_supply instance for USB power
 141  * @usb_rdev: USB VBUS regulator device
 142  * @id: SMB charger ID
 143  * @mains_online: is AC/DC input connected
 144  * @usb_online: is USB input connected
 145  * @irq_unsupported: is interrupt unsupported by SMB hardware
 146  * @usb_vbus_enabled: is USB VBUS powered by SMB charger
 147  * @max_charge_current: maximum current (in uA) the battery can be charged
 148  * @max_charge_voltage: maximum voltage (in uV) the battery can be charged
 149  * @pre_charge_current: current (in uA) to use in pre-charging phase
 150  * @termination_current: current (in uA) used to determine when the
 151  *                       charging cycle terminates
 152  * @pre_to_fast_voltage: voltage (in uV) treshold used for transitioning to
 153  *                       pre-charge to fast charge mode
 154  * @mains_current_limit: maximum input current drawn from AC/DC input (in uA)
 155  * @usb_hc_current_limit: maximum input high current (in uA) drawn from USB
 156  *                        input
 157  * @chip_temp_threshold: die temperature where device starts limiting charge
 158  *                       current [%100 - %130] (in degree C)
 159  * @soft_cold_temp_limit: soft cold temperature limit [%0 - %15] (in degree C),
 160  *                        granularity is 5 deg C.
 161  * @soft_hot_temp_limit: soft hot temperature limit [%40 - %55] (in degree  C),
 162  *                       granularity is 5 deg C.
 163  * @hard_cold_temp_limit: hard cold temperature limit [%-5 - %10] (in degree C),
 164  *                        granularity is 5 deg C.
 165  * @hard_hot_temp_limit: hard hot temperature limit [%50 - %65] (in degree C),
 166  *                       granularity is 5 deg C.
 167  * @suspend_on_hard_temp_limit: suspend charging when hard limit is hit
 168  * @soft_temp_limit_compensation: compensation method when soft temperature
 169  *                                limit is hit
 170  * @charge_current_compensation: current (in uA) for charging compensation
 171  *                               current when temperature hits soft limits
 172  * @use_mains: AC/DC input can be used
 173  * @use_usb: USB input can be used
 174  * @use_usb_otg: USB OTG output can be used (not implemented yet)
 175  * @enable_control: how charging enable/disable is controlled
 176  *                  (driver/pin controls)
 177  * @inok_polarity: polarity of INOK signal which denotes presence of external
 178  *                 power supply
 179  *
 180  * @use_main, @use_usb, and @use_usb_otg are means to enable/disable
 181  * hardware support for these. This is useful when we want to have for
 182  * example OTG charging controlled via OTG transceiver driver and not by
 183  * the SMB347 hardware.
 184  *
 185  * Hard and soft temperature limit values are given as described in the
 186  * device data sheet and assuming NTC beta value is %3750. Even if this is
 187  * not the case, these values should be used. They can be mapped to the
 188  * corresponding NTC beta values with the help of table %2 in the data
 189  * sheet. So for example if NTC beta is %3375 and we want to program hard
 190  * hot limit to be %53 deg C, @hard_hot_temp_limit should be set to %50.
 191  *
 192  * If zero value is given in any of the current and voltage values, the
 193  * factory programmed default will be used. For soft/hard temperature
 194  * values, pass in %SMB3XX_TEMP_USE_DEFAULT instead.
 195  */
 196 struct smb347_charger {
 197         struct device           *dev;
 198         struct regmap           *regmap;
 199         struct power_supply     *mains;
 200         struct power_supply     *usb;
 201         struct regulator_dev    *usb_rdev;
 202         unsigned int            id;
 203         bool                    mains_online;
 204         bool                    usb_online;
 205         bool                    irq_unsupported;
 206         bool                    usb_vbus_enabled;
 207
 208         unsigned int            max_charge_current;
 209         unsigned int            max_charge_voltage;
 210         unsigned int            pre_charge_current;
 211         unsigned int            termination_current;
 212         unsigned int            pre_to_fast_voltage;
 213         unsigned int            mains_current_limit;
 214         unsigned int            usb_hc_current_limit;
 215         unsigned int            chip_temp_threshold;
 216         int                     soft_cold_temp_limit;
 217         int                     soft_hot_temp_limit;
 218         int                     hard_cold_temp_limit;
 219         int                     hard_hot_temp_limit;
 220         bool                    suspend_on_hard_temp_limit;
 221         unsigned int            soft_temp_limit_compensation;
 222         unsigned int            charge_current_compensation;
 223         bool                    use_mains;
 224         bool                    use_usb;
 225         bool                    use_usb_otg;
 226         unsigned int            enable_control;
 227         unsigned int            inok_polarity;
 228 };
 229
 230 enum smb_charger_chipid {
 231         SMB345,
 232         SMB347,
 233         SMB358,
 234         NUM_CHIP_TYPES,
 235 };
 236
 237 /* Fast charge current in uA */
 238 static const unsigned int fcc_tbl[NUM_CHIP_TYPES][8] = {
 239         [SMB345] = {  200000,  450000,  600000,  900000,
 240                      1300000, 1500000, 1800000, 2000000 },
 241         [SMB347] = {  700000,  900000, 1200000, 1500000,
 242                      1800000, 2000000, 2200000, 2500000 },
 243         [SMB358] = {  200000,  450000,  600000,  900000,
 244                      1300000, 1500000, 1800000, 2000000 },
 245 };
 246 /* Pre-charge current in uA */
 247 static const unsigned int pcc_tbl[NUM_CHIP_TYPES][4] = {
 248         [SMB345] = { 150000, 250000, 350000, 450000 },
 249         [SMB347] = { 100000, 150000, 200000, 250000 },
 250         [SMB358] = { 150000, 250000, 350000, 450000 },
 251 };
 252
 253 /* Termination current in uA */
 254 static const unsigned int tc_tbl[NUM_CHIP_TYPES][8] = {
 255         [SMB345] = {  30000,  40000,  60000,  80000,
 256                      100000, 125000, 150000, 200000 },
 257         [SMB347] = {  37500,  50000, 100000, 150000,
 258                      200000, 250000, 500000, 600000 },
 259         [SMB358] = {  30000,  40000,  60000,  80000,
 260                      100000, 125000, 150000, 200000 },
 261 };
 262
 263 /* Input current limit in uA */
 264 static const unsigned int icl_tbl[NUM_CHIP_TYPES][10] = {
 265         [SMB345] = {  300000,  500000,  700000, 1000000, 1500000,
 266                      1800000, 2000000, 2000000, 2000000, 2000000 },
 267         [SMB347] = {  300000,  500000,  700000,  900000, 1200000,
 268                      1500000, 1800000, 2000000, 2200000, 2500000 },
 269         [SMB358] = {  300000,  500000,  700000, 1000000, 1500000,
 270                      1800000, 2000000, 2000000, 2000000, 2000000 },
 271 };
 272
 273 /* Charge current compensation in uA */
 274 static const unsigned int ccc_tbl[NUM_CHIP_TYPES][4] = {
 275         [SMB345] = {  200000,  450000,  600000,  900000 },
 276         [SMB347] = {  250000,  700000,  900000, 1200000 },
 277         [SMB358] = {  200000,  450000,  600000,  900000 },
 278 };
 279
 280 /* Convert register value to current using lookup table */
 281 static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
 282 {
 283         if (val >= size)
 284                 return -EINVAL;
 285         return tbl[val];
 286 }
 287
 288 /* Convert current to register value using lookup table */
 289 static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
 290 {
 291         size_t i;
 292
 293         for (i = 0; i < size; i++)
 294                 if (val < tbl[i])
 295                         break;
 296         return i > 0 ? i - 1 : -EINVAL;
 297 }
 298
 299 /**
 300  * smb347_update_ps_status - refreshes the power source status
 301  * @smb: pointer to smb347 charger instance
 302  *
 303  * Function checks whether any power source is connected to the charger and
 304  * updates internal state accordingly. If there is a change to previous state
 305  * function returns %1, otherwise %0 and negative errno in case of errror.
 306  */
 307 static int smb347_update_ps_status(struct smb347_charger *smb)
 308 {
 309         bool usb = false;
 310         bool dc = false;
 311         unsigned int val;
 312         int ret;
 313
 314         ret = regmap_read(smb->regmap, IRQSTAT_E, &val);
 315         if (ret < 0)
 316                 return ret;
 317
 318         /*
 319          * Dc and usb are set depending on whether they are enabled in
 320          * platform data _and_ whether corresponding undervoltage is set.
 321          */
 322         if (smb->use_mains)
 323                 dc = !(val & IRQSTAT_E_DCIN_UV_STAT);
 324         if (smb->use_usb)
 325                 usb = !(val & IRQSTAT_E_USBIN_UV_STAT);
 326
 327         ret = smb->mains_online != dc || smb->usb_online != usb;
 328         smb->mains_online = dc;
 329         smb->usb_online = usb;
 330
 331         return ret;
 332 }
 333
 334 /*
 335  * smb347_is_ps_online - returns whether input power source is connected
 336  * @smb: pointer to smb347 charger instance
 337  *
 338  * Returns %true if input power source is connected. Note that this is
 339  * dependent on what platform has configured for usable power sources. For
 340  * example if USB is disabled, this will return %false even if the USB cable
 341  * is connected.
 342  */
 343 static bool smb347_is_ps_online(struct smb347_charger *smb)
 344 {
 345         return smb->usb_online || smb->mains_online;
 346 }
 347
 348 /**
 349  * smb347_charging_status - returns status of charging
 350  * @smb: pointer to smb347 charger instance
 351  *
 352  * Function returns charging status. %0 means no charging is in progress,
 353  * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
 354  */
 355 static int smb347_charging_status(struct smb347_charger *smb)
 356 {
 357         unsigned int val;
 358         int ret;
 359
 360         if (!smb347_is_ps_online(smb))
 361                 return 0;
 362
 363         ret = regmap_read(smb->regmap, STAT_C, &val);
 364         if (ret < 0)
 365                 return 0;
 366
 367         return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
 368 }
 369
 370 static int smb347_charging_set(struct smb347_charger *smb, bool enable)
 371 {
 372         if (smb->enable_control != SMB3XX_CHG_ENABLE_SW) {
 373                 dev_dbg(smb->dev, "charging enable/disable in SW disabled\n");
 374                 return 0;
 375         }
 376
 377         if (enable && smb->usb_vbus_enabled) {
 378                 dev_dbg(smb->dev, "charging not enabled because USB is in host mode\n");
 379                 return 0;
 380         }
 381
 382         return regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED,
 383                                   enable ? CMD_A_CHG_ENABLED : 0);
 384 }
 385
 386 static inline int smb347_charging_enable(struct smb347_charger *smb)
 387 {
 388         return smb347_charging_set(smb, true);
 389 }
 390
 391 static inline int smb347_charging_disable(struct smb347_charger *smb)
 392 {
 393         return smb347_charging_set(smb, false);
 394 }
 395
 396 static int smb347_start_stop_charging(struct smb347_charger *smb)
 397 {
 398         int ret;
 399
 400         /*
 401          * Depending on whether valid power source is connected or not, we
 402          * disable or enable the charging. We do it manually because it
 403          * depends on how the platform has configured the valid inputs.
 404          */
 405         if (smb347_is_ps_online(smb)) {
 406                 ret = smb347_charging_enable(smb);
 407                 if (ret < 0)
 408                         dev_err(smb->dev, "failed to enable charging\n");
 409         } else {
 410                 ret = smb347_charging_disable(smb);
 411                 if (ret < 0)
 412                         dev_err(smb->dev, "failed to disable charging\n");
 413         }
 414
 415         return ret;
 416 }
 417
 418 static int smb347_set_charge_current(struct smb347_charger *smb)
 419 {
 420         unsigned int id = smb->id;
 421         int ret;
 422
 423         if (smb->max_charge_current) {
 424                 ret = current_to_hw(fcc_tbl[id], ARRAY_SIZE(fcc_tbl[id]),
 425                                     smb->max_charge_current);
 426                 if (ret < 0)
 427                         return ret;
 428
 429                 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
 430                                          CFG_CHARGE_CURRENT_FCC_MASK,
 431                                          ret << CFG_CHARGE_CURRENT_FCC_SHIFT);
 432                 if (ret < 0)
 433                         return ret;
 434         }
 435
 436         if (smb->pre_charge_current) {
 437                 ret = current_to_hw(pcc_tbl[id], ARRAY_SIZE(pcc_tbl[id]),
 438                                     smb->pre_charge_current);
 439                 if (ret < 0)
 440                         return ret;
 441
 442                 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
 443                                          CFG_CHARGE_CURRENT_PCC_MASK,
 444                                          ret << CFG_CHARGE_CURRENT_PCC_SHIFT);
 445                 if (ret < 0)
 446                         return ret;
 447         }
 448
 449         if (smb->termination_current) {
 450                 ret = current_to_hw(tc_tbl[id], ARRAY_SIZE(tc_tbl[id]),
 451                                     smb->termination_current);
 452                 if (ret < 0)
 453                         return ret;
 454
 455                 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
 456                                          CFG_CHARGE_CURRENT_TC_MASK, ret);
 457                 if (ret < 0)
 458                         return ret;
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int smb347_set_current_limits(struct smb347_charger *smb)
 465 {
 466         unsigned int id = smb->id;
 467         int ret;
 468
 469         if (smb->mains_current_limit) {
 470                 ret = current_to_hw(icl_tbl[id], ARRAY_SIZE(icl_tbl[id]),
 471                                     smb->mains_current_limit);
 472                 if (ret < 0)
 473                         return ret;
 474
 475                 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
 476                                          CFG_CURRENT_LIMIT_DC_MASK,
 477                                          ret << CFG_CURRENT_LIMIT_DC_SHIFT);
 478                 if (ret < 0)
 479                         return ret;
 480         }
 481
 482         if (smb->usb_hc_current_limit) {
 483                 ret = current_to_hw(icl_tbl[id], ARRAY_SIZE(icl_tbl[id]),
 484                                     smb->usb_hc_current_limit);
 485                 if (ret < 0)
 486                         return ret;
 487
 488                 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
 489                                          CFG_CURRENT_LIMIT_USB_MASK, ret);
 490                 if (ret < 0)
 491                         return ret;
 492         }
 493
 494         return 0;
 495 }
 496
 497 static int smb347_set_voltage_limits(struct smb347_charger *smb)
 498 {
 499         int ret;
 500
 501         if (smb->pre_to_fast_voltage) {
 502                 ret = smb->pre_to_fast_voltage;
 503
 504                 /* uV */
 505                 ret = clamp_val(ret, 2400000, 3000000) - 2400000;
 506                 ret /= 200000;
 507
 508                 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
 509                                 CFG_FLOAT_VOLTAGE_THRESHOLD_MASK,
 510                                 ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT);
 511                 if (ret < 0)
 512                         return ret;
 513         }
 514
 515         if (smb->max_charge_voltage) {
 516                 ret = smb->max_charge_voltage;
 517
 518                 /* uV */
 519                 ret = clamp_val(ret, 3500000, 4500000) - 3500000;
 520                 ret /= 20000;
 521
 522                 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
 523                                          CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret);
 524                 if (ret < 0)
 525                         return ret;
 526         }
 527
 528         return 0;
 529 }
 530
 531 static int smb347_set_temp_limits(struct smb347_charger *smb)
 532 {
 533         unsigned int id = smb->id;
 534         bool enable_therm_monitor = false;
 535         int ret = 0;
 536         int val;
 537
 538         if (smb->chip_temp_threshold) {
 539                 val = smb->chip_temp_threshold;
 540
 541                 /* degree C */
 542                 val = clamp_val(val, 100, 130) - 100;
 543                 val /= 10;
 544
 545                 ret = regmap_update_bits(smb->regmap, CFG_OTG,
 546                                          CFG_OTG_TEMP_THRESHOLD_MASK,
 547                                          val << CFG_OTG_TEMP_THRESHOLD_SHIFT);
 548                 if (ret < 0)
 549                         return ret;
 550         }
 551
 552         if (smb->soft_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
 553                 val = smb->soft_cold_temp_limit;
 554
 555                 val = clamp_val(val, 0, 15);
 556                 val /= 5;
 557                 /* this goes from higher to lower so invert the value */
 558                 val = ~val & 0x3;
 559
 560                 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
 561                                          CFG_TEMP_LIMIT_SOFT_COLD_MASK,
 562                                          val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT);
 563                 if (ret < 0)
 564                         return ret;
 565
 566                 enable_therm_monitor = true;
 567         }
 568
 569         if (smb->soft_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
 570                 val = smb->soft_hot_temp_limit;
 571
 572                 val = clamp_val(val, 40, 55) - 40;
 573                 val /= 5;
 574
 575                 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
 576                                          CFG_TEMP_LIMIT_SOFT_HOT_MASK,
 577                                          val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT);
 578                 if (ret < 0)
 579                         return ret;
 580
 581                 enable_therm_monitor = true;
 582         }
 583
 584         if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
 585                 val = smb->hard_cold_temp_limit;
 586
 587                 val = clamp_val(val, -5, 10) + 5;
 588                 val /= 5;
 589                 /* this goes from higher to lower so invert the value */
 590                 val = ~val & 0x3;
 591
 592                 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
 593                                          CFG_TEMP_LIMIT_HARD_COLD_MASK,
 594                                          val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT);
 595                 if (ret < 0)
 596                         return ret;
 597
 598                 enable_therm_monitor = true;
 599         }
 600
 601         if (smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
 602                 val = smb->hard_hot_temp_limit;
 603
 604                 val = clamp_val(val, 50, 65) - 50;
 605                 val /= 5;
 606
 607                 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
 608                                          CFG_TEMP_LIMIT_HARD_HOT_MASK,
 609                                          val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT);
 610                 if (ret < 0)
 611                         return ret;
 612
 613                 enable_therm_monitor = true;
 614         }
 615
 616         /*
 617          * If any of the temperature limits are set, we also enable the
 618          * thermistor monitoring.
 619          *
 620          * When soft limits are hit, the device will start to compensate
 621          * current and/or voltage depending on the configuration.
 622          *
 623          * When hard limit is hit, the device will suspend charging
 624          * depending on the configuration.
 625          */
 626         if (enable_therm_monitor) {
 627                 ret = regmap_update_bits(smb->regmap, CFG_THERM,
 628                                          CFG_THERM_MONITOR_DISABLED, 0);
 629                 if (ret < 0)
 630                         return ret;
 631         }
 632
 633         if (smb->suspend_on_hard_temp_limit) {
 634                 ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
 635                                  CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0);
 636                 if (ret < 0)
 637                         return ret;
 638         }
 639
 640         if (smb->soft_temp_limit_compensation !=
 641             SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT) {
 642                 val = smb->soft_temp_limit_compensation & 0x3;
 643
 644                 ret = regmap_update_bits(smb->regmap, CFG_THERM,
 645                                  CFG_THERM_SOFT_HOT_COMPENSATION_MASK,
 646                                  val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT);
 647                 if (ret < 0)
 648                         return ret;
 649
 650                 ret = regmap_update_bits(smb->regmap, CFG_THERM,
 651                                  CFG_THERM_SOFT_COLD_COMPENSATION_MASK,
 652                                  val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT);
 653                 if (ret < 0)
 654                         return ret;
 655         }
 656
 657         if (smb->charge_current_compensation) {
 658                 val = current_to_hw(ccc_tbl[id], ARRAY_SIZE(ccc_tbl[id]),
 659                                     smb->charge_current_compensation);
 660                 if (val < 0)
 661                         return val;
 662
 663                 ret = regmap_update_bits(smb->regmap, CFG_OTG,
 664                                 CFG_OTG_CC_COMPENSATION_MASK,
 665                                 (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT);
 666                 if (ret < 0)
 667                         return ret;
 668         }
 669
 670         return ret;
 671 }
 672
 673 /*
 674  * smb347_set_writable - enables/disables writing to non-volatile registers
 675  * @smb: pointer to smb347 charger instance
 676  *
 677  * You can enable/disable writing to the non-volatile configuration
 678  * registers by calling this function.
 679  *
 680  * Returns %0 on success and negative errno in case of failure.
 681  */
 682 static int smb347_set_writable(struct smb347_charger *smb, bool writable,
 683                                bool irq_toggle)
 684 {
 685         struct i2c_client *client = to_i2c_client(smb->dev);
 686         int ret;
 687
 688         if (writable && irq_toggle && !smb->irq_unsupported)
 689                 disable_irq(client->irq);
 690
 691         ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE,
 692                                  writable ? CMD_A_ALLOW_WRITE : 0);
 693
 694         if ((!writable || ret) && irq_toggle && !smb->irq_unsupported)
 695                 enable_irq(client->irq);
 696
 697         return ret;
 698 }
 699
 700 static int smb347_hw_init(struct smb347_charger *smb)
 701 {
 702         unsigned int val;
 703         int ret;
 704
 705         ret = smb347_set_writable(smb, true, false);
 706         if (ret < 0)
 707                 return ret;
 708
 709         /*
 710          * Program the platform specific configuration values to the device
 711          * first.
 712          */
 713         ret = smb347_set_charge_current(smb);
 714         if (ret < 0)
 715                 goto fail;
 716
 717         ret = smb347_set_current_limits(smb);
 718         if (ret < 0)
 719                 goto fail;
 720
 721         ret = smb347_set_voltage_limits(smb);
 722         if (ret < 0)
 723                 goto fail;
 724
 725         ret = smb347_set_temp_limits(smb);
 726         if (ret < 0)
 727                 goto fail;
 728
 729         /* If USB charging is disabled we put the USB in suspend mode */
 730         if (!smb->use_usb) {
 731                 ret = regmap_update_bits(smb->regmap, CMD_A,
 732                                          CMD_A_SUSPEND_ENABLED,
 733                                          CMD_A_SUSPEND_ENABLED);
 734                 if (ret < 0)
 735                         goto fail;
 736         }
 737
 738         /*
 739          * If configured by platform data, we enable hardware Auto-OTG
 740          * support for driving VBUS. Otherwise we disable it.
 741          */
 742         ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK,
 743                 smb->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0);
 744         if (ret < 0)
 745                 goto fail;
 746
 747         /* Activate pin control, making it writable. */
 748         switch (smb->enable_control) {
 749         case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW:
 750         case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH:
 751                 ret = regmap_set_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL);
 752                 if (ret < 0)
 753                         goto fail;
 754         }
 755
 756         /*
 757          * Make the charging functionality controllable by a write to the
 758          * command register unless pin control is specified in the platform
 759          * data.
 760          */
 761         switch (smb->enable_control) {
 762         case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW:
 763                 val = CFG_PIN_EN_CTRL_ACTIVE_LOW;
 764                 break;
 765         case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH:
 766                 val = CFG_PIN_EN_CTRL_ACTIVE_HIGH;
 767                 break;
 768         default:
 769                 val = 0;
 770                 break;
 771         }
 772
 773         ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK,
 774                                  val);
 775         if (ret < 0)
 776                 goto fail;
 777
 778         /* Disable Automatic Power Source Detection (APSD) interrupt. */
 779         ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0);
 780         if (ret < 0)
 781                 goto fail;
 782
 783         ret = smb347_update_ps_status(smb);
 784         if (ret < 0)
 785                 goto fail;
 786
 787         ret = smb347_start_stop_charging(smb);
 788
 789 fail:
 790         smb347_set_writable(smb, false, false);
 791         return ret;
 792 }
 793
 794 static irqreturn_t smb347_interrupt(int irq, void *data)
 795 {
 796         struct smb347_charger *smb = data;
 797         unsigned int stat_c, irqstat_c, irqstat_d, irqstat_e;
 798         bool handled = false;
 799         int ret;
 800
 801         /* SMB347 it needs at least 20ms for setting IRQSTAT_E_*IN_UV_IRQ */
 802         usleep_range(25000, 35000);
 803
 804         ret = regmap_read(smb->regmap, STAT_C, &stat_c);
 805         if (ret < 0) {
 806                 dev_warn(smb->dev, "reading STAT_C failed\n");
 807                 return IRQ_NONE;
 808         }
 809
 810         ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c);
 811         if (ret < 0) {
 812                 dev_warn(smb->dev, "reading IRQSTAT_C failed\n");
 813                 return IRQ_NONE;
 814         }
 815
 816         ret = regmap_read(smb->regmap, IRQSTAT_D, &irqstat_d);
 817         if (ret < 0) {
 818                 dev_warn(smb->dev, "reading IRQSTAT_D failed\n");
 819                 return IRQ_NONE;
 820         }
 821
 822         ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e);
 823         if (ret < 0) {
 824                 dev_warn(smb->dev, "reading IRQSTAT_E failed\n");
 825                 return IRQ_NONE;
 826         }
 827
 828         /*
 829          * If we get charger error we report the error back to user.
 830          * If the error is recovered charging will resume again.
 831          */
 832         if (stat_c & STAT_C_CHARGER_ERROR) {
 833                 dev_err(smb->dev, "charging stopped due to charger error\n");
 834                 if (smb->use_mains)
 835                         power_supply_changed(smb->mains);
 836                 if (smb->use_usb)
 837                         power_supply_changed(smb->usb);
 838                 handled = true;
 839         }
 840
 841         /*
 842          * If we reached the termination current the battery is charged and
 843          * we can update the status now. Charging is automatically
 844          * disabled by the hardware.
 845          */
 846         if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
 847                 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT) {
 848                         if (smb->use_mains)
 849                                 power_supply_changed(smb->mains);
 850                         if (smb->use_usb)
 851                                 power_supply_changed(smb->usb);
 852                 }
 853                 dev_dbg(smb->dev, "going to HW maintenance mode\n");
 854                 handled = true;
 855         }
 856
 857         /*
 858          * If we got a charger timeout INT that means the charge
 859          * full is not detected with in charge timeout value.
 860          */
 861         if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_IRQ) {
 862                 dev_dbg(smb->dev, "total Charge Timeout INT received\n");
 863
 864                 if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_STAT)
 865                         dev_warn(smb->dev, "charging stopped due to timeout\n");
 866                 if (smb->use_mains)
 867                         power_supply_changed(smb->mains);
 868                 if (smb->use_usb)
 869                         power_supply_changed(smb->usb);
 870                 handled = true;
 871         }
 872
 873         /*
 874          * If we got an under voltage interrupt it means that AC/USB input
 875          * was connected or disconnected.
 876          */
 877         if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
 878                 if (smb347_update_ps_status(smb) > 0) {
 879                         smb347_start_stop_charging(smb);
 880                         if (smb->use_mains)
 881                                 power_supply_changed(smb->mains);
 882                         if (smb->use_usb)
 883                                 power_supply_changed(smb->usb);
 884                 }
 885                 handled = true;
 886         }
 887
 888         return handled ? IRQ_HANDLED : IRQ_NONE;
 889 }
 890
 891 static int smb347_irq_set(struct smb347_charger *smb, bool enable)
 892 {
 893         int ret;
 894
 895         if (smb->irq_unsupported)
 896                 return 0;
 897
 898         ret = smb347_set_writable(smb, true, true);
 899         if (ret < 0)
 900                 return ret;
 901
 902         /*
 903          * Enable/disable interrupts for:
 904          *      - under voltage
 905          *      - termination current reached
 906          *      - charger timeout
 907          *      - charger error
 908          */
 909         ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff,
 910                                  enable ? CFG_FAULT_IRQ_DCIN_UV : 0);
 911         if (ret < 0)
 912                 goto fail;
 913
 914         ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff,
 915                         enable ? (CFG_STATUS_IRQ_TERMINATION_OR_TAPER |
 916                                         CFG_STATUS_IRQ_CHARGE_TIMEOUT) : 0);
 917         if (ret < 0)
 918                 goto fail;
 919
 920         ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR,
 921                                  enable ? CFG_PIN_EN_CHARGER_ERROR : 0);
 922 fail:
 923         smb347_set_writable(smb, false, true);
 924         return ret;
 925 }
 926
 927 static inline int smb347_irq_enable(struct smb347_charger *smb)
 928 {
 929         return smb347_irq_set(smb, true);
 930 }
 931
 932 static inline int smb347_irq_disable(struct smb347_charger *smb)
 933 {
 934         return smb347_irq_set(smb, false);
 935 }
 936
 937 static int smb347_irq_init(struct smb347_charger *smb,
 938                            struct i2c_client *client)
 939 {
 940         int ret;
 941
 942         smb->irq_unsupported = true;
 943
 944         /*
 945          * Interrupt pin is optional. If it is connected, we setup the
 946          * interrupt support here.
 947          */
 948         if (!client->irq)
 949                 return 0;
 950
 951         ret = smb347_set_writable(smb, true, false);
 952         if (ret < 0)
 953                 return ret;
 954
 955         /*
 956          * Configure the STAT output to be suitable for interrupts: disable
 957          * all other output (except interrupts) and make it active low.
 958          */
 959         ret = regmap_update_bits(smb->regmap, CFG_STAT,
 960                                  CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED,
 961                                  CFG_STAT_DISABLED);
 962
 963         smb347_set_writable(smb, false, false);
 964
 965         if (ret < 0) {
 966                 dev_warn(smb->dev, "failed to initialize IRQ: %d\n", ret);
 967                 dev_warn(smb->dev, "disabling IRQ support\n");
 968                 return 0;
 969         }
 970
 971         ret = devm_request_threaded_irq(smb->dev, client->irq, NULL,
 972                                         smb347_interrupt, IRQF_ONESHOT,
 973                                         client->name, smb);
 974         if (ret)
 975                 return ret;
 976
 977         smb->irq_unsupported = false;
 978
 979         ret = smb347_irq_enable(smb);
 980         if (ret < 0)
 981                 return ret;
 982
 983         return 0;
 984 }
 985
 986 /*
 987  * Returns the constant charge current programmed
 988  * into the charger in uA.
 989  */
 990 static int get_const_charge_current(struct smb347_charger *smb)
 991 {
 992         unsigned int id = smb->id;
 993         int ret, intval;
 994         unsigned int v;
 995
 996         if (!smb347_is_ps_online(smb))
 997                 return -ENODATA;
 998
 999         ret = regmap_read(smb->regmap, STAT_B, &v);
1000         if (ret < 0)
1001                 return ret;
1002
1003         /*
1004          * The current value is composition of FCC and PCC values
1005          * and we can detect which table to use from bit 5.
1006          */
1007         if (v & 0x20) {
1008                 intval = hw_to_current(fcc_tbl[id],
1009                                        ARRAY_SIZE(fcc_tbl[id]), v & 7);
1010         } else {
1011                 v >>= 3;
1012                 intval = hw_to_current(pcc_tbl[id],
1013                                        ARRAY_SIZE(pcc_tbl[id]), v & 7);
1014         }
1015
1016         return intval;
1017 }
1018
1019 /*
1020  * Returns the constant charge voltage programmed
1021  * into the charger in uV.
1022  */
1023 static int get_const_charge_voltage(struct smb347_charger *smb)
1024 {
1025         int ret, intval;
1026         unsigned int v;
1027
1028         if (!smb347_is_ps_online(smb))
1029                 return -ENODATA;
1030
1031         ret = regmap_read(smb->regmap, STAT_A, &v);
1032         if (ret < 0)
1033                 return ret;
1034
1035         v &= STAT_A_FLOAT_VOLTAGE_MASK;
1036         if (v > 0x3d)
1037                 v = 0x3d;
1038
1039         intval = 3500000 + v * 20000;
1040
1041         return intval;
1042 }
1043
1044 static int smb347_get_charging_status(struct smb347_charger *smb,
1045                                       struct power_supply *psy)
1046 {
1047         int ret, status;
1048         unsigned int val;
1049
1050         if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
1051                 if (!smb->usb_online)
1052                         return POWER_SUPPLY_STATUS_DISCHARGING;
1053         } else {
1054                 if (!smb->mains_online)
1055                         return POWER_SUPPLY_STATUS_DISCHARGING;
1056         }
1057
1058         ret = regmap_read(smb->regmap, STAT_C, &val);
1059         if (ret < 0)
1060                 return ret;
1061
1062         if ((val & STAT_C_CHARGER_ERROR) ||
1063                         (val & STAT_C_HOLDOFF_STAT)) {
1064                 /*
1065                  * set to NOT CHARGING upon charger error
1066                  * or charging has stopped.
1067                  */
1068                 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1069         } else {
1070                 if ((val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT) {
1071                         /*
1072                          * set to charging if battery is in pre-charge,
1073                          * fast charge or taper charging mode.
1074                          */
1075                         status = POWER_SUPPLY_STATUS_CHARGING;
1076                 } else if (val & STAT_C_CHG_TERM) {
1077                         /*
1078                          * set the status to FULL if battery is not in pre
1079                          * charge, fast charge or taper charging mode AND
1080                          * charging is terminated at least once.
1081                          */
1082                         status = POWER_SUPPLY_STATUS_FULL;
1083                 } else {
1084                         /*
1085                          * in this case no charger error or termination
1086                          * occured but charging is not in progress!!!
1087                          */
1088                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1089                 }
1090         }
1091
1092         return status;
1093 }
1094
1095 static int smb347_get_property_locked(struct power_supply *psy,
1096                                       enum power_supply_property prop,
1097                                       union power_supply_propval *val)
1098 {
1099         struct smb347_charger *smb = power_supply_get_drvdata(psy);
1100         int ret;
1101
1102         switch (prop) {
1103         case POWER_SUPPLY_PROP_STATUS:
1104                 ret = smb347_get_charging_status(smb, psy);
1105                 if (ret < 0)
1106                         return ret;
1107                 val->intval = ret;
1108                 break;
1109
1110         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1111                 if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
1112                         if (!smb->usb_online)
1113                                 return -ENODATA;
1114                 } else {
1115                         if (!smb->mains_online)
1116                                 return -ENODATA;
1117                 }
1118
1119                 /*
1120                  * We handle trickle and pre-charging the same, and taper
1121                  * and none the same.
1122                  */
1123                 switch (smb347_charging_status(smb)) {
1124                 case 1:
1125                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1126                         break;
1127                 case 2:
1128                         val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1129                         break;
1130                 default:
1131                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1132                         break;
1133                 }
1134                 break;
1135
1136         case POWER_SUPPLY_PROP_ONLINE:
1137                 if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
1138                         val->intval = smb->usb_online;
1139                 else
1140                         val->intval = smb->mains_online;
1141                 break;
1142
1143         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1144                 ret = get_const_charge_voltage(smb);
1145                 if (ret < 0)
1146                         return ret;
1147                 val->intval = ret;
1148                 break;
1149
1150         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1151                 ret = get_const_charge_current(smb);
1152                 if (ret < 0)
1153                         return ret;
1154                 val->intval = ret;
1155                 break;
1156
1157         default:
1158                 return -EINVAL;
1159         }
1160
1161         return 0;
1162 }
1163
1164 static int smb347_get_property(struct power_supply *psy,
1165                                enum power_supply_property prop,
1166                                union power_supply_propval *val)
1167 {
1168         struct smb347_charger *smb = power_supply_get_drvdata(psy);
1169         struct i2c_client *client = to_i2c_client(smb->dev);
1170         int ret;
1171
1172         if (!smb->irq_unsupported)
1173                 disable_irq(client->irq);
1174
1175         ret = smb347_get_property_locked(psy, prop, val);
1176
1177         if (!smb->irq_unsupported)
1178                 enable_irq(client->irq);
1179
1180         return ret;
1181 }
1182
1183 static enum power_supply_property smb347_properties[] = {
1184         POWER_SUPPLY_PROP_STATUS,
1185         POWER_SUPPLY_PROP_CHARGE_TYPE,
1186         POWER_SUPPLY_PROP_ONLINE,
1187         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1188         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1189 };
1190
1191 static bool smb347_volatile_reg(struct device *dev, unsigned int reg)
1192 {
1193         switch (reg) {
1194         case IRQSTAT_A:
1195         case IRQSTAT_C:
1196         case IRQSTAT_D:
1197         case IRQSTAT_E:
1198         case IRQSTAT_F:
1199         case STAT_A:
1200         case STAT_B:
1201         case STAT_C:
1202         case STAT_E:
1203                 return true;
1204         }
1205
1206         return false;
1207 }
1208
1209 static bool smb347_readable_reg(struct device *dev, unsigned int reg)
1210 {
1211         switch (reg) {
1212         case CFG_CHARGE_CURRENT:
1213         case CFG_CURRENT_LIMIT:
1214         case CFG_FLOAT_VOLTAGE:
1215         case CFG_STAT:
1216         case CFG_PIN:
1217         case CFG_THERM:
1218         case CFG_SYSOK:
1219         case CFG_OTHER:
1220         case CFG_OTG:
1221         case CFG_TEMP_LIMIT:
1222         case CFG_FAULT_IRQ:
1223         case CFG_STATUS_IRQ:
1224         case CFG_ADDRESS:
1225         case CMD_A:
1226         case CMD_B:
1227         case CMD_C:
1228                 return true;
1229         }
1230
1231         return smb347_volatile_reg(dev, reg);
1232 }
1233
1234 static void smb347_dt_parse_dev_info(struct smb347_charger *smb)
1235 {
1236         struct device *dev = smb->dev;
1237
1238         smb->soft_temp_limit_compensation =
1239                                         SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT;
1240         /*
1241          * These properties come from the battery info, still we need to
1242          * pre-initialize the values. See smb347_get_battery_info() below.
1243          */
1244         smb->soft_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
1245         smb->hard_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
1246         smb->soft_hot_temp_limit  = SMB3XX_TEMP_USE_DEFAULT;
1247         smb->hard_hot_temp_limit  = SMB3XX_TEMP_USE_DEFAULT;
1248
1249         /* Charging constraints */
1250         device_property_read_u32(dev, "summit,fast-voltage-threshold-microvolt",
1251                                  &smb->pre_to_fast_voltage);
1252         device_property_read_u32(dev, "summit,mains-current-limit-microamp",
1253                                  &smb->mains_current_limit);
1254         device_property_read_u32(dev, "summit,usb-current-limit-microamp",
1255                                  &smb->usb_hc_current_limit);
1256
1257         /* For thermometer monitoring */
1258         device_property_read_u32(dev, "summit,chip-temperature-threshold-celsius",
1259                                  &smb->chip_temp_threshold);
1260         device_property_read_u32(dev, "summit,soft-compensation-method",
1261                                  &smb->soft_temp_limit_compensation);
1262         device_property_read_u32(dev, "summit,charge-current-compensation-microamp",
1263                                  &smb->charge_current_compensation);
1264
1265         /* Supported charging mode */
1266         smb->use_mains = device_property_read_bool(dev, "summit,enable-mains-charging");
1267         smb->use_usb = device_property_read_bool(dev, "summit,enable-usb-charging");
1268         smb->use_usb_otg = device_property_read_bool(dev, "summit,enable-otg-charging");
1269
1270         /* Select charging control */
1271         device_property_read_u32(dev, "summit,enable-charge-control",
1272                                  &smb->enable_control);
1273
1274         /*
1275          * Polarity of INOK signal indicating presence of external power
1276          * supply connected to the charger.
1277          */
1278         device_property_read_u32(dev, "summit,inok-polarity",
1279                                  &smb->inok_polarity);
1280 }
1281
1282 static int smb347_get_battery_info(struct smb347_charger *smb)
1283 {
1284         struct power_supply_battery_info *info;
1285         struct power_supply *supply;
1286         int err;
1287
1288         if (smb->mains)
1289                 supply = smb->mains;
1290         else
1291                 supply = smb->usb;
1292
1293         err = power_supply_get_battery_info(supply, &info);
1294         if (err == -ENXIO || err == -ENODEV)
1295                 return 0;
1296         if (err)
1297                 return err;
1298
1299         if (info->constant_charge_current_max_ua != -EINVAL)
1300                 smb->max_charge_current = info->constant_charge_current_max_ua;
1301
1302         if (info->constant_charge_voltage_max_uv != -EINVAL)
1303                 smb->max_charge_voltage = info->constant_charge_voltage_max_uv;
1304
1305         if (info->precharge_current_ua != -EINVAL)
1306                 smb->pre_charge_current = info->precharge_current_ua;
1307
1308         if (info->charge_term_current_ua != -EINVAL)
1309                 smb->termination_current = info->charge_term_current_ua;
1310
1311         if (info->temp_alert_min != INT_MIN)
1312                 smb->soft_cold_temp_limit = info->temp_alert_min;
1313
1314         if (info->temp_alert_max != INT_MAX)
1315                 smb->soft_hot_temp_limit = info->temp_alert_max;
1316
1317         if (info->temp_min != INT_MIN)
1318                 smb->hard_cold_temp_limit = info->temp_min;
1319
1320         if (info->temp_max != INT_MAX)
1321                 smb->hard_hot_temp_limit = info->temp_max;
1322
1323         /* Suspend when battery temperature is outside hard limits */
1324         if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT ||
1325             smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT)
1326                 smb->suspend_on_hard_temp_limit = true;
1327
1328         return 0;
1329 }
1330
1331 static int smb347_usb_vbus_get_current_limit(struct regulator_dev *rdev)
1332 {
1333         struct smb347_charger *smb = rdev_get_drvdata(rdev);
1334         unsigned int val;
1335         int ret;
1336
1337         ret = regmap_read(smb->regmap, CFG_OTG, &val);
1338         if (ret < 0)
1339                 return ret;
1340
1341         /*
1342          * It's unknown what happens if this bit is unset due to lack of
1343          * access to the datasheet, assume it's limit-enable.
1344          */
1345         if (!(val & CFG_OTG_CURRENT_LIMIT_250mA))
1346                 return 0;
1347
1348         return val & CFG_OTG_CURRENT_LIMIT_750mA ? 750000 : 250000;
1349 }
1350
1351 static int smb347_usb_vbus_set_new_current_limit(struct smb347_charger *smb,
1352                                                  int max_uA)
1353 {
1354         const unsigned int mask = CFG_OTG_CURRENT_LIMIT_750mA |
1355                                   CFG_OTG_CURRENT_LIMIT_250mA;
1356         unsigned int val = CFG_OTG_CURRENT_LIMIT_250mA;
1357         int ret;
1358
1359         if (max_uA >= 750000)
1360                 val |= CFG_OTG_CURRENT_LIMIT_750mA;
1361
1362         ret = regmap_update_bits(smb->regmap, CFG_OTG, mask, val);
1363         if (ret < 0)
1364                 dev_err(smb->dev, "failed to change USB current limit\n");
1365
1366         return ret;
1367 }
1368
1369 static int smb347_usb_vbus_set_current_limit(struct regulator_dev *rdev,
1370                                              int min_uA, int max_uA)
1371 {
1372         struct smb347_charger *smb = rdev_get_drvdata(rdev);
1373         int ret;
1374
1375         ret = smb347_set_writable(smb, true, true);
1376         if (ret < 0)
1377                 return ret;
1378
1379         ret = smb347_usb_vbus_set_new_current_limit(smb, max_uA);
1380         smb347_set_writable(smb, false, true);
1381
1382         return ret;
1383 }
1384
1385 static int smb347_usb_vbus_regulator_enable(struct regulator_dev *rdev)
1386 {
1387         struct smb347_charger *smb = rdev_get_drvdata(rdev);
1388         int ret, max_uA;
1389
1390         ret = smb347_set_writable(smb, true, true);
1391         if (ret < 0)
1392                 return ret;
1393
1394         smb347_charging_disable(smb);
1395
1396         if (device_property_read_bool(&rdev->dev, "summit,needs-inok-toggle")) {
1397                 unsigned int sysok = 0;
1398
1399                 if (smb->inok_polarity == SMB3XX_SYSOK_INOK_ACTIVE_LOW)
1400                         sysok = CFG_SYSOK_INOK_ACTIVE_HIGH;
1401
1402                 /*
1403                  * VBUS won't be powered if INOK is active, so we need to
1404                  * manually disable INOK on some platforms.
1405                  */
1406                 ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
1407                                          CFG_SYSOK_INOK_ACTIVE_HIGH, sysok);
1408                 if (ret < 0) {
1409                         dev_err(smb->dev, "failed to disable INOK\n");
1410                         goto done;
1411                 }
1412         }
1413
1414         ret = smb347_usb_vbus_get_current_limit(rdev);
1415         if (ret < 0) {
1416                 dev_err(smb->dev, "failed to get USB VBUS current limit\n");
1417                 goto done;
1418         }
1419
1420         max_uA = ret;
1421
1422         ret = smb347_usb_vbus_set_new_current_limit(smb, 250000);
1423         if (ret < 0) {
1424                 dev_err(smb->dev, "failed to preset USB VBUS current limit\n");
1425                 goto done;
1426         }
1427
1428         ret = regmap_set_bits(smb->regmap, CMD_A, CMD_A_OTG_ENABLED);
1429         if (ret < 0) {
1430                 dev_err(smb->dev, "failed to enable USB VBUS\n");
1431                 goto done;
1432         }
1433
1434         smb->usb_vbus_enabled = true;
1435
1436         ret = smb347_usb_vbus_set_new_current_limit(smb, max_uA);
1437         if (ret < 0) {
1438                 dev_err(smb->dev, "failed to restore USB VBUS current limit\n");
1439                 goto done;
1440         }
1441 done:
1442         smb347_set_writable(smb, false, true);
1443
1444         return ret;
1445 }
1446
1447 static int smb347_usb_vbus_regulator_disable(struct regulator_dev *rdev)
1448 {
1449         struct smb347_charger *smb = rdev_get_drvdata(rdev);
1450         int ret;
1451
1452         ret = smb347_set_writable(smb, true, true);
1453         if (ret < 0)
1454                 return ret;
1455
1456         ret = regmap_clear_bits(smb->regmap, CMD_A, CMD_A_OTG_ENABLED);
1457         if (ret < 0) {
1458                 dev_err(smb->dev, "failed to disable USB VBUS\n");
1459                 goto done;
1460         }
1461
1462         smb->usb_vbus_enabled = false;
1463
1464         if (device_property_read_bool(&rdev->dev, "summit,needs-inok-toggle")) {
1465                 unsigned int sysok = 0;
1466
1467                 if (smb->inok_polarity == SMB3XX_SYSOK_INOK_ACTIVE_HIGH)
1468                         sysok = CFG_SYSOK_INOK_ACTIVE_HIGH;
1469
1470                 ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
1471                                          CFG_SYSOK_INOK_ACTIVE_HIGH, sysok);
1472                 if (ret < 0) {
1473                         dev_err(smb->dev, "failed to enable INOK\n");
1474                         goto done;
1475                 }
1476         }
1477
1478         smb347_start_stop_charging(smb);
1479 done:
1480         smb347_set_writable(smb, false, true);
1481
1482         return ret;
1483 }
1484
1485 static const struct regmap_config smb347_regmap = {
1486         .reg_bits       = 8,
1487         .val_bits       = 8,
1488         .max_register   = SMB347_MAX_REGISTER,
1489         .volatile_reg   = smb347_volatile_reg,
1490         .readable_reg   = smb347_readable_reg,
1491         .cache_type     = REGCACHE_RBTREE,
1492 };
1493
1494 static const struct regulator_ops smb347_usb_vbus_regulator_ops = {
1495         .is_enabled     = regulator_is_enabled_regmap,
1496         .enable         = smb347_usb_vbus_regulator_enable,
1497         .disable        = smb347_usb_vbus_regulator_disable,
1498         .get_current_limit = smb347_usb_vbus_get_current_limit,
1499         .set_current_limit = smb347_usb_vbus_set_current_limit,
1500 };
1501
1502 static const struct power_supply_desc smb347_mains_desc = {
1503         .name           = "smb347-mains",
1504         .type           = POWER_SUPPLY_TYPE_MAINS,
1505         .get_property   = smb347_get_property,
1506         .properties     = smb347_properties,
1507         .num_properties = ARRAY_SIZE(smb347_properties),
1508 };
1509
1510 static const struct power_supply_desc smb347_usb_desc = {
1511         .name           = "smb347-usb",
1512         .type           = POWER_SUPPLY_TYPE_USB,
1513         .get_property   = smb347_get_property,
1514         .properties     = smb347_properties,
1515         .num_properties = ARRAY_SIZE(smb347_properties),
1516 };
1517
1518 static const struct regulator_desc smb347_usb_vbus_regulator_desc = {
1519         .name           = "smb347-usb-vbus",
1520         .of_match       = of_match_ptr("usb-vbus"),
1521         .ops            = &smb347_usb_vbus_regulator_ops,
1522         .type           = REGULATOR_VOLTAGE,
1523         .owner          = THIS_MODULE,
1524         .enable_reg     = CMD_A,
1525         .enable_mask    = CMD_A_OTG_ENABLED,
1526         .enable_val     = CMD_A_OTG_ENABLED,
1527         .fixed_uV       = 5000000,
1528         .n_voltages     = 1,
1529 };
1530
1531 static int smb347_probe(struct i2c_client *client,
1532                         const struct i2c_device_id *id)
1533 {
1534         struct power_supply_config mains_usb_cfg = {};
1535         struct regulator_config usb_rdev_cfg = {};
1536         struct device *dev = &client->dev;
1537         struct smb347_charger *smb;
1538         int ret;
1539
1540         smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1541         if (!smb)
1542                 return -ENOMEM;
1543         smb->dev = &client->dev;
1544         smb->id = id->driver_data;
1545         i2c_set_clientdata(client, smb);
1546
1547         smb347_dt_parse_dev_info(smb);
1548         if (!smb->use_mains && !smb->use_usb)
1549                 return -EINVAL;
1550
1551         smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap);
1552         if (IS_ERR(smb->regmap))
1553                 return PTR_ERR(smb->regmap);
1554
1555         mains_usb_cfg.drv_data = smb;
1556         mains_usb_cfg.of_node = dev->of_node;
1557         if (smb->use_mains) {
1558                 smb->mains = devm_power_supply_register(dev, &smb347_mains_desc,
1559                                                         &mains_usb_cfg);
1560                 if (IS_ERR(smb->mains))
1561                         return PTR_ERR(smb->mains);
1562         }
1563
1564         if (smb->use_usb) {
1565                 smb->usb = devm_power_supply_register(dev, &smb347_usb_desc,
1566                                                       &mains_usb_cfg);
1567                 if (IS_ERR(smb->usb))
1568                         return PTR_ERR(smb->usb);
1569         }
1570
1571         ret = smb347_get_battery_info(smb);
1572         if (ret)
1573                 return ret;
1574
1575         ret = smb347_hw_init(smb);
1576         if (ret < 0)
1577                 return ret;
1578
1579         ret = smb347_irq_init(smb, client);
1580         if (ret)
1581                 return ret;
1582
1583         usb_rdev_cfg.dev = dev;
1584         usb_rdev_cfg.driver_data = smb;
1585         usb_rdev_cfg.regmap = smb->regmap;
1586
1587         smb->usb_rdev = devm_regulator_register(dev,
1588                                                 &smb347_usb_vbus_regulator_desc,
1589                                                 &usb_rdev_cfg);
1590         if (IS_ERR(smb->usb_rdev)) {
1591                 smb347_irq_disable(smb);
1592                 return PTR_ERR(smb->usb_rdev);
1593         }
1594
1595         return 0;
1596 }
1597
1598 static void smb347_remove(struct i2c_client *client)
1599 {
1600         struct smb347_charger *smb = i2c_get_clientdata(client);
1601
1602         smb347_usb_vbus_regulator_disable(smb->usb_rdev);
1603         smb347_irq_disable(smb);
1604 }
1605
1606 static void smb347_shutdown(struct i2c_client *client)
1607 {
1608         smb347_remove(client);
1609 }
1610
1611 static const struct i2c_device_id smb347_id[] = {
1612         { "smb345", SMB345 },
1613         { "smb347", SMB347 },
1614         { "smb358", SMB358 },
1615         { },
1616 };
1617 MODULE_DEVICE_TABLE(i2c, smb347_id);
1618
1619 static const struct of_device_id smb3xx_of_match[] = {
1620         { .compatible = "summit,smb345" },
1621         { .compatible = "summit,smb347" },
1622         { .compatible = "summit,smb358" },
1623         { },
1624 };
1625 MODULE_DEVICE_TABLE(of, smb3xx_of_match);
1626
1627 static struct i2c_driver smb347_driver = {
1628         .driver = {
1629                 .name = "smb347",
1630                 .of_match_table = smb3xx_of_match,
1631         },
1632         .probe = smb347_probe,
1633         .remove = smb347_remove,
1634         .shutdown = smb347_shutdown,
1635         .id_table = smb347_id,
1636 };
1637 module_i2c_driver(smb347_driver);
1638
1639 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1640 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1641 MODULE_DESCRIPTION("SMB347 battery charger driver");
1642 MODULE_LICENSE("GPL");