projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-linus-v3.6-rc1' of git://oss.sgi.com/xfs/xfs
[deliverable/linux.git] / drivers / power / bq27x00_battery.c
CommitLineData
b996ad0e
RG		 1/*
2 * BQ27x00 battery driver
3 *
4 * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
7fb7ba58 6 * Copyright (C) 2010-2011 Lars-Peter Clausen <lars@metafoo.de>
73c244a8 7 * Copyright (C) 2011 Pali Rohár <pali.rohar@gmail.com>
b996ad0e
RG		 8 *
9 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
10 *
11 * This package is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18 *
19 */
631c17ee
PR		 20
21/*
22 * Datasheets:
23 * http://focus.ti.com/docs/prod/folders/print/bq27000.html
24 * http://focus.ti.com/docs/prod/folders/print/bq27500.html
25 */
26
b996ad0e
RG		 27#include <linux/module.h>
28#include <linux/param.h>
29#include <linux/jiffies.h>
30#include <linux/workqueue.h>
31#include <linux/delay.h>
32#include <linux/platform_device.h>
33#include <linux/power_supply.h>
34#include <linux/idr.h>
b996ad0e 35#include <linux/i2c.h>
5a0e3ad6 36#include <linux/slab.h>
8aef7e8f 37#include <asm/unaligned.h>
b996ad0e 38
7fb7ba58
LPC		 39#include <linux/power/bq27x00_battery.h>
40
631c17ee 41#define DRIVER_VERSION "1.2.0"
b996ad0e
RG		 42
43#define BQ27x00_REG_TEMP 0x06
44#define BQ27x00_REG_VOLT 0x08
b996ad0e
RG		 45#define BQ27x00_REG_AI 0x14
46#define BQ27x00_REG_FLAGS 0x0A
4e924a81
GI		 47#define BQ27x00_REG_TTE 0x16
48#define BQ27x00_REG_TTF 0x18
49#define BQ27x00_REG_TTECP 0x26
202e0116 50#define BQ27x00_REG_NAC 0x0C /* Nominal available capacity */
631c17ee
PR		 51#define BQ27x00_REG_LMD 0x12 /* Last measured discharge */
52#define BQ27x00_REG_CYCT 0x2A /* Cycle count total */
202e0116 53#define BQ27x00_REG_AE 0x22 /* Available energy */
b996ad0e 54
e20908d9 55#define BQ27000_REG_RSOC 0x0B /* Relative State-of-Charge */
631c17ee 56#define BQ27000_REG_ILMD 0x76 /* Initial last measured discharge */
d66bab3f
PR		 57#define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */
58#define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */
4b226c2c 59#define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */
c1b9ab67 60#define BQ27000_FLAG_FC BIT(5)
d66bab3f 61#define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */
e20908d9 62
bf7d4140 63#define BQ27500_REG_SOC 0x2C
631c17ee 64#define BQ27500_REG_DCAP 0x3C /* Design capacity */
b7aaacf5 65#define BQ27500_FLAG_DSC BIT(0)
d66bab3f
PR		 66#define BQ27500_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */
67#define BQ27500_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */
b7aaacf5 68#define BQ27500_FLAG_FC BIT(9)
e20908d9 69
a2e5118c
PR		 70#define BQ27000_RS 20 /* Resistor sense */
71
b996ad0e
RG		 72struct bq27x00_device_info;
73struct bq27x00_access_methods {
297a533b 74 int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);
b996ad0e
RG		 75};
76
e20908d9
GI		 77enum bq27x00_chip { BQ27000, BQ27500 };
78
297a533b
LPC		 79struct bq27x00_reg_cache {
80 int temperature;
81 int time_to_empty;
82 int time_to_empty_avg;
83 int time_to_full;
631c17ee 84 int charge_full;
73c244a8 85 int cycle_count;
297a533b 86 int capacity;
a8f6bd23 87 int energy;
297a533b 88 int flags;
297a533b
LPC		 89};
90
b996ad0e
RG		 91struct bq27x00_device_info {
92 struct device *dev;
93 int id;
e20908d9 94 enum bq27x00_chip chip;
b996ad0e 95
297a533b 96 struct bq27x00_reg_cache cache;
631c17ee
PR		 97 int charge_design_full;
98
297a533b 99 unsigned long last_update;
740b755a 100 struct delayed_work work;
297a533b 101
a40402ef
LPC		 102 struct power_supply bat;
103
104 struct bq27x00_access_methods bus;
740b755a
LPC		 105
106 struct mutex lock;
b996ad0e
RG		 107};
108
109static enum power_supply_property bq27x00_battery_props[] = {
4e924a81 110 POWER_SUPPLY_PROP_STATUS,
b996ad0e
RG		 111 POWER_SUPPLY_PROP_PRESENT,
112 POWER_SUPPLY_PROP_VOLTAGE_NOW,
113 POWER_SUPPLY_PROP_CURRENT_NOW,
114 POWER_SUPPLY_PROP_CAPACITY,
d66bab3f 115 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
b996ad0e 116 POWER_SUPPLY_PROP_TEMP,
4e924a81
GI		 117 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
118 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
119 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
5661f334 120 POWER_SUPPLY_PROP_TECHNOLOGY,
631c17ee
PR		 121 POWER_SUPPLY_PROP_CHARGE_FULL,
122 POWER_SUPPLY_PROP_CHARGE_NOW,
123 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
73c244a8 124 POWER_SUPPLY_PROP_CYCLE_COUNT,
631c17ee 125 POWER_SUPPLY_PROP_ENERGY_NOW,
b996ad0e
RG		 126};
127
740b755a
LPC		 128static unsigned int poll_interval = 360;
129module_param(poll_interval, uint, 0644);
130MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
131 "0 disables polling");
132
b996ad0e
RG		 133/*
134 * Common code for BQ27x00 devices
135 */
136
a40402ef 137static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
297a533b 138 bool single)
b996ad0e 139{
297a533b 140 return di->bus.read(di, reg, single);
b996ad0e
RG		 141}
142
143/*
297a533b 144 * Return the battery Relative State-of-Charge
b996ad0e
RG		 145 * Or < 0 if something fails.
146 */
297a533b 147static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
b996ad0e 148{
297a533b 149 int rsoc;
b996ad0e 150
e20908d9 151 if (di->chip == BQ27500)
297a533b 152 rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);
e20908d9 153 else
297a533b
LPC		 154 rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);
155
156 if (rsoc < 0)
c6cd4f26 157 dev_dbg(di->dev, "error reading relative State-of-Charge\n");
297a533b
LPC		 158
159 return rsoc;
b996ad0e
RG		 160}
161
631c17ee
PR		 162/*
163 * Return a battery charge value in µAh
164 * Or < 0 if something fails.
165 */
166static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
167{
168 int charge;
169
170 charge = bq27x00_read(di, reg, false);
171 if (charge < 0) {
c6cd4f26
PR		 172 dev_dbg(di->dev, "error reading charge register %02x: %d\n",
173 reg, charge);
631c17ee
PR		 174 return charge;
175 }
176
177 if (di->chip == BQ27500)
178 charge *= 1000;
179 else
180 charge = charge * 3570 / BQ27000_RS;
181
182 return charge;
183}
184
185/*
186 * Return the battery Nominal available capaciy in µAh
187 * Or < 0 if something fails.
188 */
189static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
190{
191 return bq27x00_battery_read_charge(di, BQ27x00_REG_NAC);
192}
193
194/*
195 * Return the battery Last measured discharge in µAh
196 * Or < 0 if something fails.
197 */
198static inline int bq27x00_battery_read_lmd(struct bq27x00_device_info *di)
199{
200 return bq27x00_battery_read_charge(di, BQ27x00_REG_LMD);
201}
202
203/*
204 * Return the battery Initial last measured discharge in µAh
205 * Or < 0 if something fails.
206 */
207static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
208{
209 int ilmd;
210
211 if (di->chip == BQ27500)
212 ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
213 else
214 ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
215
216 if (ilmd < 0) {
c6cd4f26 217 dev_dbg(di->dev, "error reading initial last measured discharge\n");
631c17ee
PR		 218 return ilmd;
219 }
220
221 if (di->chip == BQ27500)
222 ilmd *= 1000;
223 else
224 ilmd = ilmd * 256 * 3570 / BQ27000_RS;
225
226 return ilmd;
227}
228
a8f6bd23
PR		 229/*
230 * Return the battery Available energy in µWh
231 * Or < 0 if something fails.
232 */
233static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
234{
235 int ae;
236
237 ae = bq27x00_read(di, BQ27x00_REG_AE, false);
238 if (ae < 0) {
c6cd4f26 239 dev_dbg(di->dev, "error reading available energy\n");
a8f6bd23
PR		 240 return ae;
241 }
242
243 if (di->chip == BQ27500)
244 ae *= 1000;
245 else
246 ae = ae * 29200 / BQ27000_RS;
247
248 return ae;
249}
250
d149e98e
PR		 251/*
252 * Return the battery temperature in tenths of degree Celsius
253 * Or < 0 if something fails.
254 */
255static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
256{
257 int temp;
258
259 temp = bq27x00_read(di, BQ27x00_REG_TEMP, false);
260 if (temp < 0) {
261 dev_err(di->dev, "error reading temperature\n");
262 return temp;
263 }
264
265 if (di->chip == BQ27500)
266 temp -= 2731;
267 else
268 temp = ((temp * 5) - 5463) / 2;
269
270 return temp;
271}
272
631c17ee
PR		 273/*
274 * Return the battery Cycle count total
275 * Or < 0 if something fails.
276 */
277static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
278{
279 int cyct;
280
281 cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false);
282 if (cyct < 0)
283 dev_err(di->dev, "error reading cycle count total\n");
284
285 return cyct;
286}
287
b996ad0e 288/*
297a533b
LPC		 289 * Read a time register.
290 * Return < 0 if something fails.
b996ad0e 291 */
297a533b 292static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
b996ad0e 293{
297a533b 294 int tval;
b996ad0e 295
297a533b
LPC		 296 tval = bq27x00_read(di, reg, false);
297 if (tval < 0) {
c6cd4f26
PR		 298 dev_dbg(di->dev, "error reading time register %02x: %d\n",
299 reg, tval);
297a533b 300 return tval;
b996ad0e
RG		 301 }
302
297a533b
LPC		 303 if (tval == 65535)
304 return -ENODATA;
305
306 return tval * 60;
307}
308
309static void bq27x00_update(struct bq27x00_device_info *di)
310{
311 struct bq27x00_reg_cache cache = {0, };
312 bool is_bq27500 = di->chip == BQ27500;
313
4d403659 314 cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, !is_bq27500);
297a533b 315 if (cache.flags >= 0) {
4b226c2c 316 if (!is_bq27500 && (cache.flags & BQ27000_FLAG_CI)) {
c6cd4f26 317 dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
4b226c2c 318 cache.capacity = -ENODATA;
a8f6bd23 319 cache.energy = -ENODATA;
4b226c2c
PR		 320 cache.time_to_empty = -ENODATA;
321 cache.time_to_empty_avg = -ENODATA;
322 cache.time_to_full = -ENODATA;
323 cache.charge_full = -ENODATA;
324 } else {
325 cache.capacity = bq27x00_battery_read_rsoc(di);
a8f6bd23 326 cache.energy = bq27x00_battery_read_energy(di);
4b226c2c
PR		 327 cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE);
328 cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP);
329 cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF);
330 cache.charge_full = bq27x00_battery_read_lmd(di);
331 }
d149e98e 332 cache.temperature = bq27x00_battery_read_temperature(di);
73c244a8 333 cache.cycle_count = bq27x00_battery_read_cyct(di);
297a533b 334
631c17ee
PR		 335 /* We only have to read charge design full once */
336 if (di->charge_design_full <= 0)
337 di->charge_design_full = bq27x00_battery_read_ilmd(di);
297a533b
LPC		 338 }
339
b68f6216 340 if (memcmp(&di->cache, &cache, sizeof(cache)) != 0) {
297a533b
LPC		 341 di->cache = cache;
342 power_supply_changed(&di->bat);
343 }
344
345 di->last_update = jiffies;
346}
347
740b755a
LPC		 348static void bq27x00_battery_poll(struct work_struct *work)
349{
350 struct bq27x00_device_info *di =
351 container_of(work, struct bq27x00_device_info, work.work);
352
353 bq27x00_update(di);
354
355 if (poll_interval > 0) {
356 /* The timer does not have to be accurate. */
357 set_timer_slack(&di->work.timer, poll_interval * HZ / 4);
358 schedule_delayed_work(&di->work, poll_interval * HZ);
359 }
360}
361
b996ad0e 362/*
bf7d4140 363 * Return the battery average current in µA
b996ad0e
RG		 364 * Note that current can be negative signed as well
365 * Or 0 if something fails.
366 */
297a533b
LPC		 367static int bq27x00_battery_current(struct bq27x00_device_info *di,
368 union power_supply_propval *val)
b996ad0e 369{
297a533b 370 int curr;
b68f6216 371 int flags;
b996ad0e 372
b68f6216 373 curr = bq27x00_read(di, BQ27x00_REG_AI, false);
c6cd4f26
PR		 374 if (curr < 0) {
375 dev_err(di->dev, "error reading current\n");
297a533b 376 return curr;
c6cd4f26 377 }
e20908d9
GI		 378
379 if (di->chip == BQ27500) {
380 /* bq27500 returns signed value */
297a533b 381 val->intval = (int)((s16)curr) * 1000;
e20908d9 382 } else {
b68f6216
PR		 383 flags = bq27x00_read(di, BQ27x00_REG_FLAGS, false);
384 if (flags & BQ27000_FLAG_CHGS) {
e20908d9 385 dev_dbg(di->dev, "negative current!\n");
afbc74fd 386 curr = -curr;
e20908d9 387 }
b996ad0e 388
297a533b 389 val->intval = curr * 3570 / BQ27000_RS;
b996ad0e
RG		 390 }
391
297a533b 392 return 0;
b996ad0e
RG		 393}
394
4e924a81 395static int bq27x00_battery_status(struct bq27x00_device_info *di,
297a533b 396 union power_supply_propval *val)
4e924a81 397{
4e924a81 398 int status;
4e924a81
GI		 399
400 if (di->chip == BQ27500) {
297a533b 401 if (di->cache.flags & BQ27500_FLAG_FC)
4e924a81 402 status = POWER_SUPPLY_STATUS_FULL;
b7aaacf5 403 else if (di->cache.flags & BQ27500_FLAG_DSC)
4e924a81 404 status = POWER_SUPPLY_STATUS_DISCHARGING;
270968c0 405 else
b7aaacf5 406 status = POWER_SUPPLY_STATUS_CHARGING;
4e924a81 407 } else {
c1b9ab67
LPC		 408 if (di->cache.flags & BQ27000_FLAG_FC)
409 status = POWER_SUPPLY_STATUS_FULL;
410 else if (di->cache.flags & BQ27000_FLAG_CHGS)
4e924a81 411 status = POWER_SUPPLY_STATUS_CHARGING;
c1b9ab67
LPC		 412 else if (power_supply_am_i_supplied(&di->bat))
413 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
4e924a81
GI		 414 else
415 status = POWER_SUPPLY_STATUS_DISCHARGING;
416 }
417
418 val->intval = status;
297a533b 419
4e924a81
GI		 420 return 0;
421}
422
d66bab3f
PR		 423static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
424 union power_supply_propval *val)
425{
426 int level;
427
428 if (di->chip == BQ27500) {
429 if (di->cache.flags & BQ27500_FLAG_FC)
430 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
431 else if (di->cache.flags & BQ27500_FLAG_SOC1)
432 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
433 else if (di->cache.flags & BQ27500_FLAG_SOCF)
434 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
435 else
436 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
437 } else {
438 if (di->cache.flags & BQ27000_FLAG_FC)
439 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
440 else if (di->cache.flags & BQ27000_FLAG_EDV1)
441 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
442 else if (di->cache.flags & BQ27000_FLAG_EDVF)
443 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
444 else
445 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
446 }
447
448 val->intval = level;
449
450 return 0;
451}
452
4e924a81 453/*
91fe4d50 454 * Return the battery Voltage in millivolts
297a533b 455 * Or < 0 if something fails.
4e924a81 456 */
297a533b
LPC		 457static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
458 union power_supply_propval *val)
4e924a81 459{
297a533b 460 int volt;
4e924a81 461
297a533b 462 volt = bq27x00_read(di, BQ27x00_REG_VOLT, false);
c6cd4f26
PR		 463 if (volt < 0) {
464 dev_err(di->dev, "error reading voltage\n");
297a533b 465 return volt;
c6cd4f26 466 }
4e924a81 467
297a533b
LPC		 468 val->intval = volt * 1000;
469
470 return 0;
471}
472
473static int bq27x00_simple_value(int value,
474 union power_supply_propval *val)
475{
476 if (value < 0)
477 return value;
478
479 val->intval = value;
4e924a81 480
4e924a81
GI		 481 return 0;
482}
483
b996ad0e
RG		 484#define to_bq27x00_device_info(x) container_of((x), \
485 struct bq27x00_device_info, bat);
486
487static int bq27x00_battery_get_property(struct power_supply *psy,
488 enum power_supply_property psp,
489 union power_supply_propval *val)
490{
4e924a81 491 int ret = 0;
b996ad0e 492 struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
3413b4ea 493
740b755a
LPC		 494 mutex_lock(&di->lock);
495 if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
496 cancel_delayed_work_sync(&di->work);
497 bq27x00_battery_poll(&di->work.work);
498 }
499 mutex_unlock(&di->lock);
297a533b
LPC		 500
501 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
3413b4ea 502 return -ENODEV;
b996ad0e
RG		 503
504 switch (psp) {
4e924a81
GI		 505 case POWER_SUPPLY_PROP_STATUS:
506 ret = bq27x00_battery_status(di, val);
507 break;
b996ad0e 508 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
297a533b 509 ret = bq27x00_battery_voltage(di, val);
3413b4ea 510 break;
b996ad0e 511 case POWER_SUPPLY_PROP_PRESENT:
297a533b 512 val->intval = di->cache.flags < 0 ? 0 : 1;
b996ad0e
RG		 513 break;
514 case POWER_SUPPLY_PROP_CURRENT_NOW:
297a533b 515 ret = bq27x00_battery_current(di, val);
b996ad0e
RG		 516 break;
517 case POWER_SUPPLY_PROP_CAPACITY:
297a533b 518 ret = bq27x00_simple_value(di->cache.capacity, val);
b996ad0e 519 break;
d66bab3f
PR		 520 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
521 ret = bq27x00_battery_capacity_level(di, val);
522 break;
b996ad0e 523 case POWER_SUPPLY_PROP_TEMP:
d149e98e 524 ret = bq27x00_simple_value(di->cache.temperature, val);
b996ad0e 525 break;
4e924a81 526 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
297a533b 527 ret = bq27x00_simple_value(di->cache.time_to_empty, val);
4e924a81
GI		 528 break;
529 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
297a533b 530 ret = bq27x00_simple_value(di->cache.time_to_empty_avg, val);
4e924a81
GI		 531 break;
532 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
297a533b 533 ret = bq27x00_simple_value(di->cache.time_to_full, val);
4e924a81 534 break;
5661f334
LPC		 535 case POWER_SUPPLY_PROP_TECHNOLOGY:
536 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
537 break;
631c17ee
PR		 538 case POWER_SUPPLY_PROP_CHARGE_NOW:
539 ret = bq27x00_simple_value(bq27x00_battery_read_nac(di), val);
540 break;
541 case POWER_SUPPLY_PROP_CHARGE_FULL:
542 ret = bq27x00_simple_value(di->cache.charge_full, val);
543 break;
544 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
545 ret = bq27x00_simple_value(di->charge_design_full, val);
546 break;
73c244a8
PR		 547 case POWER_SUPPLY_PROP_CYCLE_COUNT:
548 ret = bq27x00_simple_value(di->cache.cycle_count, val);
631c17ee
PR		 549 break;
550 case POWER_SUPPLY_PROP_ENERGY_NOW:
a8f6bd23 551 ret = bq27x00_simple_value(di->cache.energy, val);
631c17ee 552 break;
b996ad0e
RG		 553 default:
554 return -EINVAL;
555 }
556
4e924a81 557 return ret;
b996ad0e
RG		 558}
559
740b755a
LPC		 560static void bq27x00_external_power_changed(struct power_supply *psy)
561{
562 struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
563
564 cancel_delayed_work_sync(&di->work);
565 schedule_delayed_work(&di->work, 0);
566}
567
a40402ef 568static int bq27x00_powersupply_init(struct bq27x00_device_info *di)
b996ad0e 569{
a40402ef
LPC		 570 int ret;
571
b996ad0e
RG		 572 di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
573 di->bat.properties = bq27x00_battery_props;
574 di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
575 di->bat.get_property = bq27x00_battery_get_property;
740b755a
LPC		 576 di->bat.external_power_changed = bq27x00_external_power_changed;
577
578 INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll);
579 mutex_init(&di->lock);
a40402ef
LPC		 580
581 ret = power_supply_register(di->dev, &di->bat);
582 if (ret) {
583 dev_err(di->dev, "failed to register battery: %d\n", ret);
584 return ret;
585 }
586
587 dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION);
588
297a533b
LPC		 589 bq27x00_update(di);
590
a40402ef 591 return 0;
b996ad0e
RG		 592}
593
740b755a
LPC		 594static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
595{
8cfaaa81
PR		 596 /*
597 * power_supply_unregister call bq27x00_battery_get_property which
598 * call bq27x00_battery_poll.
599 * Make sure that bq27x00_battery_poll will not call
600 * schedule_delayed_work again after unregister (which cause OOPS).
601 */
602 poll_interval = 0;
603
740b755a
LPC		 604 cancel_delayed_work_sync(&di->work);
605
606 power_supply_unregister(&di->bat);
607
608 mutex_destroy(&di->lock);
609}
610
7fb7ba58
LPC		 611
612/* i2c specific code */
613#ifdef CONFIG_BATTERY_BQ27X00_I2C
614
615/* If the system has several batteries we need a different name for each
616 * of them...
b996ad0e 617 */
7fb7ba58
LPC		 618static DEFINE_IDR(battery_id);
619static DEFINE_MUTEX(battery_mutex);
b996ad0e 620
297a533b 621static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
b996ad0e 622{
a40402ef 623 struct i2c_client *client = to_i2c_client(di->dev);
9e912f45 624 struct i2c_msg msg[2];
b996ad0e 625 unsigned char data[2];
297a533b 626 int ret;
b996ad0e
RG		 627
628 if (!client->adapter)
629 return -ENODEV;
630
9e912f45
GI		 631 msg[0].addr = client->addr;
632 msg[0].flags = 0;
633 msg[0].buf = &reg;
634 msg[0].len = sizeof(reg);
635 msg[1].addr = client->addr;
636 msg[1].flags = I2C_M_RD;
637 msg[1].buf = data;
2ec523a8 638 if (single)
9e912f45 639 msg[1].len = 1;
2ec523a8 640 else
9e912f45 641 msg[1].len = 2;
2ec523a8 642
9e912f45 643 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
2ec523a8
LPC		 644 if (ret < 0)
645 return ret;
646
647 if (!single)
648 ret = get_unaligned_le16(data);
649 else
650 ret = data[0];
b996ad0e 651
297a533b 652 return ret;
b996ad0e
RG		 653}
654
e20908d9 655static int bq27x00_battery_probe(struct i2c_client *client,
b996ad0e
RG		 656 const struct i2c_device_id *id)
657{
658 char *name;
659 struct bq27x00_device_info *di;
b996ad0e
RG		 660 int num;
661 int retval = 0;
662
663 /* Get new ID for the new battery device */
664 retval = idr_pre_get(&battery_id, GFP_KERNEL);
665 if (retval == 0)
666 return -ENOMEM;
667 mutex_lock(&battery_mutex);
668 retval = idr_get_new(&battery_id, client, &num);
669 mutex_unlock(&battery_mutex);
670 if (retval < 0)
671 return retval;
672
e20908d9 673 name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num);
b996ad0e
RG		 674 if (!name) {
675 dev_err(&client->dev, "failed to allocate device name\n");
676 retval = -ENOMEM;
677 goto batt_failed_1;
678 }
679
680 di = kzalloc(sizeof(*di), GFP_KERNEL);
681 if (!di) {
682 dev_err(&client->dev, "failed to allocate device info data\n");
683 retval = -ENOMEM;
684 goto batt_failed_2;
685 }
a40402ef 686
b996ad0e 687 di->id = num;
a40402ef 688 di->dev = &client->dev;
e20908d9 689 di->chip = id->driver_data;
a40402ef
LPC		 690 di->bat.name = name;
691 di->bus.read = &bq27x00_read_i2c;
b996ad0e 692
a40402ef 693 if (bq27x00_powersupply_init(di))
b996ad0e 694 goto batt_failed_3;
b996ad0e
RG		 695
696 i2c_set_clientdata(client, di);
b996ad0e
RG		 697
698 return 0;
699
b996ad0e
RG		 700batt_failed_3:
701 kfree(di);
702batt_failed_2:
703 kfree(name);
704batt_failed_1:
705 mutex_lock(&battery_mutex);
706 idr_remove(&battery_id, num);
707 mutex_unlock(&battery_mutex);
708
709 return retval;
710}
711
e20908d9 712static int bq27x00_battery_remove(struct i2c_client *client)
b996ad0e
RG		 713{
714 struct bq27x00_device_info *di = i2c_get_clientdata(client);
715
740b755a 716 bq27x00_powersupply_unregister(di);
b996ad0e
RG		 717
718 kfree(di->bat.name);
719
720 mutex_lock(&battery_mutex);
721 idr_remove(&battery_id, di->id);
722 mutex_unlock(&battery_mutex);
723
724 kfree(di);
725
726 return 0;
727}
728
e20908d9
GI		 729static const struct i2c_device_id bq27x00_id[] = {
730 { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */
731 { "bq27500", BQ27500 },
b996ad0e
RG		 732 {},
733};
fd9b958c 734MODULE_DEVICE_TABLE(i2c, bq27x00_id);
b996ad0e 735
e20908d9 736static struct i2c_driver bq27x00_battery_driver = {
b996ad0e 737 .driver = {
e20908d9 738 .name = "bq27x00-battery",
b996ad0e 739 },
e20908d9
GI		 740 .probe = bq27x00_battery_probe,
741 .remove = bq27x00_battery_remove,
742 .id_table = bq27x00_id,
b996ad0e
RG		 743};
744
7fb7ba58
LPC		 745static inline int bq27x00_battery_i2c_init(void)
746{
747 int ret = i2c_add_driver(&bq27x00_battery_driver);
748 if (ret)
749 printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n");
750
751 return ret;
752}
753
754static inline void bq27x00_battery_i2c_exit(void)
755{
756 i2c_del_driver(&bq27x00_battery_driver);
757}
758
759#else
760
761static inline int bq27x00_battery_i2c_init(void) { return 0; }
762static inline void bq27x00_battery_i2c_exit(void) {};
763
764#endif
765
766/* platform specific code */
767#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
768
769static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
297a533b 770 bool single)
7fb7ba58
LPC		 771{
772 struct device *dev = di->dev;
773 struct bq27000_platform_data *pdata = dev->platform_data;
774 unsigned int timeout = 3;
775 int upper, lower;
776 int temp;
777
778 if (!single) {
779 /* Make sure the value has not changed in between reading the
780 * lower and the upper part */
781 upper = pdata->read(dev, reg + 1);
782 do {
783 temp = upper;
784 if (upper < 0)
785 return upper;
786
787 lower = pdata->read(dev, reg);
788 if (lower < 0)
789 return lower;
790
791 upper = pdata->read(dev, reg + 1);
792 } while (temp != upper && --timeout);
793
794 if (timeout == 0)
795 return -EIO;
796
297a533b 797 return (upper << 8) | lower;
7fb7ba58 798 }
297a533b
LPC		 799
800 return pdata->read(dev, reg);
7fb7ba58
LPC		 801}
802
803static int __devinit bq27000_battery_probe(struct platform_device *pdev)
804{
805 struct bq27x00_device_info *di;
806 struct bq27000_platform_data *pdata = pdev->dev.platform_data;
807 int ret;
808
809 if (!pdata) {
810 dev_err(&pdev->dev, "no platform_data supplied\n");
811 return -EINVAL;
812 }
813
814 if (!pdata->read) {
815 dev_err(&pdev->dev, "no hdq read callback supplied\n");
816 return -EINVAL;
817 }
818
819 di = kzalloc(sizeof(*di), GFP_KERNEL);
820 if (!di) {
821 dev_err(&pdev->dev, "failed to allocate device info data\n");
822 return -ENOMEM;
823 }
824
825 platform_set_drvdata(pdev, di);
826
827 di->dev = &pdev->dev;
828 di->chip = BQ27000;
829
830 di->bat.name = pdata->name ?: dev_name(&pdev->dev);
831 di->bus.read = &bq27000_read_platform;
832
833 ret = bq27x00_powersupply_init(di);
834 if (ret)
835 goto err_free;
836
837 return 0;
838
839err_free:
840 platform_set_drvdata(pdev, NULL);
841 kfree(di);
842
843 return ret;
844}
845
846static int __devexit bq27000_battery_remove(struct platform_device *pdev)
847{
848 struct bq27x00_device_info *di = platform_get_drvdata(pdev);
849
740b755a
LPC		 850 bq27x00_powersupply_unregister(di);
851
7fb7ba58
LPC		 852 platform_set_drvdata(pdev, NULL);
853 kfree(di);
854
855 return 0;
856}
857
858static struct platform_driver bq27000_battery_driver = {
859 .probe = bq27000_battery_probe,
860 .remove = __devexit_p(bq27000_battery_remove),
861 .driver = {
862 .name = "bq27000-battery",
863 .owner = THIS_MODULE,
864 },
865};
866
867static inline int bq27x00_battery_platform_init(void)
868{
869 int ret = platform_driver_register(&bq27000_battery_driver);
870 if (ret)
871 printk(KERN_ERR "Unable to register BQ27000 platform driver\n");
872
873 return ret;
874}
875
876static inline void bq27x00_battery_platform_exit(void)
877{
878 platform_driver_unregister(&bq27000_battery_driver);
879}
880
881#else
882
883static inline int bq27x00_battery_platform_init(void) { return 0; }
884static inline void bq27x00_battery_platform_exit(void) {};
885
886#endif
887
888/*
889 * Module stuff
890 */
891
b996ad0e
RG		 892static int __init bq27x00_battery_init(void)
893{
894 int ret;
895
7fb7ba58
LPC		 896 ret = bq27x00_battery_i2c_init();
897 if (ret)
898 return ret;
899
900 ret = bq27x00_battery_platform_init();
b996ad0e 901 if (ret)
7fb7ba58 902 bq27x00_battery_i2c_exit();
b996ad0e
RG		 903
904 return ret;
905}
906module_init(bq27x00_battery_init);
907
908static void __exit bq27x00_battery_exit(void)
909{
7fb7ba58
LPC		 910 bq27x00_battery_platform_exit();
911 bq27x00_battery_i2c_exit();
b996ad0e
RG		 912}
913module_exit(bq27x00_battery_exit);
914
915MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
916MODULE_DESCRIPTION("BQ27x00 battery monitor driver");
917MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.636074 seconds and 5 git commands to generate.