drivers/power/smb347-charger.c

   1 /*
   2  * Summit Microelectronics SMB347 Battery Charger Driver
   3  *
   4  * Copyright (C) 2011, Intel Corporation
   5  *
   6  * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
   7  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/debugfs.h>
  15 #include <linux/gpio.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/i2c.h>
  21 #include <linux/mutex.h>
  22 #include <linux/power_supply.h>
  23 #include <linux/power/smb347-charger.h>
  24 #include <linux/seq_file.h>
  25
  26 /*
  27  * Configuration registers. These are mirrored to volatile RAM and can be
  28  * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
  29  * reloaded from non-volatile registers after POR.
  30  */
  31 #define CFG_CHARGE_CURRENT                      0x00
  32 #define CFG_CHARGE_CURRENT_FCC_MASK             0xe0
  33 #define CFG_CHARGE_CURRENT_FCC_SHIFT            5
  34 #define CFG_CHARGE_CURRENT_PCC_MASK             0x18
  35 #define CFG_CHARGE_CURRENT_PCC_SHIFT            3
  36 #define CFG_CHARGE_CURRENT_TC_MASK              0x07
  37 #define CFG_CURRENT_LIMIT                       0x01
  38 #define CFG_CURRENT_LIMIT_DC_MASK               0xf0
  39 #define CFG_CURRENT_LIMIT_DC_SHIFT              4
  40 #define CFG_CURRENT_LIMIT_USB_MASK              0x0f
  41 #define CFG_FLOAT_VOLTAGE                       0x03
  42 #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK        0xc0
  43 #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT       6
  44 #define CFG_STAT                                0x05
  45 #define CFG_STAT_DISABLED                       BIT(5)
  46 #define CFG_STAT_ACTIVE_HIGH                    BIT(7)
  47 #define CFG_PIN                                 0x06
  48 #define CFG_PIN_EN_CTRL_MASK                    0x60
  49 #define CFG_PIN_EN_CTRL_ACTIVE_HIGH             0x40
  50 #define CFG_PIN_EN_CTRL_ACTIVE_LOW              0x60
  51 #define CFG_PIN_EN_APSD_IRQ                     BIT(1)
  52 #define CFG_PIN_EN_CHARGER_ERROR                BIT(2)
  53 #define CFG_THERM                               0x07
  54 #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK    0x03
  55 #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT   0
  56 #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK   0x0c
  57 #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT  2
  58 #define CFG_THERM_MONITOR_DISABLED              BIT(4)
  59 #define CFG_SYSOK                               0x08
  60 #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED   BIT(2)
  61 #define CFG_OTHER                               0x09
  62 #define CFG_OTHER_RID_MASK                      0xc0
  63 #define CFG_OTHER_RID_ENABLED_AUTO_OTG          0xc0
  64 #define CFG_OTG                                 0x0a
  65 #define CFG_OTG_TEMP_THRESHOLD_MASK             0x30
  66 #define CFG_OTG_TEMP_THRESHOLD_SHIFT            4
  67 #define CFG_OTG_CC_COMPENSATION_MASK            0xc0
  68 #define CFG_OTG_CC_COMPENSATION_SHIFT           6
  69 #define CFG_TEMP_LIMIT                          0x0b
  70 #define CFG_TEMP_LIMIT_SOFT_HOT_MASK            0x03
  71 #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT           0
  72 #define CFG_TEMP_LIMIT_SOFT_COLD_MASK           0x0c
  73 #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT          2
  74 #define CFG_TEMP_LIMIT_HARD_HOT_MASK            0x30
  75 #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT           4
  76 #define CFG_TEMP_LIMIT_HARD_COLD_MASK           0xc0
  77 #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT          6
  78 #define CFG_FAULT_IRQ                           0x0c
  79 #define CFG_FAULT_IRQ_DCIN_UV                   BIT(2)
  80 #define CFG_STATUS_IRQ                          0x0d
  81 #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER     BIT(4)
  82 #define CFG_ADDRESS                             0x0e
  83
  84 /* Command registers */
  85 #define CMD_A                                   0x30
  86 #define CMD_A_CHG_ENABLED                       BIT(1)
  87 #define CMD_A_SUSPEND_ENABLED                   BIT(2)
  88 #define CMD_A_ALLOW_WRITE                       BIT(7)
  89 #define CMD_B                                   0x31
  90 #define CMD_C                                   0x33
  91
  92 /* Interrupt Status registers */
  93 #define IRQSTAT_A                               0x35
  94 #define IRQSTAT_C                               0x37
  95 #define IRQSTAT_C_TERMINATION_STAT              BIT(0)
  96 #define IRQSTAT_C_TERMINATION_IRQ               BIT(1)
  97 #define IRQSTAT_C_TAPER_IRQ                     BIT(3)
  98 #define IRQSTAT_E                               0x39
  99 #define IRQSTAT_E_USBIN_UV_STAT                 BIT(0)
 100 #define IRQSTAT_E_USBIN_UV_IRQ                  BIT(1)
 101 #define IRQSTAT_E_DCIN_UV_STAT                  BIT(4)
 102 #define IRQSTAT_E_DCIN_UV_IRQ                   BIT(5)
 103 #define IRQSTAT_F                               0x3a
 104
 105 /* Status registers */
 106 #define STAT_A                                  0x3b
 107 #define STAT_A_FLOAT_VOLTAGE_MASK               0x3f
 108 #define STAT_B                                  0x3c
 109 #define STAT_C                                  0x3d
 110 #define STAT_C_CHG_ENABLED                      BIT(0)
 111 #define STAT_C_CHG_MASK                         0x06
 112 #define STAT_C_CHG_SHIFT                        1
 113 #define STAT_C_CHARGER_ERROR                    BIT(6)
 114 #define STAT_E                                  0x3f
 115
 116 /**
 117  * struct smb347_charger - smb347 charger instance
 118  * @lock: protects concurrent access to online variables
 119  * @client: pointer to i2c client
 120  * @mains: power_supply instance for AC/DC power
 121  * @usb: power_supply instance for USB power
 122  * @battery: power_supply instance for battery
 123  * @mains_online: is AC/DC input connected
 124  * @usb_online: is USB input connected
 125  * @charging_enabled: is charging enabled
 126  * @dentry: for debugfs
 127  * @pdata: pointer to platform data
 128  */
 129 struct smb347_charger {
 130         struct mutex            lock;
 131         struct i2c_client       *client;
 132         struct power_supply     mains;
 133         struct power_supply     usb;
 134         struct power_supply     battery;
 135         bool                    mains_online;
 136         bool                    usb_online;
 137         bool                    charging_enabled;
 138         struct dentry           *dentry;
 139         const struct smb347_charger_platform_data *pdata;
 140 };
 141
 142 /* Fast charge current in uA */
 143 static const unsigned int fcc_tbl[] = {
 144         700000,
 145         900000,
 146         1200000,
 147         1500000,
 148         1800000,
 149         2000000,
 150         2200000,
 151         2500000,
 152 };
 153
 154 /* Pre-charge current in uA */
 155 static const unsigned int pcc_tbl[] = {
 156         100000,
 157         150000,
 158         200000,
 159         250000,
 160 };
 161
 162 /* Termination current in uA */
 163 static const unsigned int tc_tbl[] = {
 164         37500,
 165         50000,
 166         100000,
 167         150000,
 168         200000,
 169         250000,
 170         500000,
 171         600000,
 172 };
 173
 174 /* Input current limit in uA */
 175 static const unsigned int icl_tbl[] = {
 176         300000,
 177         500000,
 178         700000,
 179         900000,
 180         1200000,
 181         1500000,
 182         1800000,
 183         2000000,
 184         2200000,
 185         2500000,
 186 };
 187
 188 /* Charge current compensation in uA */
 189 static const unsigned int ccc_tbl[] = {
 190         250000,
 191         700000,
 192         900000,
 193         1200000,
 194 };
 195
 196 /* Convert register value to current using lookup table */
 197 static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
 198 {
 199         if (val >= size)
 200                 return -EINVAL;
 201         return tbl[val];
 202 }
 203
 204 /* Convert current to register value using lookup table */
 205 static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
 206 {
 207         size_t i;
 208
 209         for (i = 0; i < size; i++)
 210                 if (val < tbl[i])
 211                         break;
 212         return i > 0 ? i - 1 : -EINVAL;
 213 }
 214
 215 static int smb347_read(struct smb347_charger *smb, u8 reg)
 216 {
 217         int ret;
 218
 219         ret = i2c_smbus_read_byte_data(smb->client, reg);
 220         if (ret < 0)
 221                 dev_warn(&smb->client->dev, "failed to read reg 0x%x: %d\n",
 222                          reg, ret);
 223         return ret;
 224 }
 225
 226 static int smb347_write(struct smb347_charger *smb, u8 reg, u8 val)
 227 {
 228         int ret;
 229
 230         ret = i2c_smbus_write_byte_data(smb->client, reg, val);
 231         if (ret < 0)
 232                 dev_warn(&smb->client->dev, "failed to write reg 0x%x: %d\n",
 233                          reg, ret);
 234         return ret;
 235 }
 236
 237 /**
 238  * smb347_update_status - updates the charging status
 239  * @smb: pointer to smb347 charger instance
 240  *
 241  * Function checks status of the charging and updates internal state
 242  * accordingly. Returns %0 if there is no change in status, %1 if the
 243  * status has changed and negative errno in case of failure.
 244  */
 245 static int smb347_update_status(struct smb347_charger *smb)
 246 {
 247         bool usb = false;
 248         bool dc = false;
 249         int ret;
 250
 251         ret = smb347_read(smb, IRQSTAT_E);
 252         if (ret < 0)
 253                 return ret;
 254
 255         /*
 256          * Dc and usb are set depending on whether they are enabled in
 257          * platform data _and_ whether corresponding undervoltage is set.
 258          */
 259         if (smb->pdata->use_mains)
 260                 dc = !(ret & IRQSTAT_E_DCIN_UV_STAT);
 261         if (smb->pdata->use_usb)
 262                 usb = !(ret & IRQSTAT_E_USBIN_UV_STAT);
 263
 264         mutex_lock(&smb->lock);
 265         ret = smb->mains_online != dc || smb->usb_online != usb;
 266         smb->mains_online = dc;
 267         smb->usb_online = usb;
 268         mutex_unlock(&smb->lock);
 269
 270         return ret;
 271 }
 272
 273 /*
 274  * smb347_is_online - returns whether input power source is connected
 275  * @smb: pointer to smb347 charger instance
 276  *
 277  * Returns %true if input power source is connected. Note that this is
 278  * dependent on what platform has configured for usable power sources. For
 279  * example if USB is disabled, this will return %false even if the USB
 280  * cable is connected.
 281  */
 282 static bool smb347_is_online(struct smb347_charger *smb)
 283 {
 284         bool ret;
 285
 286         mutex_lock(&smb->lock);
 287         ret = smb->usb_online || smb->mains_online;
 288         mutex_unlock(&smb->lock);
 289
 290         return ret;
 291 }
 292
 293 /**
 294  * smb347_charging_status - returns status of charging
 295  * @smb: pointer to smb347 charger instance
 296  *
 297  * Function returns charging status. %0 means no charging is in progress,
 298  * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
 299  */
 300 static int smb347_charging_status(struct smb347_charger *smb)
 301 {
 302         int ret;
 303
 304         if (!smb347_is_online(smb))
 305                 return 0;
 306
 307         ret = smb347_read(smb, STAT_C);
 308         if (ret < 0)
 309                 return 0;
 310
 311         return (ret & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
 312 }
 313
 314 static int smb347_charging_set(struct smb347_charger *smb, bool enable)
 315 {
 316         int ret = 0;
 317
 318         if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) {
 319                 dev_dbg(&smb->client->dev,
 320                         "charging enable/disable in SW disabled\n");
 321                 return 0;
 322         }
 323
 324         mutex_lock(&smb->lock);
 325         if (smb->charging_enabled != enable) {
 326                 ret = smb347_read(smb, CMD_A);
 327                 if (ret < 0)
 328                         goto out;
 329
 330                 smb->charging_enabled = enable;
 331
 332                 if (enable)
 333                         ret |= CMD_A_CHG_ENABLED;
 334                 else
 335                         ret &= ~CMD_A_CHG_ENABLED;
 336
 337                 ret = smb347_write(smb, CMD_A, ret);
 338         }
 339 out:
 340         mutex_unlock(&smb->lock);
 341         return ret;
 342 }
 343
 344 static inline int smb347_charging_enable(struct smb347_charger *smb)
 345 {
 346         return smb347_charging_set(smb, true);
 347 }
 348
 349 static inline int smb347_charging_disable(struct smb347_charger *smb)
 350 {
 351         return smb347_charging_set(smb, false);
 352 }
 353
 354 static int smb347_update_online(struct smb347_charger *smb)
 355 {
 356         int ret;
 357
 358         /*
 359          * Depending on whether valid power source is connected or not, we
 360          * disable or enable the charging. We do it manually because it
 361          * depends on how the platform has configured the valid inputs.
 362          */
 363         if (smb347_is_online(smb)) {
 364                 ret = smb347_charging_enable(smb);
 365                 if (ret < 0)
 366                         dev_err(&smb->client->dev,
 367                                 "failed to enable charging\n");
 368         } else {
 369                 ret = smb347_charging_disable(smb);
 370                 if (ret < 0)
 371                         dev_err(&smb->client->dev,
 372                                 "failed to disable charging\n");
 373         }
 374
 375         return ret;
 376 }
 377
 378 static int smb347_set_charge_current(struct smb347_charger *smb)
 379 {
 380         int ret, val;
 381
 382         ret = smb347_read(smb, CFG_CHARGE_CURRENT);
 383         if (ret < 0)
 384                 return ret;
 385
 386         if (smb->pdata->max_charge_current) {
 387                 val = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl),
 388                                     smb->pdata->max_charge_current);
 389                 if (val < 0)
 390                         return val;
 391
 392                 ret &= ~CFG_CHARGE_CURRENT_FCC_MASK;
 393                 ret |= val << CFG_CHARGE_CURRENT_FCC_SHIFT;
 394         }
 395
 396         if (smb->pdata->pre_charge_current) {
 397                 val = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl),
 398                                     smb->pdata->pre_charge_current);
 399                 if (val < 0)
 400                         return val;
 401
 402                 ret &= ~CFG_CHARGE_CURRENT_PCC_MASK;
 403                 ret |= val << CFG_CHARGE_CURRENT_PCC_SHIFT;
 404         }
 405
 406         if (smb->pdata->termination_current) {
 407                 val = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl),
 408                                     smb->pdata->termination_current);
 409                 if (val < 0)
 410                         return val;
 411
 412                 ret &= ~CFG_CHARGE_CURRENT_TC_MASK;
 413                 ret |= val;
 414         }
 415
 416         return smb347_write(smb, CFG_CHARGE_CURRENT, ret);
 417 }
 418
 419 static int smb347_set_current_limits(struct smb347_charger *smb)
 420 {
 421         int ret, val;
 422
 423         ret = smb347_read(smb, CFG_CURRENT_LIMIT);
 424         if (ret < 0)
 425                 return ret;
 426
 427         if (smb->pdata->mains_current_limit) {
 428                 val = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
 429                                     smb->pdata->mains_current_limit);
 430                 if (val < 0)
 431                         return val;
 432
 433                 ret &= ~CFG_CURRENT_LIMIT_DC_MASK;
 434                 ret |= val << CFG_CURRENT_LIMIT_DC_SHIFT;
 435         }
 436
 437         if (smb->pdata->usb_hc_current_limit) {
 438                 val = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
 439                                     smb->pdata->usb_hc_current_limit);
 440                 if (val < 0)
 441                         return val;
 442
 443                 ret &= ~CFG_CURRENT_LIMIT_USB_MASK;
 444                 ret |= val;
 445         }
 446
 447         return smb347_write(smb, CFG_CURRENT_LIMIT, ret);
 448 }
 449
 450 static int smb347_set_voltage_limits(struct smb347_charger *smb)
 451 {
 452         int ret, val;
 453
 454         ret = smb347_read(smb, CFG_FLOAT_VOLTAGE);
 455         if (ret < 0)
 456                 return ret;
 457
 458         if (smb->pdata->pre_to_fast_voltage) {
 459                 val = smb->pdata->pre_to_fast_voltage;
 460
 461                 /* uV */
 462                 val = clamp_val(val, 2400000, 3000000) - 2400000;
 463                 val /= 200000;
 464
 465                 ret &= ~CFG_FLOAT_VOLTAGE_THRESHOLD_MASK;
 466                 ret |= val << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT;
 467         }
 468
 469         if (smb->pdata->max_charge_voltage) {
 470                 val = smb->pdata->max_charge_voltage;
 471
 472                 /* uV */
 473                 val = clamp_val(val, 3500000, 4500000) - 3500000;
 474                 val /= 20000;
 475
 476                 ret |= val;
 477         }
 478
 479         return smb347_write(smb, CFG_FLOAT_VOLTAGE, ret);
 480 }
 481
 482 static int smb347_set_temp_limits(struct smb347_charger *smb)
 483 {
 484         bool enable_therm_monitor = false;
 485         int ret, val;
 486
 487         if (smb->pdata->chip_temp_threshold) {
 488                 val = smb->pdata->chip_temp_threshold;
 489
 490                 /* degree C */
 491                 val = clamp_val(val, 100, 130) - 100;
 492                 val /= 10;
 493
 494                 ret = smb347_read(smb, CFG_OTG);
 495                 if (ret < 0)
 496                         return ret;
 497
 498                 ret &= ~CFG_OTG_TEMP_THRESHOLD_MASK;
 499                 ret |= val << CFG_OTG_TEMP_THRESHOLD_SHIFT;
 500
 501                 ret = smb347_write(smb, CFG_OTG, ret);
 502                 if (ret < 0)
 503                         return ret;
 504         }
 505
 506         ret = smb347_read(smb, CFG_TEMP_LIMIT);
 507         if (ret < 0)
 508                 return ret;
 509
 510         if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
 511                 val = smb->pdata->soft_cold_temp_limit;
 512
 513                 val = clamp_val(val, 0, 15);
 514                 val /= 5;
 515                 /* this goes from higher to lower so invert the value */
 516                 val = ~val & 0x3;
 517
 518                 ret &= ~CFG_TEMP_LIMIT_SOFT_COLD_MASK;
 519                 ret |= val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT;
 520
 521                 enable_therm_monitor = true;
 522         }
 523
 524         if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
 525                 val = smb->pdata->soft_hot_temp_limit;
 526
 527                 val = clamp_val(val, 40, 55) - 40;
 528                 val /= 5;
 529
 530                 ret &= ~CFG_TEMP_LIMIT_SOFT_HOT_MASK;
 531                 ret |= val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT;
 532
 533                 enable_therm_monitor = true;
 534         }
 535
 536         if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
 537                 val = smb->pdata->hard_cold_temp_limit;
 538
 539                 val = clamp_val(val, -5, 10) + 5;
 540                 val /= 5;
 541                 /* this goes from higher to lower so invert the value */
 542                 val = ~val & 0x3;
 543
 544                 ret &= ~CFG_TEMP_LIMIT_HARD_COLD_MASK;
 545                 ret |= val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT;
 546
 547                 enable_therm_monitor = true;
 548         }
 549
 550         if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
 551                 val = smb->pdata->hard_hot_temp_limit;
 552
 553                 val = clamp_val(val, 50, 65) - 50;
 554                 val /= 5;
 555
 556                 ret &= ~CFG_TEMP_LIMIT_HARD_HOT_MASK;
 557                 ret |= val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT;
 558
 559                 enable_therm_monitor = true;
 560         }
 561
 562         ret = smb347_write(smb, CFG_TEMP_LIMIT, ret);
 563         if (ret < 0)
 564                 return ret;
 565
 566         /*
 567          * If any of the temperature limits are set, we also enable the
 568          * thermistor monitoring.
 569          *
 570          * When soft limits are hit, the device will start to compensate
 571          * current and/or voltage depending on the configuration.
 572          *
 573          * When hard limit is hit, the device will suspend charging
 574          * depending on the configuration.
 575          */
 576         if (enable_therm_monitor) {
 577                 ret = smb347_read(smb, CFG_THERM);
 578                 if (ret < 0)
 579                         return ret;
 580
 581                 ret &= ~CFG_THERM_MONITOR_DISABLED;
 582
 583                 ret = smb347_write(smb, CFG_THERM, ret);
 584                 if (ret < 0)
 585                         return ret;
 586         }
 587
 588         if (smb->pdata->suspend_on_hard_temp_limit) {
 589                 ret = smb347_read(smb, CFG_SYSOK);
 590                 if (ret < 0)
 591                         return ret;
 592
 593                 ret &= ~CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED;
 594
 595                 ret = smb347_write(smb, CFG_SYSOK, ret);
 596                 if (ret < 0)
 597                         return ret;
 598         }
 599
 600         if (smb->pdata->soft_temp_limit_compensation !=
 601             SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) {
 602                 val = smb->pdata->soft_temp_limit_compensation & 0x3;
 603
 604                 ret = smb347_read(smb, CFG_THERM);
 605                 if (ret < 0)
 606                         return ret;
 607
 608                 ret &= ~CFG_THERM_SOFT_HOT_COMPENSATION_MASK;
 609                 ret |= val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT;
 610
 611                 ret &= ~CFG_THERM_SOFT_COLD_COMPENSATION_MASK;
 612                 ret |= val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT;
 613
 614                 ret = smb347_write(smb, CFG_THERM, ret);
 615                 if (ret < 0)
 616                         return ret;
 617         }
 618
 619         if (smb->pdata->charge_current_compensation) {
 620                 val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl),
 621                                     smb->pdata->charge_current_compensation);
 622                 if (val < 0)
 623                         return val;
 624
 625                 ret = smb347_read(smb, CFG_OTG);
 626                 if (ret < 0)
 627                         return ret;
 628
 629                 ret &= ~CFG_OTG_CC_COMPENSATION_MASK;
 630                 ret |= (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT;
 631
 632                 ret = smb347_write(smb, CFG_OTG, ret);
 633                 if (ret < 0)
 634                         return ret;
 635         }
 636
 637         return ret;
 638 }
 639
 640 /*
 641  * smb347_set_writable - enables/disables writing to non-volatile registers
 642  * @smb: pointer to smb347 charger instance
 643  *
 644  * You can enable/disable writing to the non-volatile configuration
 645  * registers by calling this function.
 646  *
 647  * Returns %0 on success and negative errno in case of failure.
 648  */
 649 static int smb347_set_writable(struct smb347_charger *smb, bool writable)
 650 {
 651         int ret;
 652
 653         ret = smb347_read(smb, CMD_A);
 654         if (ret < 0)
 655                 return ret;
 656
 657         if (writable)
 658                 ret |= CMD_A_ALLOW_WRITE;
 659         else
 660                 ret &= ~CMD_A_ALLOW_WRITE;
 661
 662         return smb347_write(smb, CMD_A, ret);
 663 }
 664
 665 static int smb347_hw_init(struct smb347_charger *smb)
 666 {
 667         int ret;
 668
 669         ret = smb347_set_writable(smb, true);
 670         if (ret < 0)
 671                 return ret;
 672
 673         /*
 674          * Program the platform specific configuration values to the device
 675          * first.
 676          */
 677         ret = smb347_set_charge_current(smb);
 678         if (ret < 0)
 679                 goto fail;
 680
 681         ret = smb347_set_current_limits(smb);
 682         if (ret < 0)
 683                 goto fail;
 684
 685         ret = smb347_set_voltage_limits(smb);
 686         if (ret < 0)
 687                 goto fail;
 688
 689         ret = smb347_set_temp_limits(smb);
 690         if (ret < 0)
 691                 goto fail;
 692
 693         /* If USB charging is disabled we put the USB in suspend mode */
 694         if (!smb->pdata->use_usb) {
 695                 ret = smb347_read(smb, CMD_A);
 696                 if (ret < 0)
 697                         goto fail;
 698
 699                 ret |= CMD_A_SUSPEND_ENABLED;
 700
 701                 ret = smb347_write(smb, CMD_A, ret);
 702                 if (ret < 0)
 703                         goto fail;
 704         }
 705
 706         ret = smb347_read(smb, CFG_OTHER);
 707         if (ret < 0)
 708                 goto fail;
 709
 710         /*
 711          * If configured by platform data, we enable hardware Auto-OTG
 712          * support for driving VBUS. Otherwise we disable it.
 713          */
 714         ret &= ~CFG_OTHER_RID_MASK;
 715         if (smb->pdata->use_usb_otg)
 716                 ret |= CFG_OTHER_RID_ENABLED_AUTO_OTG;
 717
 718         ret = smb347_write(smb, CFG_OTHER, ret);
 719         if (ret < 0)
 720                 goto fail;
 721
 722         ret = smb347_read(smb, CFG_PIN);
 723         if (ret < 0)
 724                 goto fail;
 725
 726         /*
 727          * Make the charging functionality controllable by a write to the
 728          * command register unless pin control is specified in the platform
 729          * data.
 730          */
 731         ret &= ~CFG_PIN_EN_CTRL_MASK;
 732
 733         switch (smb->pdata->enable_control) {
 734         case SMB347_CHG_ENABLE_SW:
 735                 /* Do nothing, 0 means i2c control */
 736                 break;
 737         case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW:
 738                 ret |= CFG_PIN_EN_CTRL_ACTIVE_LOW;
 739                 break;
 740         case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH:
 741                 ret |= CFG_PIN_EN_CTRL_ACTIVE_HIGH;
 742                 break;
 743         }
 744
 745         /* Disable Automatic Power Source Detection (APSD) interrupt. */
 746         ret &= ~CFG_PIN_EN_APSD_IRQ;
 747
 748         ret = smb347_write(smb, CFG_PIN, ret);
 749         if (ret < 0)
 750                 goto fail;
 751
 752         ret = smb347_update_status(smb);
 753         if (ret < 0)
 754                 goto fail;
 755
 756         ret = smb347_update_online(smb);
 757
 758 fail:
 759         smb347_set_writable(smb, false);
 760         return ret;
 761 }
 762
 763 static irqreturn_t smb347_interrupt(int irq, void *data)
 764 {
 765         struct smb347_charger *smb = data;
 766         int stat_c, irqstat_e, irqstat_c;
 767         irqreturn_t ret = IRQ_NONE;
 768
 769         stat_c = smb347_read(smb, STAT_C);
 770         if (stat_c < 0) {
 771                 dev_warn(&smb->client->dev, "reading STAT_C failed\n");
 772                 return IRQ_NONE;
 773         }
 774
 775         irqstat_c = smb347_read(smb, IRQSTAT_C);
 776         if (irqstat_c < 0) {
 777                 dev_warn(&smb->client->dev, "reading IRQSTAT_C failed\n");
 778                 return IRQ_NONE;
 779         }
 780
 781         irqstat_e = smb347_read(smb, IRQSTAT_E);
 782         if (irqstat_e < 0) {
 783                 dev_warn(&smb->client->dev, "reading IRQSTAT_E failed\n");
 784                 return IRQ_NONE;
 785         }
 786
 787         /*
 788          * If we get charger error we report the error back to user and
 789          * disable charging.
 790          */
 791         if (stat_c & STAT_C_CHARGER_ERROR) {
 792                 dev_err(&smb->client->dev,
 793                         "error in charger, disabling charging\n");
 794
 795                 smb347_charging_disable(smb);
 796                 power_supply_changed(&smb->battery);
 797
 798                 ret = IRQ_HANDLED;
 799         }
 800
 801         /*
 802          * If we reached the termination current the battery is charged and
 803          * we can update the status now. Charging is automatically
 804          * disabled by the hardware.
 805          */
 806         if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
 807                 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT)
 808                         power_supply_changed(&smb->battery);
 809                 ret = IRQ_HANDLED;
 810         }
 811
 812         /*
 813          * If we got an under voltage interrupt it means that AC/USB input
 814          * was connected or disconnected.
 815          */
 816         if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
 817                 if (smb347_update_status(smb) > 0) {
 818                         smb347_update_online(smb);
 819                         power_supply_changed(&smb->mains);
 820                         power_supply_changed(&smb->usb);
 821                 }
 822                 ret = IRQ_HANDLED;
 823         }
 824
 825         return ret;
 826 }
 827
 828 static int smb347_irq_set(struct smb347_charger *smb, bool enable)
 829 {
 830         int ret;
 831
 832         ret = smb347_set_writable(smb, true);
 833         if (ret < 0)
 834                 return ret;
 835
 836         /*
 837          * Enable/disable interrupts for:
 838          *      - under voltage
 839          *      - termination current reached
 840          *      - charger error
 841          */
 842         if (enable) {
 843                 ret = smb347_write(smb, CFG_FAULT_IRQ, CFG_FAULT_IRQ_DCIN_UV);
 844                 if (ret < 0)
 845                         goto fail;
 846
 847                 ret = smb347_write(smb, CFG_STATUS_IRQ,
 848                                    CFG_STATUS_IRQ_TERMINATION_OR_TAPER);
 849                 if (ret < 0)
 850                         goto fail;
 851
 852                 ret = smb347_read(smb, CFG_PIN);
 853                 if (ret < 0)
 854                         goto fail;
 855
 856                 ret |= CFG_PIN_EN_CHARGER_ERROR;
 857
 858                 ret = smb347_write(smb, CFG_PIN, ret);
 859         } else {
 860                 ret = smb347_write(smb, CFG_FAULT_IRQ, 0);
 861                 if (ret < 0)
 862                         goto fail;
 863
 864                 ret = smb347_write(smb, CFG_STATUS_IRQ, 0);
 865                 if (ret < 0)
 866                         goto fail;
 867
 868                 ret = smb347_read(smb, CFG_PIN);
 869                 if (ret < 0)
 870                         goto fail;
 871
 872                 ret &= ~CFG_PIN_EN_CHARGER_ERROR;
 873
 874                 ret = smb347_write(smb, CFG_PIN, ret);
 875         }
 876
 877 fail:
 878         smb347_set_writable(smb, false);
 879         return ret;
 880 }
 881
 882 static inline int smb347_irq_enable(struct smb347_charger *smb)
 883 {
 884         return smb347_irq_set(smb, true);
 885 }
 886
 887 static inline int smb347_irq_disable(struct smb347_charger *smb)
 888 {
 889         return smb347_irq_set(smb, false);
 890 }
 891
 892 static int smb347_irq_init(struct smb347_charger *smb)
 893 {
 894         const struct smb347_charger_platform_data *pdata = smb->pdata;
 895         int ret, irq = gpio_to_irq(pdata->irq_gpio);
 896
 897         ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, smb->client->name);
 898         if (ret < 0)
 899                 goto fail;
 900
 901         ret = request_threaded_irq(irq, NULL, smb347_interrupt,
 902                                    IRQF_TRIGGER_FALLING, smb->client->name,
 903                                    smb);
 904         if (ret < 0)
 905                 goto fail_gpio;
 906
 907         ret = smb347_set_writable(smb, true);
 908         if (ret < 0)
 909                 goto fail_irq;
 910
 911         /*
 912          * Configure the STAT output to be suitable for interrupts: disable
 913          * all other output (except interrupts) and make it active low.
 914          */
 915         ret = smb347_read(smb, CFG_STAT);
 916         if (ret < 0)
 917                 goto fail_readonly;
 918
 919         ret &= ~CFG_STAT_ACTIVE_HIGH;
 920         ret |= CFG_STAT_DISABLED;
 921
 922         ret = smb347_write(smb, CFG_STAT, ret);
 923         if (ret < 0)
 924                 goto fail_readonly;
 925
 926         ret = smb347_irq_enable(smb);
 927         if (ret < 0)
 928                 goto fail_readonly;
 929
 930         smb347_set_writable(smb, false);
 931         smb->client->irq = irq;
 932         return 0;
 933
 934 fail_readonly:
 935         smb347_set_writable(smb, false);
 936 fail_irq:
 937         free_irq(irq, smb);
 938 fail_gpio:
 939         gpio_free(pdata->irq_gpio);
 940 fail:
 941         smb->client->irq = 0;
 942         return ret;
 943 }
 944
 945 static int smb347_mains_get_property(struct power_supply *psy,
 946                                      enum power_supply_property prop,
 947                                      union power_supply_propval *val)
 948 {
 949         struct smb347_charger *smb =
 950                 container_of(psy, struct smb347_charger, mains);
 951
 952         if (prop == POWER_SUPPLY_PROP_ONLINE) {
 953                 val->intval = smb->mains_online;
 954                 return 0;
 955         }
 956         return -EINVAL;
 957 }
 958
 959 static enum power_supply_property smb347_mains_properties[] = {
 960         POWER_SUPPLY_PROP_ONLINE,
 961 };
 962
 963 static int smb347_usb_get_property(struct power_supply *psy,
 964                                    enum power_supply_property prop,
 965                                    union power_supply_propval *val)
 966 {
 967         struct smb347_charger *smb =
 968                 container_of(psy, struct smb347_charger, usb);
 969
 970         if (prop == POWER_SUPPLY_PROP_ONLINE) {
 971                 val->intval = smb->usb_online;
 972                 return 0;
 973         }
 974         return -EINVAL;
 975 }
 976
 977 static enum power_supply_property smb347_usb_properties[] = {
 978         POWER_SUPPLY_PROP_ONLINE,
 979 };
 980
 981 static int smb347_battery_get_property(struct power_supply *psy,
 982                                        enum power_supply_property prop,
 983                                        union power_supply_propval *val)
 984 {
 985         struct smb347_charger *smb =
 986                         container_of(psy, struct smb347_charger, battery);
 987         const struct smb347_charger_platform_data *pdata = smb->pdata;
 988         int ret;
 989
 990         ret = smb347_update_status(smb);
 991         if (ret < 0)
 992                 return ret;
 993
 994         switch (prop) {
 995         case POWER_SUPPLY_PROP_STATUS:
 996                 if (!smb347_is_online(smb)) {
 997                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 998                         break;
 999                 }
1000                 if (smb347_charging_status(smb))
1001                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
1002                 else
1003                         val->intval = POWER_SUPPLY_STATUS_FULL;
1004                 break;
1005
1006         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1007                 if (!smb347_is_online(smb))
1008                         return -ENODATA;
1009
1010                 /*
1011                  * We handle trickle and pre-charging the same, and taper
1012                  * and none the same.
1013                  */
1014                 switch (smb347_charging_status(smb)) {
1015                 case 1:
1016                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1017                         break;
1018                 case 2:
1019                         val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1020                         break;
1021                 default:
1022                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1023                         break;
1024                 }
1025                 break;
1026
1027         case POWER_SUPPLY_PROP_TECHNOLOGY:
1028                 val->intval = pdata->battery_info.technology;
1029                 break;
1030
1031         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1032                 val->intval = pdata->battery_info.voltage_min_design;
1033                 break;
1034
1035         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1036                 val->intval = pdata->battery_info.voltage_max_design;
1037                 break;
1038
1039         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1040                 if (!smb347_is_online(smb))
1041                         return -ENODATA;
1042                 ret = smb347_read(smb, STAT_A);
1043                 if (ret < 0)
1044                         return ret;
1045
1046                 ret &= STAT_A_FLOAT_VOLTAGE_MASK;
1047                 if (ret > 0x3d)
1048                         ret = 0x3d;
1049
1050                 val->intval = 3500000 + ret * 20000;
1051                 break;
1052
1053         case POWER_SUPPLY_PROP_CURRENT_NOW:
1054                 if (!smb347_is_online(smb))
1055                         return -ENODATA;
1056
1057                 ret = smb347_read(smb, STAT_B);
1058                 if (ret < 0)
1059                         return ret;
1060
1061                 /*
1062                  * The current value is composition of FCC and PCC values
1063                  * and we can detect which table to use from bit 5.
1064                  */
1065                 if (ret & 0x20) {
1066                         val->intval = hw_to_current(fcc_tbl,
1067                                                     ARRAY_SIZE(fcc_tbl),
1068                                                     ret & 7);
1069                 } else {
1070                         ret >>= 3;
1071                         val->intval = hw_to_current(pcc_tbl,
1072                                                     ARRAY_SIZE(pcc_tbl),
1073                                                     ret & 7);
1074                 }
1075                 break;
1076
1077         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1078                 val->intval = pdata->battery_info.charge_full_design;
1079                 break;
1080
1081         case POWER_SUPPLY_PROP_MODEL_NAME:
1082                 val->strval = pdata->battery_info.name;
1083                 break;
1084
1085         default:
1086                 return -EINVAL;
1087         }
1088
1089         return 0;
1090 }
1091
1092 static enum power_supply_property smb347_battery_properties[] = {
1093         POWER_SUPPLY_PROP_STATUS,
1094         POWER_SUPPLY_PROP_CHARGE_TYPE,
1095         POWER_SUPPLY_PROP_TECHNOLOGY,
1096         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1097         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1098         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1099         POWER_SUPPLY_PROP_CURRENT_NOW,
1100         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1101         POWER_SUPPLY_PROP_MODEL_NAME,
1102 };
1103
1104 static int smb347_debugfs_show(struct seq_file *s, void *data)
1105 {
1106         struct smb347_charger *smb = s->private;
1107         int ret;
1108         u8 reg;
1109
1110         seq_printf(s, "Control registers:\n");
1111         seq_printf(s, "==================\n");
1112         for (reg = CFG_CHARGE_CURRENT; reg <= CFG_ADDRESS; reg++) {
1113                 ret = smb347_read(smb, reg);
1114                 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1115         }
1116         seq_printf(s, "\n");
1117
1118         seq_printf(s, "Command registers:\n");
1119         seq_printf(s, "==================\n");
1120         ret = smb347_read(smb, CMD_A);
1121         seq_printf(s, "0x%02x:\t0x%02x\n", CMD_A, ret);
1122         ret = smb347_read(smb, CMD_B);
1123         seq_printf(s, "0x%02x:\t0x%02x\n", CMD_B, ret);
1124         ret = smb347_read(smb, CMD_C);
1125         seq_printf(s, "0x%02x:\t0x%02x\n", CMD_C, ret);
1126         seq_printf(s, "\n");
1127
1128         seq_printf(s, "Interrupt status registers:\n");
1129         seq_printf(s, "===========================\n");
1130         for (reg = IRQSTAT_A; reg <= IRQSTAT_F; reg++) {
1131                 ret = smb347_read(smb, reg);
1132                 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1133         }
1134         seq_printf(s, "\n");
1135
1136         seq_printf(s, "Status registers:\n");
1137         seq_printf(s, "=================\n");
1138         for (reg = STAT_A; reg <= STAT_E; reg++) {
1139                 ret = smb347_read(smb, reg);
1140                 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1141         }
1142
1143         return 0;
1144 }
1145
1146 static int smb347_debugfs_open(struct inode *inode, struct file *file)
1147 {
1148         return single_open(file, smb347_debugfs_show, inode->i_private);
1149 }
1150
1151 static const struct file_operations smb347_debugfs_fops = {
1152         .open           = smb347_debugfs_open,
1153         .read           = seq_read,
1154         .llseek         = seq_lseek,
1155         .release        = single_release,
1156 };
1157
1158 static int smb347_probe(struct i2c_client *client,
1159                         const struct i2c_device_id *id)
1160 {
1161         static char *battery[] = { "smb347-battery" };
1162         const struct smb347_charger_platform_data *pdata;
1163         struct device *dev = &client->dev;
1164         struct smb347_charger *smb;
1165         int ret;
1166
1167         pdata = dev->platform_data;
1168         if (!pdata)
1169                 return -EINVAL;
1170
1171         if (!pdata->use_mains && !pdata->use_usb)
1172                 return -EINVAL;
1173
1174         smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1175         if (!smb)
1176                 return -ENOMEM;
1177
1178         i2c_set_clientdata(client, smb);
1179
1180         mutex_init(&smb->lock);
1181         smb->client = client;
1182         smb->pdata = pdata;
1183
1184         ret = smb347_hw_init(smb);
1185         if (ret < 0)
1186                 return ret;
1187
1188         smb->mains.name = "smb347-mains";
1189         smb->mains.type = POWER_SUPPLY_TYPE_MAINS;
1190         smb->mains.get_property = smb347_mains_get_property;
1191         smb->mains.properties = smb347_mains_properties;
1192         smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties);
1193         smb->mains.supplied_to = battery;
1194         smb->mains.num_supplicants = ARRAY_SIZE(battery);
1195
1196         smb->usb.name = "smb347-usb";
1197         smb->usb.type = POWER_SUPPLY_TYPE_USB;
1198         smb->usb.get_property = smb347_usb_get_property;
1199         smb->usb.properties = smb347_usb_properties;
1200         smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties);
1201         smb->usb.supplied_to = battery;
1202         smb->usb.num_supplicants = ARRAY_SIZE(battery);
1203
1204         smb->battery.name = "smb347-battery";
1205         smb->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1206         smb->battery.get_property = smb347_battery_get_property;
1207         smb->battery.properties = smb347_battery_properties;
1208         smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties);
1209
1210         ret = power_supply_register(dev, &smb->mains);
1211         if (ret < 0)
1212                 return ret;
1213
1214         ret = power_supply_register(dev, &smb->usb);
1215         if (ret < 0) {
1216                 power_supply_unregister(&smb->mains);
1217                 return ret;
1218         }
1219
1220         ret = power_supply_register(dev, &smb->battery);
1221         if (ret < 0) {
1222                 power_supply_unregister(&smb->usb);
1223                 power_supply_unregister(&smb->mains);
1224                 return ret;
1225         }
1226
1227         /*
1228          * Interrupt pin is optional. If it is connected, we setup the
1229          * interrupt support here.
1230          */
1231         if (pdata->irq_gpio >= 0) {
1232                 ret = smb347_irq_init(smb);
1233                 if (ret < 0) {
1234                         dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
1235                         dev_warn(dev, "disabling IRQ support\n");
1236                 }
1237         }
1238
1239         smb->dentry = debugfs_create_file("smb347-regs", S_IRUSR, NULL, smb,
1240                                           &smb347_debugfs_fops);
1241         return 0;
1242 }
1243
1244 static int smb347_remove(struct i2c_client *client)
1245 {
1246         struct smb347_charger *smb = i2c_get_clientdata(client);
1247
1248         if (!IS_ERR_OR_NULL(smb->dentry))
1249                 debugfs_remove(smb->dentry);
1250
1251         if (client->irq) {
1252                 smb347_irq_disable(smb);
1253                 free_irq(client->irq, smb);
1254                 gpio_free(smb->pdata->irq_gpio);
1255         }
1256
1257         power_supply_unregister(&smb->battery);
1258         power_supply_unregister(&smb->usb);
1259         power_supply_unregister(&smb->mains);
1260         return 0;
1261 }
1262
1263 static const struct i2c_device_id smb347_id[] = {
1264         { "smb347", 0 },
1265         { }
1266 };
1267 MODULE_DEVICE_TABLE(i2c, smb347_id);
1268
1269 static struct i2c_driver smb347_driver = {
1270         .driver = {
1271                 .name = "smb347",
1272         },
1273         .probe        = smb347_probe,
1274         .remove       = __devexit_p(smb347_remove),
1275         .id_table     = smb347_id,
1276 };
1277
1278 static int __init smb347_init(void)
1279 {
1280         return i2c_add_driver(&smb347_driver);
1281 }
1282 module_init(smb347_init);
1283
1284 static void __exit smb347_exit(void)
1285 {
1286         i2c_del_driver(&smb347_driver);
1287 }
1288 module_exit(smb347_exit);
1289
1290 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1291 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1292 MODULE_DESCRIPTION("SMB347 battery charger driver");
1293 MODULE_LICENSE("GPL");
1294 MODULE_ALIAS("i2c:smb347");