git.maemo.org Git - kernel-power/blob - kernel-power-2.6.28/debian/patches/bq2415x_charger.patch

   1 --- /dev/null
   2 +++ kernel-power/drivers/power/bq2415x_charger.c
   3 @@ -0,0 +1,1569 @@
   4 +/*
   5 +    bq2415x_charger.c - bq2415x charger driver
   6 +    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
   7 +
   8 +    This program is free software; you can redistribute it and/or modify
   9 +    it under the terms of the GNU General Public License as published by
  10 +    the Free Software Foundation; either version 2 of the License, or
  11 +    (at your option) any later version.
  12 +
  13 +    This program is distributed in the hope that it will be useful,
  14 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 +    GNU General Public License for more details.
  17 +
  18 +    You should have received a copy of the GNU General Public License along
  19 +    with this program; if not, write to the Free Software Foundation, Inc.,
  20 +    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21 +*/
  22 +
  23 +/*
  24 +  Datasheets:
  25 +  http://www.ti.com/product/bq24150
  26 +  http://www.ti.com/product/bq24150a
  27 +  http://www.ti.com/product/bq24152
  28 +  http://www.ti.com/product/bq24153
  29 +  http://www.ti.com/product/bq24153a
  30 +  http://www.ti.com/product/bq24155
  31 +*/
  32 +
  33 +#include <linux/version.h>
  34 +#include <linux/module.h>
  35 +#include <linux/param.h>
  36 +#include <linux/err.h>
  37 +#include <linux/workqueue.h>
  38 +#include <linux/sysfs.h>
  39 +#include <linux/platform_device.h>
  40 +#include <linux/power_supply.h>
  41 +#include <linux/idr.h>
  42 +#include <linux/i2c.h>
  43 +#include <linux/slab.h>
  44 +
  45 +#include <linux/power/bq2415x_charger.h>
  46 +
  47 +#define BQ2415X_TIMER_TIMEOUT  10
  48 +
  49 +#define BQ2415X_REG_STATUS             0x00
  50 +#define BQ2415X_REG_CONTROL            0x01
  51 +#define BQ2415X_REG_VOLTAGE            0x02
  52 +#define BQ2415X_REG_VENDER             0x03
  53 +#define BQ2415X_REG_CURRENT            0x04
  54 +
  55 +/* reset state for all registers */
  56 +#define BQ2415X_RESET_STATUS           BIT(6)
  57 +#define BQ2415X_RESET_CONTROL          (BIT(4)|BIT(5))
  58 +#define BQ2415X_RESET_VOLTAGE          (BIT(1)|BIT(3))
  59 +#define BQ2415X_RESET_CURRENT          (BIT(0)|BIT(3)|BIT(7))
  60 +
  61 +/* status register */
  62 +#define BQ2415X_BIT_TMR_RST            7
  63 +#define BQ2415X_BIT_OTG                        7
  64 +#define BQ2415X_BIT_EN_STAT            6
  65 +#define BQ2415X_MASK_STAT              (BIT(4)|BIT(5))
  66 +#define BQ2415X_SHIFT_STAT             4
  67 +#define BQ2415X_BIT_BOOST              3
  68 +#define BQ2415X_MASK_FAULT             (BIT(0)|BIT(1)|BIT(2))
  69 +#define BQ2415X_SHIFT_FAULT            0
  70 +
  71 +/* control register */
  72 +#define BQ2415X_MASK_LIMIT             (BIT(6)|BIT(7))
  73 +#define BQ2415X_SHIFT_LIMIT            6
  74 +#define BQ2415X_MASK_VLOWV             (BIT(4)|BIT(5))
  75 +#define BQ2415X_SHIFT_VLOWV            4
  76 +#define BQ2415X_BIT_TE                 3
  77 +#define BQ2415X_BIT_CE                 2
  78 +#define BQ2415X_BIT_HZ_MODE            1
  79 +#define BQ2415X_BIT_OPA_MODE           0
  80 +
  81 +/* voltage register */
  82 +#define BQ2415X_MASK_VO                (BIT(2)|BIT(3)|BIT(4)|BIT(5)|BIT(6)|BIT(7))
  83 +#define BQ2415X_SHIFT_VO               2
  84 +#define BQ2415X_BIT_OTG_PL             1
  85 +#define BQ2415X_BIT_OTG_EN             0
  86 +
  87 +/* vender register */
  88 +#define BQ2415X_MASK_VENDER            (BIT(5)|BIT(6)|BIT(7))
  89 +#define BQ2415X_SHIFT_VENDER           5
  90 +#define BQ2415X_MASK_PN                        (BIT(3)|BIT(4))
  91 +#define BQ2415X_SHIFT_PN               3
  92 +#define BQ2415X_MASK_REVISION          (BIT(0)|BIT(1)|BIT(2))
  93 +#define BQ2415X_SHIFT_REVISION         0
  94 +
  95 +/* current register */
  96 +/* RESET                               BIT(7) */
  97 +#define BQ2415X_MASK_VI_CHRG           (BIT(4)|BIT(5)|BIT(6)|BIT(7))
  98 +#define BQ2415X_SHIFT_VI_CHRG          4
  99 +/* N/A                                 BIT(3) */
 100 +#define BQ2415X_MASK_VI_TERM           (BIT(0)|BIT(1)|BIT(2)|BIT(7))
 101 +#define BQ2415X_SHIFT_VI_TERM          0
 102 +
 103 +
 104 +enum bq2415x_command {
 105 +       BQ2415X_TIMER_RESET,
 106 +       BQ2415X_OTG_STATUS,
 107 +       BQ2415X_STAT_PIN_STATUS,
 108 +       BQ2415X_STAT_PIN_ENABLE,
 109 +       BQ2415X_STAT_PIN_DISABLE,
 110 +       BQ2415X_CHARGE_STATUS,
 111 +       BQ2415X_BOOST_STATUS,
 112 +       BQ2415X_FAULT_STATUS,
 113 +
 114 +       BQ2415X_CHARGE_TERMINATION_STATUS,
 115 +       BQ2415X_CHARGE_TERMINATION_ENABLE,
 116 +       BQ2415X_CHARGE_TERMINATION_DISABLE,
 117 +       BQ2415X_CHARGER_STATUS,
 118 +       BQ2415X_CHARGER_ENABLE,
 119 +       BQ2415X_CHARGER_DISABLE,
 120 +       BQ2415X_HIGH_IMPEDANCE_STATUS,
 121 +       BQ2415X_HIGH_IMPEDANCE_ENABLE,
 122 +       BQ2415X_HIGH_IMPEDANCE_DISABLE,
 123 +       BQ2415X_BOOST_MODE_STATUS,
 124 +       BQ2415X_BOOST_MODE_ENABLE,
 125 +       BQ2415X_BOOST_MODE_DISABLE,
 126 +
 127 +       BQ2415X_OTG_LEVEL,
 128 +       BQ2415X_OTG_ACTIVATE_HIGH,
 129 +       BQ2415X_OTG_ACTIVATE_LOW,
 130 +       BQ2415X_OTG_PIN_STATUS,
 131 +       BQ2415X_OTG_PIN_ENABLE,
 132 +       BQ2415X_OTG_PIN_DISABLE,
 133 +
 134 +       BQ2415X_VENDER_CODE,
 135 +       BQ2415X_PART_NUMBER,
 136 +       BQ2415X_REVISION,
 137 +};
 138 +
 139 +enum bq2415x_chip {
 140 +       BQUNKNOWN,
 141 +       BQ24150,
 142 +       BQ24150A,
 143 +       BQ24151,
 144 +       BQ24151A,
 145 +       BQ24152,
 146 +       BQ24153,
 147 +       BQ24153A,
 148 +       BQ24155,
 149 +       BQ24156,
 150 +       BQ24156A,
 151 +       BQ24158,
 152 +};
 153 +
 154 +static char *bq2415x_chip_name[] = {
 155 +       "unknown",
 156 +       "bq24150",
 157 +       "bq24150a",
 158 +       "bq24151",
 159 +       "bq24151a",
 160 +       "bq24152",
 161 +       "bq24153",
 162 +       "bq24153a",
 163 +       "bq24155",
 164 +       "bq24156",
 165 +       "bq24156a",
 166 +       "bq24158",
 167 +};
 168 +
 169 +struct bq2415x_device {
 170 +       struct device *dev;
 171 +       struct bq2415x_platform_data init_data;
 172 +       struct power_supply charger;
 173 +       struct delayed_work work;
 174 +       enum bq2415x_mode reported_mode;/* mode reported by hook function */
 175 +       enum bq2415x_mode mode;         /* current configured mode */
 176 +       enum bq2415x_chip chip;
 177 +       char *model;
 178 +       char *name;
 179 +       int autotimer;  /* 1 - if driver automatically reset timer, 0 - not */
 180 +       int automode;   /* 1 - enabled, 0 - disabled; -1 - not supported */
 181 +       int id;
 182 +};
 183 +
 184 +static DEFINE_IDR(bq2415x_id);
 185 +
 186 +static DEFINE_MUTEX(bq2415x_id_mutex);
 187 +static DEFINE_MUTEX(bq2415x_timer_mutex);
 188 +static DEFINE_MUTEX(bq2415x_i2c_mutex);
 189 +
 190 +/* i2c read functions */
 191 +
 192 +static int bq2415x_i2c_read(struct bq2415x_device *bq, u8 reg)
 193 +{
 194 +       struct i2c_client *client = to_i2c_client(bq->dev);
 195 +       struct i2c_msg msg[2];
 196 +       u8 val;
 197 +       int ret;
 198 +
 199 +       if (!client->adapter)
 200 +               return -ENODEV;
 201 +
 202 +       msg[0].addr = client->addr;
 203 +       msg[0].flags = 0;
 204 +       msg[0].buf = &reg;
 205 +       msg[0].len = sizeof(reg);
 206 +       msg[1].addr = client->addr;
 207 +       msg[1].flags = I2C_M_RD;
 208 +       msg[1].buf = &val;
 209 +       msg[1].len = sizeof(val);
 210 +
 211 +       mutex_lock(&bq2415x_i2c_mutex);
 212 +       ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
 213 +       mutex_unlock(&bq2415x_i2c_mutex);
 214 +
 215 +       if (ret < 0)
 216 +               return ret;
 217 +
 218 +       return val;
 219 +}
 220 +
 221 +static int bq2415x_i2c_read_mask(struct bq2415x_device *bq, u8 reg,
 222 +                               u8 mask, u8 shift)
 223 +{
 224 +       int ret;
 225 +
 226 +       if (shift > 8)
 227 +               return -EINVAL;
 228 +
 229 +       ret = bq2415x_i2c_read(bq, reg);
 230 +       if (ret < 0)
 231 +               return ret;
 232 +       else
 233 +               return (ret & mask) >> shift;
 234 +}
 235 +
 236 +static int bq2415x_i2c_read_bit(struct bq2415x_device *bq, u8 reg, u8 bit)
 237 +{
 238 +       if (bit > 8)
 239 +               return -EINVAL;
 240 +       else
 241 +               return bq2415x_i2c_read_mask(bq, reg, BIT(bit), bit);
 242 +}
 243 +
 244 +/* i2c write functions */
 245 +
 246 +static int bq2415x_i2c_write(struct bq2415x_device *bq, u8 reg, u8 val)
 247 +{
 248 +       struct i2c_client *client = to_i2c_client(bq->dev);
 249 +       struct i2c_msg msg[1];
 250 +       u8 data[2];
 251 +       int ret;
 252 +
 253 +       data[0] = reg;
 254 +       data[1] = val;
 255 +
 256 +       msg[0].addr = client->addr;
 257 +       msg[0].flags = 0;
 258 +       msg[0].buf = data;
 259 +       msg[0].len = ARRAY_SIZE(data);
 260 +
 261 +       mutex_lock(&bq2415x_i2c_mutex);
 262 +       ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
 263 +       mutex_unlock(&bq2415x_i2c_mutex);
 264 +
 265 +       /* i2c_transfer returns number of messages transferred */
 266 +       if (ret < 0)
 267 +               return ret;
 268 +       else if (ret != 1)
 269 +               return -EIO;
 270 +
 271 +       return 0;
 272 +}
 273 +
 274 +static int bq2415x_i2c_write_mask(struct bq2415x_device *bq, u8 reg, u8 val,
 275 +                               u8 mask, u8 shift)
 276 +{
 277 +       int ret;
 278 +
 279 +       if (shift > 8)
 280 +               return -EINVAL;
 281 +
 282 +       ret = bq2415x_i2c_read(bq, reg);
 283 +       if (ret < 0)
 284 +               return ret;
 285 +
 286 +       ret &= ~mask;
 287 +       ret |= val << shift;
 288 +
 289 +       return bq2415x_i2c_write(bq, reg, ret);
 290 +}
 291 +
 292 +static int bq2415x_i2c_write_bit(struct bq2415x_device *bq, u8 reg,
 293 +                               bool val, u8 bit)
 294 +{
 295 +       if (bit > 8)
 296 +               return -EINVAL;
 297 +       else
 298 +               return bq2415x_i2c_write_mask(bq, reg, val, BIT(bit), bit);
 299 +}
 300 +
 301 +/* global exec command function */
 302 +
 303 +static int bq2415x_exec_command(struct bq2415x_device *bq,
 304 +                               enum bq2415x_command command)
 305 +{
 306 +       int ret;
 307 +       switch (command) {
 308 +       case BQ2415X_TIMER_RESET:
 309 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS,
 310 +                               1, BQ2415X_BIT_TMR_RST);
 311 +       case BQ2415X_OTG_STATUS:
 312 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
 313 +                               BQ2415X_BIT_OTG);
 314 +       case BQ2415X_STAT_PIN_STATUS:
 315 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
 316 +                               BQ2415X_BIT_EN_STAT);
 317 +       case BQ2415X_STAT_PIN_ENABLE:
 318 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 1,
 319 +                               BQ2415X_BIT_EN_STAT);
 320 +       case BQ2415X_STAT_PIN_DISABLE:
 321 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 0,
 322 +                               BQ2415X_BIT_EN_STAT);
 323 +       case BQ2415X_CHARGE_STATUS:
 324 +               return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
 325 +                               BQ2415X_MASK_STAT, BQ2415X_SHIFT_STAT);
 326 +       case BQ2415X_BOOST_STATUS:
 327 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
 328 +                               BQ2415X_BIT_BOOST);
 329 +       case BQ2415X_FAULT_STATUS:
 330 +               return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
 331 +                       BQ2415X_MASK_FAULT, BQ2415X_SHIFT_FAULT);
 332 +
 333 +       case BQ2415X_CHARGE_TERMINATION_STATUS:
 334 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
 335 +                               BQ2415X_BIT_TE);
 336 +       case BQ2415X_CHARGE_TERMINATION_ENABLE:
 337 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 338 +                               1, BQ2415X_BIT_TE);
 339 +       case BQ2415X_CHARGE_TERMINATION_DISABLE:
 340 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 341 +                               0, BQ2415X_BIT_TE);
 342 +       case BQ2415X_CHARGER_STATUS:
 343 +               ret = bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
 344 +                       BQ2415X_BIT_CE);
 345 +               if (ret < 0)
 346 +                       return ret;
 347 +               else
 348 +                       return ret > 0 ? 0 : 1;
 349 +       case BQ2415X_CHARGER_ENABLE:
 350 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 351 +                               0, BQ2415X_BIT_CE);
 352 +       case BQ2415X_CHARGER_DISABLE:
 353 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 354 +                               1, BQ2415X_BIT_CE);
 355 +       case BQ2415X_HIGH_IMPEDANCE_STATUS:
 356 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
 357 +                               BQ2415X_BIT_HZ_MODE);
 358 +       case BQ2415X_HIGH_IMPEDANCE_ENABLE:
 359 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 360 +                               1, BQ2415X_BIT_HZ_MODE);
 361 +       case BQ2415X_HIGH_IMPEDANCE_DISABLE:
 362 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 363 +                               0, BQ2415X_BIT_HZ_MODE);
 364 +       case BQ2415X_BOOST_MODE_STATUS:
 365 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
 366 +                               BQ2415X_BIT_OPA_MODE);
 367 +       case BQ2415X_BOOST_MODE_ENABLE:
 368 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 369 +                               1, BQ2415X_BIT_OPA_MODE);
 370 +       case BQ2415X_BOOST_MODE_DISABLE:
 371 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
 372 +                               0, BQ2415X_BIT_OPA_MODE);
 373 +
 374 +       case BQ2415X_OTG_LEVEL:
 375 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
 376 +                               BQ2415X_BIT_OTG_PL);
 377 +       case BQ2415X_OTG_ACTIVATE_HIGH:
 378 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
 379 +                               1, BQ2415X_BIT_OTG_PL);
 380 +       case BQ2415X_OTG_ACTIVATE_LOW:
 381 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
 382 +                               0, BQ2415X_BIT_OTG_PL);
 383 +       case BQ2415X_OTG_PIN_STATUS:
 384 +               return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
 385 +                               BQ2415X_BIT_OTG_EN);
 386 +       case BQ2415X_OTG_PIN_ENABLE:
 387 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
 388 +                               1, BQ2415X_BIT_OTG_EN);
 389 +       case BQ2415X_OTG_PIN_DISABLE:
 390 +               return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
 391 +                               0, BQ2415X_BIT_OTG_EN);
 392 +
 393 +       case BQ2415X_VENDER_CODE:
 394 +               return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
 395 +                       BQ2415X_MASK_VENDER, BQ2415X_SHIFT_VENDER);
 396 +       case BQ2415X_PART_NUMBER:
 397 +               return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
 398 +                               BQ2415X_MASK_PN, BQ2415X_SHIFT_PN);
 399 +       case BQ2415X_REVISION:
 400 +               return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
 401 +                       BQ2415X_MASK_REVISION, BQ2415X_SHIFT_REVISION);
 402 +
 403 +       default:
 404 +               return -EINVAL;
 405 +       }
 406 +}
 407 +
 408 +/* global detect chip */
 409 +
 410 +static enum bq2415x_chip bq2415x_detect_chip(struct bq2415x_device *bq)
 411 +{
 412 +       struct i2c_client *client = to_i2c_client(bq->dev);
 413 +       int ret = bq2415x_exec_command(bq, BQ2415X_PART_NUMBER);
 414 +
 415 +       if (ret < 0)
 416 +               return ret;
 417 +
 418 +       switch (client->addr) {
 419 +       case 0x6b:
 420 +               switch (ret) {
 421 +               case 0:
 422 +                       if (bq->chip == BQ24151A)
 423 +                               return bq->chip;
 424 +                       else
 425 +                               return BQ24151;
 426 +               case 1:
 427 +                       if (bq->chip == BQ24150A ||
 428 +                               bq->chip == BQ24152 ||
 429 +                               bq->chip == BQ24155)
 430 +                               return bq->chip;
 431 +                       else
 432 +                               return BQ24150;
 433 +               case 2:
 434 +                       if (bq->chip == BQ24153A)
 435 +                               return bq->chip;
 436 +                       else
 437 +                               return BQ24153;
 438 +               default:
 439 +                       return BQUNKNOWN;
 440 +               }
 441 +               break;
 442 +
 443 +       case 0x6a:
 444 +               switch (ret) {
 445 +               case 0:
 446 +                       if (bq->chip == BQ24156A)
 447 +                               return bq->chip;
 448 +                       else
 449 +                               return BQ24156;
 450 +               case 2:
 451 +                       return BQ24158;
 452 +               default:
 453 +                       return BQUNKNOWN;
 454 +               }
 455 +               break;
 456 +       }
 457 +
 458 +       return BQUNKNOWN;
 459 +}
 460 +
 461 +static int bq2415x_detect_revision(struct bq2415x_device *bq)
 462 +{
 463 +       int ret = bq2415x_exec_command(bq, BQ2415X_REVISION);
 464 +       int chip = bq2415x_detect_chip(bq);
 465 +       if (ret < 0 || chip < 0)
 466 +               return -1;
 467 +
 468 +       switch (chip) {
 469 +       case BQ24150:
 470 +       case BQ24150A:
 471 +       case BQ24151:
 472 +       case BQ24151A:
 473 +       case BQ24152:
 474 +               if (ret >= 0 && ret <= 3)
 475 +                       return ret;
 476 +               else
 477 +                       return -1;
 478 +
 479 +       case BQ24153:
 480 +       case BQ24153A:
 481 +       case BQ24156:
 482 +       case BQ24156A:
 483 +       case BQ24158:
 484 +               if (ret == 3)
 485 +                       return 0;
 486 +               else if (ret == 1)
 487 +                       return 1;
 488 +               else
 489 +                       return -1;
 490 +
 491 +       case BQ24155:
 492 +               if (ret == 3)
 493 +                       return 3;
 494 +               else
 495 +                       return -1;
 496 +
 497 +       case BQUNKNOWN:
 498 +               return -1;
 499 +       }
 500 +
 501 +       return -1;
 502 +}
 503 +
 504 +static int bq2415x_get_vender_code(struct bq2415x_device *bq)
 505 +{
 506 +       int ret = bq2415x_exec_command(bq, BQ2415X_VENDER_CODE);
 507 +       if (ret < 0)
 508 +               return 0;
 509 +       else /* convert to binary */
 510 +               return (ret & 0x1) +
 511 +                       ((ret >> 1) & 0x1) * 10 +
 512 +                       ((ret >> 2) & 0x1) * 100;
 513 +}
 514 +
 515 +/* global other functions */
 516 +
 517 +static void bq2415x_reset_chip(struct bq2415x_device *bq)
 518 +{
 519 +       bq2415x_i2c_write(bq, BQ2415X_REG_CURRENT, BQ2415X_RESET_CURRENT);
 520 +       bq2415x_i2c_write(bq, BQ2415X_REG_VOLTAGE, BQ2415X_RESET_VOLTAGE);
 521 +       bq2415x_i2c_write(bq, BQ2415X_REG_CONTROL, BQ2415X_RESET_CONTROL);
 522 +       bq2415x_i2c_write(bq, BQ2415X_REG_STATUS, BQ2415X_RESET_STATUS);
 523 +}
 524 +
 525 +static int bq2415x_set_current_limit(struct bq2415x_device *bq, int mA)
 526 +{
 527 +       int val;
 528 +       if (mA <= 100)
 529 +               val = 0;
 530 +       else if (mA <= 500)
 531 +               val = 1;
 532 +       else if (mA <= 800)
 533 +               val = 2;
 534 +       else
 535 +               val = 3;
 536 +       return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
 537 +                       BQ2415X_MASK_LIMIT, BQ2415X_SHIFT_LIMIT);
 538 +}
 539 +
 540 +static int bq2415x_get_current_limit(struct bq2415x_device *bq)
 541 +{
 542 +       int ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
 543 +                       BQ2415X_MASK_LIMIT, BQ2415X_SHIFT_LIMIT);
 544 +       if (ret < 0)
 545 +               return ret;
 546 +       else if (ret == 0)
 547 +               return 100;
 548 +       else if (ret == 1)
 549 +               return 500;
 550 +       else if (ret == 2)
 551 +               return 800;
 552 +       else if (ret == 3)
 553 +               return 1800;
 554 +       else
 555 +               return -EINVAL;
 556 +}
 557 +
 558 +static int bq2415x_set_weak_battery_voltage(struct bq2415x_device *bq, int mV)
 559 +{
 560 +       /* round to 100mV */
 561 +       int val;
 562 +       if (mV <= 3400 + 50)
 563 +               val = 0;
 564 +       else if (mV <= 3500 + 50)
 565 +               val = 1;
 566 +       else if (mV <= 3600 + 50)
 567 +               val = 2;
 568 +       else
 569 +               val = 3;
 570 +       return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
 571 +                       BQ2415X_MASK_VLOWV, BQ2415X_SHIFT_VLOWV);
 572 +}
 573 +
 574 +static int bq2415x_get_weak_battery_voltage(struct bq2415x_device *bq)
 575 +{
 576 +       int ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
 577 +                       BQ2415X_MASK_VLOWV, BQ2415X_SHIFT_VLOWV);
 578 +       if (ret < 0)
 579 +               return ret;
 580 +       else
 581 +               return 100 * (34 + ret);
 582 +}
 583 +
 584 +static int bq2415x_set_battery_regulation_voltage(struct bq2415x_device *bq,
 585 +                                               int mV)
 586 +{
 587 +       int val = (mV/10 - 350) / 2;
 588 +
 589 +       if (val < 0)
 590 +               val = 0;
 591 +       else if (val > 94) /* FIXME: Max is 94 or 122 ? Set max value ? */
 592 +               return -EINVAL;
 593 +
 594 +       return bq2415x_i2c_write_mask(bq, BQ2415X_REG_VOLTAGE, val,
 595 +                       BQ2415X_MASK_VO, BQ2415X_SHIFT_VO);
 596 +}
 597 +
 598 +static int bq2415x_get_battery_regulation_voltage(struct bq2415x_device *bq)
 599 +{
 600 +       int ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_VOLTAGE,
 601 +                       BQ2415X_MASK_VO, BQ2415X_SHIFT_VO);
 602 +       if (ret < 0)
 603 +               return ret;
 604 +       else
 605 +               return 10 * (350 + 2*ret);
 606 +}
 607 +
 608 +static int bq2415x_set_charge_current(struct bq2415x_device *bq, int mA)
 609 +{
 610 +       int val;
 611 +       if (bq->init_data.resistor_sense <= 0)
 612 +               return -ENOSYS;
 613 +
 614 +       val = (mA * bq->init_data.resistor_sense - 37400) / 6800;
 615 +
 616 +       if (val < 0)
 617 +               val = 0;
 618 +       else if (val > 7)
 619 +               val = 7;
 620 +
 621 +       return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
 622 +                       BQ2415X_MASK_VI_CHRG, BQ2415X_SHIFT_VI_CHRG);
 623 +}
 624 +
 625 +static int bq2415x_get_charge_current(struct bq2415x_device *bq)
 626 +{
 627 +       int ret;
 628 +       if (bq->init_data.resistor_sense <= 0)
 629 +               return -ENOSYS;
 630 +
 631 +       ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
 632 +                       BQ2415X_MASK_VI_CHRG, BQ2415X_SHIFT_VI_CHRG);
 633 +       if (ret < 0)
 634 +               return ret;
 635 +       else
 636 +               return (37400 + 6800*ret) / bq->init_data.resistor_sense;
 637 +}
 638 +
 639 +static int bq2415x_set_termination_current(struct bq2415x_device *bq, int mA)
 640 +{
 641 +       int val;
 642 +       if (bq->init_data.resistor_sense <= 0)
 643 +               return -ENOSYS;
 644 +
 645 +       val = (mA * bq->init_data.resistor_sense - 3400) / 3400;
 646 +
 647 +       if (val < 0)
 648 +               val = 0;
 649 +       else if (val > 7)
 650 +               val = 7;
 651 +
 652 +       return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
 653 +                       BQ2415X_MASK_VI_TERM, BQ2415X_SHIFT_VI_TERM);
 654 +}
 655 +
 656 +static int bq2415x_get_termination_current(struct bq2415x_device *bq)
 657 +{
 658 +       int ret;
 659 +       if (bq->init_data.resistor_sense <= 0)
 660 +               return -ENOSYS;
 661 +
 662 +       ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
 663 +                       BQ2415X_MASK_VI_TERM, BQ2415X_SHIFT_VI_TERM);
 664 +       if (ret < 0)
 665 +               return ret;
 666 +       else
 667 +               return (3400 + 3400*ret) / bq->init_data.resistor_sense;
 668 +}
 669 +
 670 +#define bq2415x_set_default_value(bq, value) \
 671 +       do { \
 672 +               int ret = 0; \
 673 +               if (bq->init_data.value != -1) \
 674 +                       ret = bq2415x_set_##value(bq, bq->init_data.value); \
 675 +               if (ret < 0) \
 676 +                       return ret; \
 677 +       } while (0)
 678 +
 679 +static int bq2415x_set_defaults(struct bq2415x_device *bq)
 680 +{
 681 +       bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
 682 +       bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
 683 +       bq2415x_set_default_value(bq, current_limit);
 684 +       bq2415x_set_default_value(bq, weak_battery_voltage);
 685 +       bq2415x_set_default_value(bq, battery_regulation_voltage);
 686 +       if (bq->init_data.resistor_sense > 0) {
 687 +               bq2415x_set_default_value(bq, charge_current);
 688 +               bq2415x_set_default_value(bq, termination_current);
 689 +               bq2415x_exec_command(bq, BQ2415X_CHARGE_TERMINATION_ENABLE);
 690 +       }
 691 +       bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
 692 +       return 0;
 693 +}
 694 +
 695 +#undef bq2415x_set_default_value
 696 +
 697 +/* charger mode functions */
 698 +
 699 +static int bq2415x_set_mode(struct bq2415x_device *bq, enum bq2415x_mode mode)
 700 +{
 701 +       int ret = 0;
 702 +       int charger = 0;
 703 +
 704 +       if (mode == BQ2415X_MODE_NONE ||
 705 +               mode == BQ2415X_MODE_HOST_CHARGER ||
 706 +               mode == BQ2415X_MODE_DEDICATED_CHARGER)
 707 +                       charger = 1;
 708 +
 709 +       if (charger)
 710 +               ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
 711 +       else
 712 +               ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
 713 +
 714 +       if (ret < 0)
 715 +               return ret;
 716 +
 717 +       switch (mode) {
 718 +       case BQ2415X_MODE_NONE:
 719 +               dev_info(bq->dev, "mode: N/A\n");
 720 +               ret = bq2415x_set_current_limit(bq, 100);
 721 +               break;
 722 +       case BQ2415X_MODE_HOST_CHARGER:
 723 +               dev_info(bq->dev, "mode: Host/HUB charger\n");
 724 +               ret = bq2415x_set_current_limit(bq, 500);
 725 +               break;
 726 +       case BQ2415X_MODE_DEDICATED_CHARGER:
 727 +               dev_info(bq->dev, "mode: Dedicated charger\n");
 728 +               ret = bq2415x_set_current_limit(bq, 1800);
 729 +               break;
 730 +       case BQ2415X_MODE_BOOST: /* Boost mode */
 731 +               dev_info(bq->dev, "mode: Boost\n");
 732 +               ret = bq2415x_set_current_limit(bq, 100);
 733 +               break;
 734 +       }
 735 +
 736 +       if (ret < 0)
 737 +               return ret;
 738 +
 739 +       if (charger)
 740 +               ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
 741 +       else
 742 +               ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_ENABLE);
 743 +
 744 +       if (ret < 0)
 745 +               return ret;
 746 +
 747 +       bq->mode = mode;
 748 +       return 0;
 749 +
 750 +}
 751 +
 752 +static void bq2415x_hook_function(enum bq2415x_mode mode, void *data)
 753 +{
 754 +       struct bq2415x_device *bq = data;
 755 +
 756 +       if (!bq)
 757 +               return;
 758 +
 759 +       bq->reported_mode = mode;
 760 +
 761 +       if (bq->automode < 1)
 762 +               return;
 763 +
 764 +       bq2415x_set_mode(bq, bq->reported_mode);
 765 +
 766 +}
 767 +
 768 +/* timer functions */
 769 +
 770 +static void bq2415x_set_autotimer(struct bq2415x_device *bq, int state)
 771 +{
 772 +       mutex_lock(&bq2415x_timer_mutex);
 773 +
 774 +       if (bq->autotimer == state) {
 775 +               mutex_unlock(&bq2415x_timer_mutex);
 776 +               return;
 777 +       }
 778 +
 779 +       bq->autotimer = state;
 780 +
 781 +       if (state) {
 782 +               schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
 783 +               bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
 784 +       } else {
 785 +               cancel_delayed_work_sync(&bq->work);
 786 +       }
 787 +
 788 +       mutex_unlock(&bq2415x_timer_mutex);
 789 +}
 790 +
 791 +static void bq2415x_timer_error(struct bq2415x_device *bq, const char *msg)
 792 +{
 793 +       dev_err(bq->dev, "%s\n", msg);
 794 +       if (bq->automode > 0)
 795 +               bq->automode = 0;
 796 +       bq2415x_set_mode(bq, BQ2415X_MODE_NONE);
 797 +       bq2415x_set_autotimer(bq, 0);
 798 +}
 799 +
 800 +static void bq2415x_timer_work(struct work_struct *work)
 801 +{
 802 +       struct bq2415x_device *bq = container_of(work, struct bq2415x_device,
 803 +                                               work.work);
 804 +       int ret, error, boost;
 805 +
 806 +       if (!bq->autotimer)
 807 +               return;
 808 +
 809 +       ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
 810 +       if (ret < 0) {
 811 +               bq2415x_timer_error(bq, "Reseting timer failed");
 812 +               return;
 813 +       }
 814 +
 815 +       boost = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_STATUS);
 816 +       if (boost < 0) {
 817 +               bq2415x_timer_error(bq, "Unknow error");
 818 +               return;
 819 +       }
 820 +
 821 +       error = bq2415x_exec_command(bq, BQ2415X_FAULT_STATUS);
 822 +       if (error < 0) {
 823 +               bq2415x_timer_error(bq, "Unknow error");
 824 +               return;
 825 +       }
 826 +
 827 +       if (boost) {
 828 +               switch (error) {
 829 +               case 0: /* No error */
 830 +                       break;
 831 +               case 6: /* Timer expired */
 832 +                       dev_err(bq->dev, "Timer expired\n");
 833 +                       break;
 834 +               case 3: /* Battery voltage too low */
 835 +                       dev_err(bq->dev, "Battery voltage to low\n");
 836 +                       break;
 837 +
 838 +               case 1: /* Overvoltage protection (chip fried) */
 839 +                       bq2415x_timer_error(bq,
 840 +                               "Overvolatge protection (chip fried)");
 841 +                       return;
 842 +               case 2: /* Overload */
 843 +                       bq2415x_timer_error(bq, "Overload");
 844 +                       return;
 845 +               case 4: /* Battery overvoltage protection */
 846 +                       bq2415x_timer_error(bq,
 847 +                               "Battery overvoltage protection");
 848 +                       return;
 849 +               case 5: /* Thermal shutdown (too hot) */
 850 +                       bq2415x_timer_error(bq,
 851 +                                       "Thermal shutdown (too hot)");
 852 +                       return;
 853 +               case 7: /* N/A */
 854 +                       bq2415x_timer_error(bq, "Unknown error");
 855 +                       return;
 856 +               }
 857 +       } else {
 858 +               switch (error) {
 859 +               case 0: /* No error */
 860 +                       break;
 861 +               case 2: /* Sleep mode */
 862 +                       dev_err(bq->dev, "Sleep mode\n");
 863 +                       break;
 864 +               case 3: /* Poor input source */
 865 +                       dev_err(bq->dev, "Poor input source\n");
 866 +                       break;
 867 +               case 6: /* Timer expired */
 868 +                       dev_err(bq->dev, "Timer expired\n");
 869 +                       break;
 870 +               case 7: /* No battery */
 871 +                       dev_err(bq->dev, "No battery\n");
 872 +                       break;
 873 +
 874 +               case 1: /* Overvoltage protection (chip fried) */
 875 +                       bq2415x_timer_error(bq,
 876 +                               "Overvolatge protection (chip fried)");
 877 +                       return;
 878 +               case 4: /* Battery overvoltage protection */
 879 +                       bq2415x_timer_error(bq,
 880 +                               "Battery overvoltage protection");
 881 +                       return;
 882 +               case 5: /* Thermal shutdown (too hot) */
 883 +                       bq2415x_timer_error(bq,
 884 +                               "Thermal shutdown (too hot)");
 885 +                       return;
 886 +               }
 887 +       }
 888 +
 889 +       schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
 890 +}
 891 +
 892 +/* power supply */
 893 +
 894 +static enum power_supply_property bq2415x_power_supply_props[] = {
 895 +       /* TODO: more power supply properties */
 896 +       POWER_SUPPLY_PROP_STATUS,
 897 +       POWER_SUPPLY_PROP_MODEL_NAME,
 898 +};
 899 +
 900 +static int bq2415x_power_supply_get_property(struct power_supply *psy,
 901 +       enum power_supply_property psp, union power_supply_propval *val)
 902 +{
 903 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
 904 +                                               charger);
 905 +       int ret;
 906 +
 907 +       switch (psp) {
 908 +       case POWER_SUPPLY_PROP_STATUS:
 909 +               ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS);
 910 +               if (ret < 0)
 911 +                       return ret;
 912 +               else if (ret == 0) /* Ready */
 913 +                       val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 914 +               else if (ret == 1) /* Charge in progress */
 915 +                       val->intval = POWER_SUPPLY_STATUS_CHARGING;
 916 +               else if (ret == 2) /* Charge done */
 917 +                       val->intval = POWER_SUPPLY_STATUS_FULL;
 918 +               else
 919 +                       val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 920 +               break;
 921 +       case POWER_SUPPLY_PROP_MODEL_NAME:
 922 +               val->strval = bq->model;
 923 +               break;
 924 +       default:
 925 +               return -EINVAL;
 926 +       }
 927 +       return 0;
 928 +}
 929 +
 930 +static int bq2415x_power_supply_init(struct bq2415x_device *bq)
 931 +{
 932 +       int ret;
 933 +       int chip;
 934 +       char revstr[8];
 935 +
 936 +       bq->charger.name = bq->name;
 937 +       bq->charger.type = POWER_SUPPLY_TYPE_USB;
 938 +       bq->charger.properties = bq2415x_power_supply_props;
 939 +       bq->charger.num_properties = ARRAY_SIZE(bq2415x_power_supply_props);
 940 +       bq->charger.get_property = bq2415x_power_supply_get_property;
 941 +
 942 +       ret = bq2415x_detect_chip(bq);
 943 +       if (ret < 0)
 944 +               chip = BQUNKNOWN;
 945 +       else
 946 +               chip = ret;
 947 +
 948 +       ret = bq2415x_detect_revision(bq);
 949 +       if (ret < 0)
 950 +               strcpy(revstr, "unknown");
 951 +       else
 952 +               sprintf(revstr, "1.%d", ret);
 953 +
 954 +       bq->model = kasprintf(GFP_KERNEL,
 955 +                               "chip %s, revision %s, vender code %.3d",
 956 +                               bq2415x_chip_name[chip], revstr,
 957 +                               bq2415x_get_vender_code(bq));
 958 +       if (!bq->model) {
 959 +               dev_err(bq->dev, "failed to allocate model name\n");
 960 +               return -ENOMEM;
 961 +       }
 962 +
 963 +       ret = power_supply_register(bq->dev, &bq->charger);
 964 +       if (ret) {
 965 +               kfree(bq->model);
 966 +               return ret;
 967 +       }
 968 +
 969 +       return 0;
 970 +}
 971 +
 972 +static void bq2415x_power_supply_exit(struct bq2415x_device *bq)
 973 +{
 974 +       bq->autotimer = 0;
 975 +       if (bq->automode > 0)
 976 +               bq->automode = 0;
 977 +       cancel_delayed_work_sync(&bq->work);
 978 +       power_supply_unregister(&bq->charger);
 979 +       kfree(bq->model);
 980 +}
 981 +
 982 +/* sysfs files */
 983 +
 984 +static ssize_t bq2415x_sysfs_show_status(struct device *dev,
 985 +               struct device_attribute *attr, char *buf)
 986 +{
 987 +       struct power_supply *psy = dev_get_drvdata(dev);
 988 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
 989 +                                               charger);
 990 +       enum bq2415x_command command;
 991 +       int ret;
 992 +
 993 +       if (strcmp(attr->attr.name, "otg_status") == 0)
 994 +               command = BQ2415X_OTG_STATUS;
 995 +       else if (strcmp(attr->attr.name, "charge_status") == 0)
 996 +               command = BQ2415X_CHARGE_STATUS;
 997 +       else if (strcmp(attr->attr.name, "boost_status") == 0)
 998 +               command = BQ2415X_BOOST_STATUS;
 999 +       else if (strcmp(attr->attr.name, "fault_status") == 0)
