linux/drivers/power/sbs-battery.c
<<
>>
Prefs
   1/*
   2 * Gas Gauge driver for SBS Compliant Batteries
   3 *
   4 * Copyright (c) 2010, NVIDIA Corporation.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful, but WITHOUT
  12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14 * more details.
  15 *
  16 * You should have received a copy of the GNU General Public License along
  17 * with this program; if not, write to the Free Software Foundation, Inc.,
  18 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21#include <linux/init.h>
  22#include <linux/module.h>
  23#include <linux/kernel.h>
  24#include <linux/err.h>
  25#include <linux/power_supply.h>
  26#include <linux/i2c.h>
  27#include <linux/slab.h>
  28#include <linux/interrupt.h>
  29#include <linux/gpio.h>
  30#include <linux/of.h>
  31
  32#include <linux/power/sbs-battery.h>
  33
  34enum {
  35        REG_MANUFACTURER_DATA,
  36        REG_TEMPERATURE,
  37        REG_VOLTAGE,
  38        REG_CURRENT,
  39        REG_CAPACITY,
  40        REG_TIME_TO_EMPTY,
  41        REG_TIME_TO_FULL,
  42        REG_STATUS,
  43        REG_CYCLE_COUNT,
  44        REG_SERIAL_NUMBER,
  45        REG_REMAINING_CAPACITY,
  46        REG_REMAINING_CAPACITY_CHARGE,
  47        REG_FULL_CHARGE_CAPACITY,
  48        REG_FULL_CHARGE_CAPACITY_CHARGE,
  49        REG_DESIGN_CAPACITY,
  50        REG_DESIGN_CAPACITY_CHARGE,
  51        REG_DESIGN_VOLTAGE,
  52};
  53
  54/* Battery Mode defines */
  55#define BATTERY_MODE_OFFSET             0x03
  56#define BATTERY_MODE_MASK               0x8000
  57enum sbs_battery_mode {
  58        BATTERY_MODE_AMPS,
  59        BATTERY_MODE_WATTS
  60};
  61
  62/* manufacturer access defines */
  63#define MANUFACTURER_ACCESS_STATUS      0x0006
  64#define MANUFACTURER_ACCESS_SLEEP       0x0011
  65
  66/* battery status value bits */
  67#define BATTERY_DISCHARGING             0x40
  68#define BATTERY_FULL_CHARGED            0x20
  69#define BATTERY_FULL_DISCHARGED         0x10
  70
  71#define SBS_DATA(_psp, _addr, _min_value, _max_value) { \
  72        .psp = _psp, \
  73        .addr = _addr, \
  74        .min_value = _min_value, \
  75        .max_value = _max_value, \
  76}
  77
  78static const struct chip_data {
  79        enum power_supply_property psp;
  80        u8 addr;
  81        int min_value;
  82        int max_value;
  83} sbs_data[] = {
  84        [REG_MANUFACTURER_DATA] =
  85                SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
  86        [REG_TEMPERATURE] =
  87                SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
  88        [REG_VOLTAGE] =
  89                SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
  90        [REG_CURRENT] =
  91                SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767),
  92        [REG_CAPACITY] =
  93                SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0D, 0, 100),
  94        [REG_REMAINING_CAPACITY] =
  95                SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
  96        [REG_REMAINING_CAPACITY_CHARGE] =
  97                SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
  98        [REG_FULL_CHARGE_CAPACITY] =
  99                SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
 100        [REG_FULL_CHARGE_CAPACITY_CHARGE] =
 101                SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
 102        [REG_TIME_TO_EMPTY] =
 103                SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535),
 104        [REG_TIME_TO_FULL] =
 105                SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535),
 106        [REG_STATUS] =
 107                SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
 108        [REG_CYCLE_COUNT] =
 109                SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
 110        [REG_DESIGN_CAPACITY] =
 111                SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535),
 112        [REG_DESIGN_CAPACITY_CHARGE] =
 113                SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535),
 114        [REG_DESIGN_VOLTAGE] =
 115                SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535),
 116        [REG_SERIAL_NUMBER] =
 117                SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
 118};
 119
 120static enum power_supply_property sbs_properties[] = {
 121        POWER_SUPPLY_PROP_STATUS,
 122        POWER_SUPPLY_PROP_HEALTH,
 123        POWER_SUPPLY_PROP_PRESENT,
 124        POWER_SUPPLY_PROP_TECHNOLOGY,
 125        POWER_SUPPLY_PROP_CYCLE_COUNT,
 126        POWER_SUPPLY_PROP_VOLTAGE_NOW,
 127        POWER_SUPPLY_PROP_CURRENT_NOW,
 128        POWER_SUPPLY_PROP_CAPACITY,
 129        POWER_SUPPLY_PROP_TEMP,
 130        POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
 131        POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
 132        POWER_SUPPLY_PROP_SERIAL_NUMBER,
 133        POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 134        POWER_SUPPLY_PROP_ENERGY_NOW,
 135        POWER_SUPPLY_PROP_ENERGY_FULL,
 136        POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 137        POWER_SUPPLY_PROP_CHARGE_NOW,
 138        POWER_SUPPLY_PROP_CHARGE_FULL,
 139        POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 140};
 141
 142struct sbs_info {
 143        struct i2c_client               *client;
 144        struct power_supply             power_supply;
 145        struct sbs_platform_data        *pdata;
 146        bool                            is_present;
 147        bool                            gpio_detect;
 148        bool                            enable_detection;
 149        int                             irq;
 150        int                             last_state;
 151        int                             poll_time;
 152        struct delayed_work             work;
 153        int                             ignore_changes;
 154};
 155
 156static int sbs_read_word_data(struct i2c_client *client, u8 address)
 157{
 158        struct sbs_info *chip = i2c_get_clientdata(client);
 159        s32 ret = 0;
 160        int retries = 1;
 161
 162        if (chip->pdata)
 163                retries = max(chip->pdata->i2c_retry_count + 1, 1);
 164
 165        while (retries > 0) {
 166                ret = i2c_smbus_read_word_data(client, address);
 167                if (ret >= 0)
 168                        break;
 169                retries--;
 170        }
 171
 172        if (ret < 0) {
 173                dev_dbg(&client->dev,
 174                        "%s: i2c read at address 0x%x failed\n",
 175                        __func__, address);
 176                return ret;
 177        }
 178
 179        return le16_to_cpu(ret);
 180}
 181
 182static int sbs_write_word_data(struct i2c_client *client, u8 address,
 183        u16 value)
 184{
 185        struct sbs_info *chip = i2c_get_clientdata(client);
 186        s32 ret = 0;
 187        int retries = 1;
 188
 189        if (chip->pdata)
 190                retries = max(chip->pdata->i2c_retry_count + 1, 1);
 191
 192        while (retries > 0) {
 193                ret = i2c_smbus_write_word_data(client, address,
 194                        le16_to_cpu(value));
 195                if (ret >= 0)
 196                        break;
 197                retries--;
 198        }
 199
 200        if (ret < 0) {
 201                dev_dbg(&client->dev,
 202                        "%s: i2c write to address 0x%x failed\n",
 203                        __func__, address);
 204                return ret;
 205        }
 206
 207        return 0;
 208}
 209
 210static int sbs_get_battery_presence_and_health(
 211        struct i2c_client *client, enum power_supply_property psp,
 212        union power_supply_propval *val)
 213{
 214        s32 ret;
 215        struct sbs_info *chip = i2c_get_clientdata(client);
 216
 217        if (psp == POWER_SUPPLY_PROP_PRESENT &&
 218                chip->gpio_detect) {
 219                ret = gpio_get_value(chip->pdata->battery_detect);
 220                if (ret == chip->pdata->battery_detect_present)
 221                        val->intval = 1;
 222                else
 223                        val->intval = 0;
 224                chip->is_present = val->intval;
 225                return ret;
 226        }
 227
 228        /* Write to ManufacturerAccess with
 229         * ManufacturerAccess command and then
 230         * read the status */
 231        ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
 232                                        MANUFACTURER_ACCESS_STATUS);
 233        if (ret < 0) {
 234                if (psp == POWER_SUPPLY_PROP_PRESENT)
 235                        val->intval = 0; /* battery removed */
 236                return ret;
 237        }
 238
 239        ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr);
 240        if (ret < 0)
 241                return ret;
 242
 243        if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value ||
 244            ret > sbs_data[REG_MANUFACTURER_DATA].max_value) {
 245                val->intval = 0;
 246                return 0;
 247        }
 248
 249        /* Mask the upper nibble of 2nd byte and
 250         * lower byte of response then
 251         * shift the result by 8 to get status*/
 252        ret &= 0x0F00;
 253        ret >>= 8;
 254        if (psp == POWER_SUPPLY_PROP_PRESENT) {
 255                if (ret == 0x0F)
 256                        /* battery removed */
 257                        val->intval = 0;
 258                else
 259                        val->intval = 1;
 260        } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
 261                if (ret == 0x09)
 262                        val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 263                else if (ret == 0x0B)
 264                        val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 265                else if (ret == 0x0C)
 266                        val->intval = POWER_SUPPLY_HEALTH_DEAD;
 267                else
 268                        val->intval = POWER_SUPPLY_HEALTH_GOOD;
 269        }
 270
 271        return 0;
 272}
 273
 274static int sbs_get_battery_property(struct i2c_client *client,
 275        int reg_offset, enum power_supply_property psp,
 276        union power_supply_propval *val)
 277{
 278        struct sbs_info *chip = i2c_get_clientdata(client);
 279        s32 ret;
 280
 281        ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 282        if (ret < 0)
 283                return ret;
 284
 285        /* returned values are 16 bit */
 286        if (sbs_data[reg_offset].min_value < 0)
 287                ret = (s16)ret;
 288
 289        if (ret >= sbs_data[reg_offset].min_value &&
 290            ret <= sbs_data[reg_offset].max_value) {
 291                val->intval = ret;
 292                if (psp != POWER_SUPPLY_PROP_STATUS)
 293                        return 0;
 294
 295                if (ret & BATTERY_FULL_CHARGED)
 296                        val->intval = POWER_SUPPLY_STATUS_FULL;
 297                else if (ret & BATTERY_FULL_DISCHARGED)
 298                        val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 299                else if (ret & BATTERY_DISCHARGING)
 300                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 301                else
 302                        val->intval = POWER_SUPPLY_STATUS_CHARGING;
 303
 304                if (chip->poll_time == 0)
 305                        chip->last_state = val->intval;
 306                else if (chip->last_state != val->intval) {
 307                        cancel_delayed_work_sync(&chip->work);
 308                        power_supply_changed(&chip->power_supply);
 309                        chip->poll_time = 0;
 310                }
 311        } else {
 312                if (psp == POWER_SUPPLY_PROP_STATUS)
 313                        val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 314                else
 315                        val->intval = 0;
 316        }
 317
 318        return 0;
 319}
 320
 321static void  sbs_unit_adjustment(struct i2c_client *client,
 322        enum power_supply_property psp, union power_supply_propval *val)
 323{
 324#define BASE_UNIT_CONVERSION            1000
 325#define BATTERY_MODE_CAP_MULT_WATT      (10 * BASE_UNIT_CONVERSION)
 326#define TIME_UNIT_CONVERSION            60
 327#define TEMP_KELVIN_TO_CELSIUS          2731
 328        switch (psp) {
 329        case POWER_SUPPLY_PROP_ENERGY_NOW:
 330        case POWER_SUPPLY_PROP_ENERGY_FULL:
 331        case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 332                /* sbs provides energy in units of 10mWh.
 333                 * Convert to µWh
 334                 */
 335                val->intval *= BATTERY_MODE_CAP_MULT_WATT;
 336                break;
 337
 338        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 339        case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 340        case POWER_SUPPLY_PROP_CURRENT_NOW:
 341        case POWER_SUPPLY_PROP_CHARGE_NOW:
 342        case POWER_SUPPLY_PROP_CHARGE_FULL:
 343        case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 344                val->intval *= BASE_UNIT_CONVERSION;
 345                break;
 346
 347        case POWER_SUPPLY_PROP_TEMP:
 348                /* sbs provides battery temperature in 0.1K
 349                 * so convert it to 0.1°C
 350                 */
 351                val->intval -= TEMP_KELVIN_TO_CELSIUS;
 352                break;
 353
 354        case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 355        case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 356                /* sbs provides time to empty and time to full in minutes.
 357                 * Convert to seconds
 358                 */
 359                val->intval *= TIME_UNIT_CONVERSION;
 360                break;
 361
 362        default:
 363                dev_dbg(&client->dev,
 364                        "%s: no need for unit conversion %d\n", __func__, psp);
 365        }
 366}
 367
 368static enum sbs_battery_mode sbs_set_battery_mode(struct i2c_client *client,
 369        enum sbs_battery_mode mode)
 370{
 371        int ret, original_val;
 372
 373        original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET);
 374        if (original_val < 0)
 375                return original_val;
 376
 377        if ((original_val & BATTERY_MODE_MASK) == mode)
 378                return mode;
 379
 380        if (mode == BATTERY_MODE_AMPS)
 381                ret = original_val & ~BATTERY_MODE_MASK;
 382        else
 383                ret = original_val | BATTERY_MODE_MASK;
 384
 385        ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret);
 386        if (ret < 0)
 387                return ret;
 388
 389        return original_val & BATTERY_MODE_MASK;
 390}
 391
 392static int sbs_get_battery_capacity(struct i2c_client *client,
 393        int reg_offset, enum power_supply_property psp,
 394        union power_supply_propval *val)
 395{
 396        s32 ret;
 397        enum sbs_battery_mode mode = BATTERY_MODE_WATTS;
 398
 399        if (power_supply_is_amp_property(psp))
 400                mode = BATTERY_MODE_AMPS;
 401
 402        mode = sbs_set_battery_mode(client, mode);
 403        if (mode < 0)
 404                return mode;
 405
 406        ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 407        if (ret < 0)
 408                return ret;
 409
 410        if (psp == POWER_SUPPLY_PROP_CAPACITY) {
 411                /* sbs spec says that this can be >100 %
 412                * even if max value is 100 % */
 413                val->intval = min(ret, 100);
 414        } else
 415                val->intval = ret;
 416
 417        ret = sbs_set_battery_mode(client, mode);
 418        if (ret < 0)
 419                return ret;
 420
 421        return 0;
 422}
 423
 424static char sbs_serial[5];
 425static int sbs_get_battery_serial_number(struct i2c_client *client,
 426        union power_supply_propval *val)
 427{
 428        int ret;
 429
 430        ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr);
 431        if (ret < 0)
 432                return ret;
 433
 434        ret = sprintf(sbs_serial, "%04x", ret);
 435        val->strval = sbs_serial;
 436
 437        return 0;
 438}
 439
 440static int sbs_get_property_index(struct i2c_client *client,
 441        enum power_supply_property psp)
 442{
 443        int count;
 444        for (count = 0; count < ARRAY_SIZE(sbs_data); count++)
 445                if (psp == sbs_data[count].psp)
 446                        return count;
 447
 448        dev_warn(&client->dev,
 449                "%s: Invalid Property - %d\n", __func__, psp);
 450
 451        return -EINVAL;
 452}
 453
 454static int sbs_get_property(struct power_supply *psy,
 455        enum power_supply_property psp,
 456        union power_supply_propval *val)
 457{
 458        int ret = 0;
 459        struct sbs_info *chip = container_of(psy,
 460                                struct sbs_info, power_supply);
 461        struct i2c_client *client = chip->client;
 462
 463        switch (psp) {
 464        case POWER_SUPPLY_PROP_PRESENT:
 465        case POWER_SUPPLY_PROP_HEALTH:
 466                ret = sbs_get_battery_presence_and_health(client, psp, val);
 467                if (psp == POWER_SUPPLY_PROP_PRESENT)
 468                        return 0;
 469                break;
 470
 471        case POWER_SUPPLY_PROP_TECHNOLOGY:
 472                val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 473                goto done; /* don't trigger power_supply_changed()! */
 474
 475        case POWER_SUPPLY_PROP_ENERGY_NOW:
 476        case POWER_SUPPLY_PROP_ENERGY_FULL:
 477        case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 478        case POWER_SUPPLY_PROP_CHARGE_NOW:
 479        case POWER_SUPPLY_PROP_CHARGE_FULL:
 480        case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 481        case POWER_SUPPLY_PROP_CAPACITY:
 482                ret = sbs_get_property_index(client, psp);
 483                if (ret < 0)
 484                        break;
 485
 486                ret = sbs_get_battery_capacity(client, ret, psp, val);
 487                break;
 488
 489        case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 490                ret = sbs_get_battery_serial_number(client, val);
 491                break;
 492
 493        case POWER_SUPPLY_PROP_STATUS:
 494        case POWER_SUPPLY_PROP_CYCLE_COUNT:
 495        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 496        case POWER_SUPPLY_PROP_CURRENT_NOW:
 497        case POWER_SUPPLY_PROP_TEMP:
 498        case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 499        case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 500        case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 501                ret = sbs_get_property_index(client, psp);
 502                if (ret < 0)
 503                        break;
 504
 505                ret = sbs_get_battery_property(client, ret, psp, val);
 506                break;
 507
 508        default:
 509                dev_err(&client->dev,
 510                        "%s: INVALID property\n", __func__);
 511                return -EINVAL;
 512        }
 513
 514        if (!chip->enable_detection)
 515                goto done;
 516
 517        if (!chip->gpio_detect &&
 518                chip->is_present != (ret >= 0)) {
 519                chip->is_present = (ret >= 0);
 520                power_supply_changed(&chip->power_supply);
 521        }
 522
 523done:
 524        if (!ret) {
 525                /* Convert units to match requirements for power supply class */
 526                sbs_unit_adjustment(client, psp, val);
 527        }
 528
 529        dev_dbg(&client->dev,
 530                "%s: property = %d, value = %x\n", __func__, psp, val->intval);
 531
 532        if (ret && chip->is_present)
 533                return ret;
 534
 535        /* battery not present, so return NODATA for properties */
 536        if (ret)
 537                return -ENODATA;
 538
 539        return 0;
 540}
 541
 542static irqreturn_t sbs_irq(int irq, void *devid)
 543{
 544        struct power_supply *battery = devid;
 545
 546        power_supply_changed(battery);
 547
 548        return IRQ_HANDLED;
 549}
 550
 551static void sbs_external_power_changed(struct power_supply *psy)
 552{
 553        struct sbs_info *chip;
 554
 555        chip = container_of(psy, struct sbs_info, power_supply);
 556
 557        if (chip->ignore_changes > 0) {
 558                chip->ignore_changes--;
 559                return;
 560        }
 561
 562        /* cancel outstanding work */
 563        cancel_delayed_work_sync(&chip->work);
 564
 565        schedule_delayed_work(&chip->work, HZ);
 566        chip->poll_time = chip->pdata->poll_retry_count;
 567}
 568
 569static void sbs_delayed_work(struct work_struct *work)
 570{
 571        struct sbs_info *chip;
 572        s32 ret;
 573
 574        chip = container_of(work, struct sbs_info, work.work);
 575
 576        ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr);
 577        /* if the read failed, give up on this work */
 578        if (ret < 0) {
 579                chip->poll_time = 0;
 580                return;
 581        }
 582
 583        if (ret & BATTERY_FULL_CHARGED)
 584                ret = POWER_SUPPLY_STATUS_FULL;
 585        else if (ret & BATTERY_FULL_DISCHARGED)
 586                ret = POWER_SUPPLY_STATUS_NOT_CHARGING;
 587        else if (ret & BATTERY_DISCHARGING)
 588                ret = POWER_SUPPLY_STATUS_DISCHARGING;
 589        else
 590                ret = POWER_SUPPLY_STATUS_CHARGING;
 591
 592        if (chip->last_state != ret) {
 593                chip->poll_time = 0;
 594                power_supply_changed(&chip->power_supply);
 595                return;
 596        }
 597        if (chip->poll_time > 0) {
 598                schedule_delayed_work(&chip->work, HZ);
 599                chip->poll_time--;
 600                return;
 601        }
 602}
 603
 604#if defined(CONFIG_OF)
 605
 606#include <linux/of_device.h>
 607#include <linux/of_gpio.h>
 608
 609static const struct of_device_id sbs_dt_ids[] = {
 610        { .compatible = "sbs,sbs-battery" },
 611        { .compatible = "ti,bq20z75" },
 612        { }
 613};
 614MODULE_DEVICE_TABLE(of, sbs_dt_ids);
 615
 616static struct sbs_platform_data *sbs_of_populate_pdata(
 617                struct i2c_client *client)
 618{
 619        struct device_node *of_node = client->dev.of_node;
 620        struct sbs_platform_data *pdata = client->dev.platform_data;
 621        enum of_gpio_flags gpio_flags;
 622        int rc;
 623        u32 prop;
 624
 625        /* verify this driver matches this device */
 626        if (!of_node)
 627                return NULL;
 628
 629        /* if platform data is set, honor it */
 630        if (pdata)
 631                return pdata;
 632
 633        /* first make sure at least one property is set, otherwise
 634         * it won't change behavior from running without pdata.
 635         */
 636        if (!of_get_property(of_node, "sbs,i2c-retry-count", NULL) &&
 637                !of_get_property(of_node, "sbs,poll-retry-count", NULL) &&
 638                !of_get_property(of_node, "sbs,battery-detect-gpios", NULL))
 639                goto of_out;
 640
 641        pdata = devm_kzalloc(&client->dev, sizeof(struct sbs_platform_data),
 642                                GFP_KERNEL);
 643        if (!pdata)
 644                goto of_out;
 645
 646        rc = of_property_read_u32(of_node, "sbs,i2c-retry-count", &prop);
 647        if (!rc)
 648                pdata->i2c_retry_count = prop;
 649
 650        rc = of_property_read_u32(of_node, "sbs,poll-retry-count", &prop);
 651        if (!rc)
 652                pdata->poll_retry_count = prop;
 653
 654        if (!of_get_property(of_node, "sbs,battery-detect-gpios", NULL)) {
 655                pdata->battery_detect = -1;
 656                goto of_out;
 657        }
 658
 659        pdata->battery_detect = of_get_named_gpio_flags(of_node,
 660                        "sbs,battery-detect-gpios", 0, &gpio_flags);
 661
 662        if (gpio_flags & OF_GPIO_ACTIVE_LOW)
 663                pdata->battery_detect_present = 0;
 664        else
 665                pdata->battery_detect_present = 1;
 666
 667of_out:
 668        return pdata;
 669}
 670#else
 671static struct sbs_platform_data *sbs_of_populate_pdata(
 672        struct i2c_client *client)
 673{
 674        return client->dev.platform_data;
 675}
 676#endif
 677
 678static int sbs_probe(struct i2c_client *client,
 679        const struct i2c_device_id *id)
 680{
 681        struct sbs_info *chip;
 682        struct sbs_platform_data *pdata = client->dev.platform_data;
 683        int rc;
 684        int irq;
 685        char *name;
 686
 687        name = kasprintf(GFP_KERNEL, "sbs-%s", dev_name(&client->dev));
 688        if (!name) {
 689                dev_err(&client->dev, "Failed to allocate device name\n");
 690                return -ENOMEM;
 691        }
 692
 693        chip = kzalloc(sizeof(struct sbs_info), GFP_KERNEL);
 694        if (!chip) {
 695                rc = -ENOMEM;
 696                goto exit_free_name;
 697        }
 698
 699        chip->client = client;
 700        chip->enable_detection = false;
 701        chip->gpio_detect = false;
 702        chip->power_supply.name = name;
 703        chip->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;
 704        chip->power_supply.properties = sbs_properties;
 705        chip->power_supply.num_properties = ARRAY_SIZE(sbs_properties);
 706        chip->power_supply.get_property = sbs_get_property;
 707        /* ignore first notification of external change, it is generated
 708         * from the power_supply_register call back
 709         */
 710        chip->ignore_changes = 1;
 711        chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
 712        chip->power_supply.external_power_changed = sbs_external_power_changed;
 713
 714        pdata = sbs_of_populate_pdata(client);
 715
 716        if (pdata) {
 717                chip->gpio_detect = gpio_is_valid(pdata->battery_detect);
 718                chip->pdata = pdata;
 719        }
 720
 721        i2c_set_clientdata(client, chip);
 722
 723        if (!chip->gpio_detect)
 724                goto skip_gpio;
 725
 726        rc = gpio_request(pdata->battery_detect, dev_name(&client->dev));
 727        if (rc) {
 728                dev_warn(&client->dev, "Failed to request gpio: %d\n", rc);
 729                chip->gpio_detect = false;
 730                goto skip_gpio;
 731        }
 732
 733        rc = gpio_direction_input(pdata->battery_detect);
 734        if (rc) {
 735                dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc);
 736                gpio_free(pdata->battery_detect);
 737                chip->gpio_detect = false;
 738                goto skip_gpio;
 739        }
 740
 741        irq = gpio_to_irq(pdata->battery_detect);
 742        if (irq <= 0) {
 743                dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
 744                gpio_free(pdata->battery_detect);
 745                chip->gpio_detect = false;
 746                goto skip_gpio;
 747        }
 748
 749        rc = request_irq(irq, sbs_irq,
 750                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 751                dev_name(&client->dev), &chip->power_supply);
 752        if (rc) {
 753                dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
 754                gpio_free(pdata->battery_detect);
 755                chip->gpio_detect = false;
 756                goto skip_gpio;
 757        }
 758
 759        chip->irq = irq;
 760
 761skip_gpio:
 762        /*
 763         * Before we register, we need to make sure we can actually talk
 764         * to the battery.
 765         */
 766        rc = sbs_read_word_data(client, sbs_data[REG_STATUS].addr);
 767        if (rc < 0) {
 768                dev_err(&client->dev, "%s: Failed to get device status\n",
 769                        __func__);
 770                goto exit_psupply;
 771        }
 772
 773        rc = power_supply_register(&client->dev, &chip->power_supply);
 774        if (rc) {
 775                dev_err(&client->dev,
 776                        "%s: Failed to register power supply\n", __func__);
 777                goto exit_psupply;
 778        }
 779
 780        dev_info(&client->dev,
 781                "%s: battery gas gauge device registered\n", client->name);
 782
 783        INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
 784
 785        chip->enable_detection = true;
 786
 787        return 0;
 788
 789exit_psupply:
 790        if (chip->irq)
 791                free_irq(chip->irq, &chip->power_supply);
 792        if (chip->gpio_detect)
 793                gpio_free(pdata->battery_detect);
 794
 795        kfree(chip);
 796
 797exit_free_name:
 798        kfree(name);
 799
 800        return rc;
 801}
 802
 803static int sbs_remove(struct i2c_client *client)
 804{
 805        struct sbs_info *chip = i2c_get_clientdata(client);
 806
 807        if (chip->irq)
 808                free_irq(chip->irq, &chip->power_supply);
 809        if (chip->gpio_detect)
 810                gpio_free(chip->pdata->battery_detect);
 811
 812        power_supply_unregister(&chip->power_supply);
 813
 814        cancel_delayed_work_sync(&chip->work);
 815
 816        kfree(chip->power_supply.name);
 817        kfree(chip);
 818        chip = NULL;
 819
 820        return 0;
 821}
 822
 823#if defined CONFIG_PM_SLEEP
 824
 825static int sbs_suspend(struct device *dev)
 826{
 827        struct i2c_client *client = to_i2c_client(dev);
 828        struct sbs_info *chip = i2c_get_clientdata(client);
 829        s32 ret;
 830
 831        if (chip->poll_time > 0)
 832                cancel_delayed_work_sync(&chip->work);
 833
 834        /* write to manufacturer access with sleep command */
 835        ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
 836                MANUFACTURER_ACCESS_SLEEP);
 837        if (chip->is_present && ret < 0)
 838                return ret;
 839
 840        return 0;
 841}
 842
 843static SIMPLE_DEV_PM_OPS(sbs_pm_ops, sbs_suspend, NULL);
 844#define SBS_PM_OPS (&sbs_pm_ops)
 845
 846#else
 847#define SBS_PM_OPS NULL
 848#endif
 849
 850static const struct i2c_device_id sbs_id[] = {
 851        { "bq20z75", 0 },
 852        { "sbs-battery", 1 },
 853        {}
 854};
 855MODULE_DEVICE_TABLE(i2c, sbs_id);
 856
 857static struct i2c_driver sbs_battery_driver = {
 858        .probe          = sbs_probe,
 859        .remove         = sbs_remove,
 860        .id_table       = sbs_id,
 861        .driver = {
 862                .name   = "sbs-battery",
 863                .of_match_table = of_match_ptr(sbs_dt_ids),
 864                .pm     = SBS_PM_OPS,
 865        },
 866};
 867module_i2c_driver(sbs_battery_driver);
 868
 869MODULE_DESCRIPTION("SBS battery monitor driver");
 870MODULE_LICENSE("GPL");
 871
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.