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