1000 +               command = BQ2415X_FAULT_STATUS;
1001 +       else
1002 +               return -EINVAL;
1003 +
1004 +       ret = bq2415x_exec_command(bq, command);
1005 +       if (ret < 0)
1006 +               return ret;
1007 +       else
1008 +               return sprintf(buf, "%d\n", ret);
1009 +}
1010 +
1011 +static ssize_t bq2415x_sysfs_set_timer(struct device *dev,
1012 +               struct device_attribute *attr, const char *buf, size_t count)
1013 +{
1014 +       struct power_supply *psy = dev_get_drvdata(dev);
1015 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1016 +                                               charger);
1017 +       int ret = 0;
1018 +
1019 +       if (strncmp(buf, "auto", 4) == 0)
1020 +               bq2415x_set_autotimer(bq, 1);
1021 +       else if (strncmp(buf, "off", 3) == 0)
1022 +               bq2415x_set_autotimer(bq, 0);
1023 +       else
1024 +               ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
1025 +
1026 +       if (ret < 0)
1027 +               return ret;
1028 +       else
1029 +               return count;
1030 +}
1031 +
1032 +static ssize_t bq2415x_sysfs_show_timer(struct device *dev,
1033 +               struct device_attribute *attr, char *buf)
1034 +{
1035 +       struct power_supply *psy = dev_get_drvdata(dev);
1036 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1037 +                                               charger);
1038 +
1039 +       if (bq->autotimer)
1040 +               return sprintf(buf, "auto\n");
1041 +       else
1042 +               return sprintf(buf, "off\n");
1043 +}
1044 +
1045 +static ssize_t bq2415x_sysfs_set_mode(struct device *dev,
1046 +               struct device_attribute *attr, const char *buf, size_t count)
1047 +{
1048 +       struct power_supply *psy = dev_get_drvdata(dev);
1049 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1050 +                                               charger);
1051 +       enum bq2415x_mode mode;
1052 +       int ret = 0;
1053 +
1054 +       if (strncmp(buf, "auto", 4) == 0) {
1055 +               if (bq->automode < 0)
1056 +                       return -ENOSYS;
1057 +               bq->automode = 1;
1058 +               mode = bq->reported_mode;
1059 +       } else if (strncmp(buf, "none", 4) == 0) {
1060 +               if (bq->automode > 0)
1061 +                       bq->automode = 0;
1062 +               mode = BQ2415X_MODE_NONE;
1063 +       } else if (strncmp(buf, "host", 4) == 0) {
1064 +               if (bq->automode > 0)
1065 +                       bq->automode = 0;
1066 +               mode = BQ2415X_MODE_HOST_CHARGER;
1067 +       } else if (strncmp(buf, "dedicated", 9) == 0) {
1068 +               if (bq->automode > 0)
1069 +                       bq->automode = 0;
1070 +               mode = BQ2415X_MODE_DEDICATED_CHARGER;
1071 +       } else if (strncmp(buf, "boost", 5) == 0) {
1072 +               if (bq->automode > 0)
1073 +                       bq->automode = 0;
1074 +               mode = BQ2415X_MODE_BOOST;
1075 +       } else if (strncmp(buf, "reset", 5) == 0) {
1076 +               bq2415x_reset_chip(bq);
1077 +               bq2415x_set_defaults(bq);
1078 +               if (bq->automode > 0)
1079 +                       bq->automode = 1;
1080 +               return count;
1081 +       } else
1082 +               return -EINVAL;
1083 +
1084 +       ret = bq2415x_set_mode(bq, mode);
1085 +       if (ret < 0)
1086 +               return ret;
1087 +       else
1088 +               return count;
1089 +}
1090 +
1091 +static ssize_t bq2415x_sysfs_show_mode(struct device *dev,
1092 +               struct device_attribute *attr, char *buf)
1093 +{
1094 +       struct power_supply *psy = dev_get_drvdata(dev);
1095 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1096 +                                               charger);
1097 +       ssize_t ret = 0;
1098 +
1099 +       if (bq->automode > 0)
1100 +               ret += sprintf(buf+ret, "auto (");
1101 +
1102 +       switch (bq->mode) {
1103 +       case BQ2415X_MODE_NONE:
1104 +               ret += sprintf(buf+ret, "none");
1105 +               break;
1106 +       case BQ2415X_MODE_HOST_CHARGER:
1107 +               ret += sprintf(buf+ret, "host");
1108 +               break;
1109 +       case BQ2415X_MODE_DEDICATED_CHARGER:
1110 +               ret += sprintf(buf+ret, "dedicated");
1111 +               break;
1112 +       case BQ2415X_MODE_BOOST:
1113 +               ret += sprintf(buf+ret, "boost");
1114 +               break;
1115 +       }
1116 +
1117 +       if (bq->automode > 0)
1118 +               ret += sprintf(buf+ret, ")");
1119 +
1120 +       ret += sprintf(buf+ret, "\n");
1121 +       return ret;
1122 +}
1123 +
1124 +static ssize_t bq2415x_sysfs_show_reported_mode(struct device *dev,
1125 +               struct device_attribute *attr, char *buf)
1126 +{
1127 +       struct power_supply *psy = dev_get_drvdata(dev);
1128 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1129 +                                               charger);
1130 +
1131 +       switch (bq->reported_mode) {
1132 +       case BQ2415X_MODE_NONE:
1133 +               return sprintf(buf, "none\n");
1134 +       case BQ2415X_MODE_HOST_CHARGER:
1135 +               return sprintf(buf, "host\n");
1136 +       case BQ2415X_MODE_DEDICATED_CHARGER:
1137 +               return sprintf(buf, "dedicated\n");
1138 +       case BQ2415X_MODE_BOOST:
1139 +               return sprintf(buf, "boost\n");
1140 +       }
1141 +
1142 +       return -EINVAL;
1143 +}
1144 +
1145 +static ssize_t bq2415x_sysfs_set_registers(struct device *dev,
1146 +               struct device_attribute *attr, const char *buf, size_t count)
1147 +{
1148 +       struct power_supply *psy = dev_get_drvdata(dev);
1149 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1150 +                                               charger);
1151 +       ssize_t ret = 0;
1152 +       char *end;
1153 +       int reg;
1154 +       int val;
1155 +
1156 +       reg = simple_strtol(buf, &end, 16);
1157 +       if (reg < 0 || reg > 4)
1158 +               return -EINVAL;
1159 +
1160 +       val = simple_strtol(end+1, NULL, 16);
1161 +       if (val < 0 || val > 255)
1162 +               return -EINVAL;
1163 +
1164 +       ret = bq2415x_i2c_write(bq, reg, val);
1165 +       if (ret < 0)
1166 +               return ret;
1167 +       else
1168 +               return count;
1169 +}
1170 +
1171 +static ssize_t bq2415x_sysfs_print_reg(struct bq2415x_device *bq,
1172 +                                       u8 reg, char *buf)
1173 +{
1174 +       int ret = bq2415x_i2c_read(bq, reg);
1175 +       if (ret < 0)
1176 +               return sprintf(buf, "%#.2x=error %d\n", reg, ret);
1177 +       else
1178 +               return sprintf(buf, "%#.2x=%#.2x\n", reg, ret);
1179 +}
1180 +
1181 +static ssize_t bq2415x_sysfs_show_registers(struct device *dev,
1182 +               struct device_attribute *attr, char *buf)
1183 +{
1184 +       struct power_supply *psy = dev_get_drvdata(dev);
1185 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1186 +                                               charger);
1187 +       ssize_t ret = 0;
1188 +
1189 +       ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_STATUS, buf+ret);
1190 +       ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CONTROL, buf+ret);
1191 +       ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VOLTAGE, buf+ret);
1192 +       ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VENDER, buf+ret);
1193 +       ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CURRENT, buf+ret);
1194 +       return ret;
1195 +}
1196 +
1197 +/* Current & Volatage settings */
1198 +
1199 +static ssize_t bq2415x_sysfs_set_limit(struct device *dev,
1200 +               struct device_attribute *attr, const char *buf, size_t count)
1201 +{
1202 +       struct power_supply *psy = dev_get_drvdata(dev);
1203 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1204 +                                               charger);
1205 +       long val;
1206 +       int ret;
1207 +
1208 +       if (strict_strtol(buf, 10, &val) < 0)
1209 +               return -EINVAL;
1210 +
1211 +       if (strcmp(attr->attr.name, "current_limit") == 0)
1212 +               ret = bq2415x_set_current_limit(bq, val);
1213 +       else if (strcmp(attr->attr.name, "weak_battery_voltage") == 0)
1214 +               ret = bq2415x_set_weak_battery_voltage(bq, val);
1215 +       else if (strcmp(attr->attr.name, "battery_regulation_voltage") == 0)
1216 +               ret = bq2415x_set_battery_regulation_voltage(bq, val);
1217 +       else if (strcmp(attr->attr.name, "charge_current") == 0)
1218 +               ret = bq2415x_set_charge_current(bq, val);
1219 +       else if (strcmp(attr->attr.name, "termination_current") == 0)
1220 +               ret = bq2415x_set_termination_current(bq, val);
1221 +       else
1222 +               return -EINVAL;
1223 +
1224 +       if (ret < 0)
1225 +               return ret;
1226 +       else
1227 +               return count;
1228 +}
1229 +
1230 +static ssize_t bq2415x_sysfs_show_limit(struct device *dev,
1231 +               struct device_attribute *attr, char *buf)
1232 +{
1233 +       struct power_supply *psy = dev_get_drvdata(dev);
1234 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1235 +                                               charger);
1236 +       int ret;
1237 +
1238 +       if (strcmp(attr->attr.name, "current_limit") == 0)
1239 +               ret = bq2415x_get_current_limit(bq);
1240 +       else if (strcmp(attr->attr.name, "weak_battery_voltage") == 0)
1241 +               ret = bq2415x_get_weak_battery_voltage(bq);
1242 +       else if (strcmp(attr->attr.name, "battery_regulation_voltage") == 0)
1243 +               ret = bq2415x_get_battery_regulation_voltage(bq);
1244 +       else if (strcmp(attr->attr.name, "charge_current") == 0)
1245 +               ret = bq2415x_get_charge_current(bq);
1246 +       else if (strcmp(attr->attr.name, "termination_current") == 0)
1247 +               ret = bq2415x_get_termination_current(bq);
1248 +       else
1249 +               return -EINVAL;
1250 +
1251 +       if (ret < 0)
1252 +               return ret;
1253 +       else
1254 +               return sprintf(buf, "%d\n", ret);
1255 +}
1256 +
1257 +static ssize_t bq2415x_sysfs_set_enable(struct device *dev,
1258 +               struct device_attribute *attr, const char *buf, size_t count)
1259 +{
1260 +       struct power_supply *psy = dev_get_drvdata(dev);
1261 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1262 +                                               charger);
1263 +       enum bq2415x_command command;
1264 +       long val;
1265 +       int ret;
1266 +
1267 +       if (strict_strtol(buf, 10, &val) < 0)
1268 +               return -EINVAL;
1269 +
1270 +       if (strcmp(attr->attr.name, "charge_termination_enable") == 0)
1271 +               command = val ? BQ2415X_CHARGE_TERMINATION_ENABLE :
1272 +                       BQ2415X_CHARGE_TERMINATION_DISABLE;
1273 +       else if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
1274 +               command = val ? BQ2415X_HIGH_IMPEDANCE_ENABLE :
1275 +                       BQ2415X_HIGH_IMPEDANCE_DISABLE;
1276 +       else if (strcmp(attr->attr.name, "otg_pin_enable") == 0)
1277 +               command = val ? BQ2415X_OTG_PIN_ENABLE :
1278 +                       BQ2415X_OTG_PIN_DISABLE;
1279 +       else if (strcmp(attr->attr.name, "stat_pin_enable") == 0)
1280 +               command = val ? BQ2415X_STAT_PIN_ENABLE :
1281 +                       BQ2415X_STAT_PIN_DISABLE;
1282 +       else
1283 +               return -EINVAL;
1284 +
1285 +       ret = bq2415x_exec_command(bq, command);
1286 +       if (ret < 0)
1287 +               return ret;
1288 +       else
1289 +               return count;
1290 +}
1291 +
1292 +static ssize_t bq2415x_sysfs_show_enable(struct device *dev,
1293 +               struct device_attribute *attr, char *buf)
1294 +{
1295 +       struct power_supply *psy = dev_get_drvdata(dev);
1296 +       struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1297 +                                               charger);
1298 +       enum bq2415x_command command;
1299 +       int ret;
1300 +
1301 +       if (strcmp(attr->attr.name, "charge_termination_enable") == 0)
1302 +               command = BQ2415X_CHARGE_TERMINATION_STATUS;
1303 +       else if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
1304 +               command = BQ2415X_HIGH_IMPEDANCE_STATUS;
1305 +       else if (strcmp(attr->attr.name, "otg_pin_enable") == 0)
1306 +               command = BQ2415X_OTG_PIN_STATUS;
1307 +       else if (strcmp(attr->attr.name, "stat_pin_enable") == 0)
1308 +               command = BQ2415X_STAT_PIN_STATUS;
1309 +       else
1310 +               return -EINVAL;
1311 +
1312 +       ret = bq2415x_exec_command(bq, command);
1313 +       if (ret < 0)
1314 +               return ret;
1315 +       else
1316 +               return sprintf(buf, "%d\n", ret);
1317 +}
1318 +
1319 +static DEVICE_ATTR(current_limit, S_IWUSR | S_IRUGO,
1320 +               bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1321 +static DEVICE_ATTR(weak_battery_voltage, S_IWUSR | S_IRUGO,
1322 +               bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1323 +static DEVICE_ATTR(battery_regulation_voltage, S_IWUSR | S_IRUGO,
1324 +               bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1325 +static DEVICE_ATTR(charge_current, S_IWUSR | S_IRUGO,
1326 +               bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1327 +static DEVICE_ATTR(termination_current, S_IWUSR | S_IRUGO,
1328 +               bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1329 +
1330 +static DEVICE_ATTR(charge_termination_enable, S_IWUSR | S_IRUGO,
1331 +               bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1332 +static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
1333 +               bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1334 +static DEVICE_ATTR(otg_pin_enable, S_IWUSR | S_IRUGO,
1335 +               bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1336 +static DEVICE_ATTR(stat_pin_enable, S_IWUSR | S_IRUGO,
1337 +               bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1338 +
1339 +static DEVICE_ATTR(reported_mode, S_IRUGO,
1340 +               bq2415x_sysfs_show_reported_mode, NULL);
1341 +static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO,
1342 +               bq2415x_sysfs_show_mode, bq2415x_sysfs_set_mode);
1343 +static DEVICE_ATTR(timer, S_IWUSR | S_IRUGO,
1344 +               bq2415x_sysfs_show_timer, bq2415x_sysfs_set_timer);
1345 +
1346 +static DEVICE_ATTR(registers, S_IWUSR | S_IRUGO,
1347 +               bq2415x_sysfs_show_registers, bq2415x_sysfs_set_registers);
1348 +
1349 +static DEVICE_ATTR(otg_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1350 +static DEVICE_ATTR(charge_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1351 +static DEVICE_ATTR(boost_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1352 +static DEVICE_ATTR(fault_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1353 +
1354 +static struct attribute *bq2415x_sysfs_attributes[] = {
1355 +       &dev_attr_current_limit.attr,
1356 +       &dev_attr_weak_battery_voltage.attr,
1357 +       &dev_attr_battery_regulation_voltage.attr,
1358 +       &dev_attr_charge_current.attr,
1359 +       &dev_attr_termination_current.attr,
1360 +
1361 +       &dev_attr_charge_termination_enable.attr,
1362 +       &dev_attr_high_impedance_enable.attr,
1363 +       &dev_attr_otg_pin_enable.attr,
1364 +       &dev_attr_stat_pin_enable.attr,
1365 +
1366 +       &dev_attr_reported_mode.attr,
1367 +       &dev_attr_mode.attr,
1368 +       &dev_attr_timer.attr,
1369 +
1370 +       &dev_attr_registers.attr,
1371 +
1372 +       &dev_attr_otg_status.attr,
1373 +       &dev_attr_charge_status.attr,
1374 +       &dev_attr_boost_status.attr,
1375 +       &dev_attr_fault_status.attr,
1376 +       NULL,
1377 +};
1378 +
1379 +static const struct attribute_group bq2415x_sysfs_attr_group = {
1380 +       .attrs = bq2415x_sysfs_attributes,
1381 +};
1382 +
1383 +static int bq2415x_sysfs_init(struct bq2415x_device *bq)
1384 +{
1385 +       return sysfs_create_group(&bq->charger.dev->kobj,
1386 +                       &bq2415x_sysfs_attr_group);
1387 +}
1388 +
1389 +static void bq2415x_sysfs_exit(struct bq2415x_device *bq)
1390 +{
1391 +       sysfs_remove_group(&bq->charger.dev->kobj, &bq2415x_sysfs_attr_group);
1392 +}
1393 +
1394 +/* bq2415x register */
1395 +
1396 +static int bq2415x_probe(struct i2c_client *client,
1397 +               const struct i2c_device_id *id)
1398 +{
1399 +       int ret;
1400 +       int num;
1401 +       char *name;
1402 +       struct bq2415x_device *bq;
1403 +
1404 +       if (!client->dev.platform_data) {
1405 +               dev_err(&client->dev, "platform data not set\n");
1406 +               return -ENODEV;
1407 +       }
1408 +
1409 +       /* Get new ID for the new device */
1410 +       ret = idr_pre_get(&bq2415x_id, GFP_KERNEL);
1411 +       if (ret == 0)
1412 +               return -ENOMEM;
1413 +
1414 +       mutex_lock(&bq2415x_id_mutex);
1415 +       ret = idr_get_new(&bq2415x_id, client, &num);
1416 +       mutex_unlock(&bq2415x_id_mutex);
1417 +
1418 +       if (ret < 0)
1419 +               return ret;
1420 +
1421 +       name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num);
1422 +       if (!name) {
1423 +               dev_err(&client->dev, "failed to allocate device name\n");
1424 +               ret = -ENOMEM;
1425 +               goto error_1;
1426 +       }
1427 +
1428 +       bq = kzalloc(sizeof(*bq), GFP_KERNEL);
1429 +       if (!bq) {
1430 +               dev_err(&client->dev, "failed to allocate device data\n");
1431 +               ret = -ENOMEM;
1432 +               goto error_2;
1433 +       }
1434 +
1435 +       i2c_set_clientdata(client, bq);
1436 +
1437 +       bq->id = num;
1438 +       bq->dev = &client->dev;
1439 +       bq->chip = id->driver_data;
1440 +       bq->name = name;
1441 +       bq->mode = BQ2415X_MODE_NONE;
1442 +       bq->reported_mode = BQ2415X_MODE_NONE;
1443 +       bq->autotimer = 0;
1444 +       bq->automode = 0;
1445 +
1446 +       memcpy(&bq->init_data, client->dev.platform_data,
1447 +                       sizeof(bq->init_data));
1448 +
1449 +       bq2415x_reset_chip(bq);
1450 +
1451 +       ret = bq2415x_power_supply_init(bq);
1452 +       if (ret) {
1453 +               dev_err(bq->dev, "failed to register power supply: %d\n", ret);
1454 +               goto error_3;
1455 +       }
1456 +
1457 +       ret = bq2415x_sysfs_init(bq);
1458 +       if (ret) {
1459 +               dev_err(bq->dev, "failed to create sysfs entries: %d\n", ret);
1460 +               goto error_4;
1461 +       }
1462 +
1463 +       ret = bq2415x_set_defaults(bq);
1464 +       if (ret) {
1465 +               dev_err(bq->dev, "failed to set default values: %d\n", ret);
1466 +               goto error_5;
1467 +       }
1468 +
1469 +       if (bq->init_data.set_mode_hook) {
1470 +               if (bq->init_data.set_mode_hook(
1471 +                               bq2415x_hook_function, bq)) {
1472 +                       bq->automode = 1;
1473 +                       bq2415x_set_mode(bq, bq->reported_mode);
1474 +                       dev_info(bq->dev, "automode enabled\n");
1475 +               } else {
1476 +                       bq->automode = -1;
1477 +                       dev_info(bq->dev, "automode failed\n");
1478 +               }
1479 +       } else {
1480 +               bq->automode = -1;
1481 +               dev_info(bq->dev, "automode not supported\n");
1482 +       }
1483 +
1484 +       INIT_DELAYED_WORK(&bq->work, bq2415x_timer_work);
1485 +       bq2415x_set_autotimer(bq, 1);
1486 +
1487 +       dev_info(bq->dev, "driver registred\n");
1488 +       return 0;
1489 +
1490 +error_5:
1491 +       bq2415x_sysfs_exit(bq);
1492 +error_4:
1493 +       bq2415x_power_supply_exit(bq);
1494 +error_3:
1495 +       kfree(bq);
1496 +error_2:
1497 +       kfree(name);
1498 +error_1:
1499 +       mutex_lock(&bq2415x_id_mutex);
1500 +       idr_remove(&bq2415x_id, num);
1501 +       mutex_unlock(&bq2415x_id_mutex);
1502 +
1503 +       return ret;
1504 +}
1505 +
1506 +/* bq2415x unregister */
1507 +
1508 +static int bq2415x_remove(struct i2c_client *client)
1509 +{
1510 +       struct bq2415x_device *bq = i2c_get_clientdata(client);
1511 +
1512 +       if (bq->init_data.set_mode_hook)
1513 +               bq->init_data.set_mode_hook(NULL, NULL);
1514 +
1515 +       bq2415x_sysfs_exit(bq);
1516 +       bq2415x_power_supply_exit(bq);
1517 +
1518 +       bq2415x_reset_chip(bq);
1519 +
1520 +       mutex_lock(&bq2415x_id_mutex);
1521 +       idr_remove(&bq2415x_id, bq->id);
1522 +       mutex_unlock(&bq2415x_id_mutex);
1523 +
1524 +       dev_info(bq->dev, "driver unregistred\n");
1525 +
1526 +       kfree(bq->name);
1527 +       kfree(bq);
1528 +
1529 +       return 0;
1530 +}
1531 +
1532 +static const struct i2c_device_id bq2415x_i2c_id_table[] = {
1533 +       { "bq2415x", BQUNKNOWN },
1534 +       { "bq24150", BQ24150 },
1535 +       { "bq24150a", BQ24150A },
1536 +       { "bq24151", BQ24151 },
1537 +       { "bq24151a", BQ24151A },
1538 +       { "bq24152", BQ24152 },
1539 +       { "bq24153", BQ24153 },
1540 +       { "bq24153a", BQ24153A },
1541 +       { "bq24155", BQ24155 },
1542 +       { "bq24156", BQ24156 },
1543 +       { "bq24156a", BQ24156A },
1544 +       { "bq24158", BQ24158 },
1545 +       {},
1546 +};
1547 +MODULE_DEVICE_TABLE(i2c, bq2415x_i2c_id_table);
1548 +
1549 +static struct i2c_driver bq2415x_driver = {
1550 +       .driver = {
1551 +               .name = "bq2415x-charger",
1552 +       },
1553 +       .probe = bq2415x_probe,
1554 +       .remove = bq2415x_remove,
1555 +       .id_table = bq2415x_i2c_id_table,
1556 +};
1557 +
1558 +static int __init bq2415x_init(void)
1559 +{
1560 +       return i2c_add_driver(&bq2415x_driver);
1561 +}
1562 +module_init(bq2415x_init);
1563 +
1564 +static void __exit bq2415x_exit(void)
1565 +{
1566 +       i2c_del_driver(&bq2415x_driver);
1567 +}
1568 +module_exit(bq2415x_exit);
1569 +
1570 +MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
1571 +MODULE_DESCRIPTION("bq2415x charger driver");
1572 +MODULE_LICENSE("GPL");
1573 --- /dev/null
1574 +++ kernel-power/include/linux/power/bq2415x_charger.h
1575 @@ -0,0 +1,90 @@
1576 +/*
1577 +    bq2415x_charger.h - bq2415x charger driver
1578 +    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
1579 +
1580 +    This program is free software; you can redistribute it and/or modify
1581 +    it under the terms of the GNU General Public License as published by
1582 +    the Free Software Foundation; either version 2 of the License, or
1583 +    (at your option) any later version.
1584 +
1585 +    This program is distributed in the hope that it will be useful,
1586 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
1587 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1588 +    GNU General Public License for more details.
1589 +
1590 +    You should have received a copy of the GNU General Public License along
1591 +    with this program; if not, write to the Free Software Foundation, Inc.,
1592 +    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
1593 +*/
1594 +
1595 +#ifndef BQ2415X_CHARGER_H
1596 +#define BQ2415X_CHARGER_H
1597 +
1598 +/*
1599 +  This is platform data for bq2415x chip. It contains default board voltages
1600 +  and currents which can be also later configured via sysfs. If value is -1
1601 +  then default chip value (specified in datasheet) will be used.
1602 +
1603 +  Value resistor_sense is needed for for configuring charge and termination
1604 +  current. It it is less or equal to zero, configuring charge and termination
1605 +  current will not be possible.
1606 +
1607 +  Function set_mode_hook is needed for automode (setting correct current limit
1608 +  when charger is connected/disconnected or setting boost mode). When is NULL,
1609 +  automode function is disabled. When is not NULL, it must have this prototype:
1610 +
1611 +    int (*set_mode_hook)(
1612 +      void (*hook)(enum bq2415x_mode mode, void *data),
1613 +      void *data)
1614 +
1615 +  hook is hook function (see below) and data is pointer to driver private data
1616 +
1617 +  bq2415x driver will call it as:
1618 +
1619 +    platform_data->set_mode_hook(bq2415x_hook_function, bq2415x_device);
1620 +
1621 +  Board/platform function set_mode_hook return non zero value when hook
1622 +  function was successfull registred. Platform code should call that hook
1623 +  function (which get from pointer, with data) every time when charger was
1624 +  connected/disconnected or require to enable boost mode. bq2415x driver then
1625 +  will set correct current limit, enable/disable charger or boost mode.
1626 +
1627 +  Hook function has this prototype:
1628 +
1629 +    void hook(enum bq2415x_mode mode, void *data);
1630 +
1631 +  mode is bq2415x mode (charger or boost)
1632 +  data is pointer to driver private data (which get from set_charger_type_hook)
1633 +
1634 +  When bq driver is being unloaded, it call function:
1635 +
1636 +    platform_data->set_mode_hook(NULL, NULL);
1637 +
1638 +  (hook function and driver private data are NULL)
1639 +
1640 +  After thet board/platform code must not call driver hook function! It is
1641 +  possible that pointer to hook function will not be valid and calling will
1642 +  cause undefined result.
1643 +
1644 +*/
1645 +
1646 +/* Supported modes with maximal current limit */
1647 +enum bq2415x_mode {
1648 +       BQ2415X_MODE_NONE,              /* unknown or no charger (100mA) */
1649 +       BQ2415X_MODE_HOST_CHARGER,      /* usb host/hub charger (500mA) */
1650 +       BQ2415X_MODE_DEDICATED_CHARGER, /* dedicated charger (unlimited) */
1651 +       BQ2415X_MODE_BOOST,             /* boost mode (charging disabled) */
1652 +};
1653 +
1654 +struct bq2415x_platform_data {
1655 +       int current_limit;              /* mA */
1656 +       int weak_battery_voltage;       /* mV */
1657 +       int battery_regulation_voltage; /* mV */
1658 +       int charge_current;             /* mA */
1659 +       int termination_current;        /* mA */
1660 +       int resistor_sense;             /* m ohm */
1661 +       int (*set_mode_hook)(void (*hook)(enum bq2415x_mode mode, void *data),
1662 +                            void *data);
1663 +};
1664 +
1665 +#endif