aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/leds/led-triggers.c20
-rw-r--r--drivers/power/Kconfig14
-rw-r--r--drivers/power/bq20z75.c310
-rw-r--r--drivers/power/bq27x00_battery.c725
-rw-r--r--drivers/power/ds2782_battery.c1
-rw-r--r--drivers/power/power_supply_core.c4
-rw-r--r--drivers/power/power_supply_leds.c19
-rw-r--r--drivers/power/power_supply_sysfs.c2
-rw-r--r--drivers/power/s3c_adc_battery.c4
-rw-r--r--drivers/power/twl4030_charger.c25
-rw-r--r--drivers/power/z2_battery.c3
-rw-r--r--include/linux/leds.h3
-rw-r--r--include/linux/power/bq20z75.h39
-rw-r--r--include/linux/power/bq27x00_battery.h19
-rw-r--r--include/linux/power_supply.h47
15 files changed, 1009 insertions, 226 deletions
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index c41eb6180c9c..4bebae733349 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -231,6 +231,26 @@ void led_trigger_event(struct led_trigger *trigger,
231} 231}
232EXPORT_SYMBOL_GPL(led_trigger_event); 232EXPORT_SYMBOL_GPL(led_trigger_event);
233 233
234void led_trigger_blink(struct led_trigger *trigger,
235 unsigned long *delay_on,
236 unsigned long *delay_off)
237{
238 struct list_head *entry;
239
240 if (!trigger)
241 return;
242
243 read_lock(&trigger->leddev_list_lock);
244 list_for_each(entry, &trigger->led_cdevs) {
245 struct led_classdev *led_cdev;
246
247 led_cdev = list_entry(entry, struct led_classdev, trig_list);
248 led_blink_set(led_cdev, delay_on, delay_off);
249 }
250 read_unlock(&trigger->leddev_list_lock);
251}
252EXPORT_SYMBOL_GPL(led_trigger_blink);
253
234void led_trigger_register_simple(const char *name, struct led_trigger **tp) 254void led_trigger_register_simple(const char *name, struct led_trigger **tp)
235{ 255{
236 struct led_trigger *trigger; 256 struct led_trigger *trigger;
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 61bf5d724139..52a462fc6b84 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -117,10 +117,24 @@ config BATTERY_BQ20Z75
117 117
118config BATTERY_BQ27x00 118config BATTERY_BQ27x00
119 tristate "BQ27x00 battery driver" 119 tristate "BQ27x00 battery driver"
120 help
121 Say Y here to enable support for batteries with BQ27x00 (I2C/HDQ) chips.
122
123config BATTERY_BQ27X00_I2C
124 bool "BQ27200/BQ27500 support"
125 depends on BATTERY_BQ27x00
120 depends on I2C 126 depends on I2C
127 default y
121 help 128 help
122 Say Y here to enable support for batteries with BQ27x00 (I2C) chips. 129 Say Y here to enable support for batteries with BQ27x00 (I2C) chips.
123 130
131config BATTERY_BQ27X00_PLATFORM
132 bool "BQ27000 support"
133 depends on BATTERY_BQ27x00
134 default y
135 help
136 Say Y here to enable support for batteries with BQ27000 (HDQ) chips.
137
124config BATTERY_DA9030 138config BATTERY_DA9030
125 tristate "DA9030 battery driver" 139 tristate "DA9030 battery driver"
126 depends on PMIC_DA903X 140 depends on PMIC_DA903X
diff --git a/drivers/power/bq20z75.c b/drivers/power/bq20z75.c
index 492da27e1a47..506585e31a5b 100644
--- a/drivers/power/bq20z75.c
+++ b/drivers/power/bq20z75.c
@@ -25,6 +25,10 @@
25#include <linux/power_supply.h> 25#include <linux/power_supply.h>
26#include <linux/i2c.h> 26#include <linux/i2c.h>
27#include <linux/slab.h> 27#include <linux/slab.h>
28#include <linux/interrupt.h>
29#include <linux/gpio.h>
30
31#include <linux/power/bq20z75.h>
28 32
29enum { 33enum {
30 REG_MANUFACTURER_DATA, 34 REG_MANUFACTURER_DATA,
@@ -38,11 +42,22 @@ enum {
38 REG_CYCLE_COUNT, 42 REG_CYCLE_COUNT,
39 REG_SERIAL_NUMBER, 43 REG_SERIAL_NUMBER,
40 REG_REMAINING_CAPACITY, 44 REG_REMAINING_CAPACITY,
45 REG_REMAINING_CAPACITY_CHARGE,
41 REG_FULL_CHARGE_CAPACITY, 46 REG_FULL_CHARGE_CAPACITY,
47 REG_FULL_CHARGE_CAPACITY_CHARGE,
42 REG_DESIGN_CAPACITY, 48 REG_DESIGN_CAPACITY,
49 REG_DESIGN_CAPACITY_CHARGE,
43 REG_DESIGN_VOLTAGE, 50 REG_DESIGN_VOLTAGE,
44}; 51};
45 52
53/* Battery Mode defines */
54#define BATTERY_MODE_OFFSET 0x03
55#define BATTERY_MODE_MASK 0x8000
56enum bq20z75_battery_mode {
57 BATTERY_MODE_AMPS,
58 BATTERY_MODE_WATTS
59};
60
46/* manufacturer access defines */ 61/* manufacturer access defines */
47#define MANUFACTURER_ACCESS_STATUS 0x0006 62#define MANUFACTURER_ACCESS_STATUS 0x0006
48#define MANUFACTURER_ACCESS_SLEEP 0x0011 63#define MANUFACTURER_ACCESS_SLEEP 0x0011
@@ -78,8 +93,12 @@ static const struct bq20z75_device_data {
78 BQ20Z75_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100), 93 BQ20Z75_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100),
79 [REG_REMAINING_CAPACITY] = 94 [REG_REMAINING_CAPACITY] =
80 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535), 95 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
96 [REG_REMAINING_CAPACITY_CHARGE] =
97 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
81 [REG_FULL_CHARGE_CAPACITY] = 98 [REG_FULL_CHARGE_CAPACITY] =
82 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535), 99 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
100 [REG_FULL_CHARGE_CAPACITY_CHARGE] =
101 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
83 [REG_TIME_TO_EMPTY] = 102 [REG_TIME_TO_EMPTY] =
84 BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 103 BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0,
85 65535), 104 65535),
@@ -93,6 +112,9 @@ static const struct bq20z75_device_data {
93 [REG_DESIGN_CAPACITY] = 112 [REG_DESIGN_CAPACITY] =
94 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 113 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0,
95 65535), 114 65535),
115 [REG_DESIGN_CAPACITY_CHARGE] =
116 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0,
117 65535),
96 [REG_DESIGN_VOLTAGE] = 118 [REG_DESIGN_VOLTAGE] =
97 BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 119 BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0,
98 65535), 120 65535),
@@ -117,39 +139,72 @@ static enum power_supply_property bq20z75_properties[] = {
117 POWER_SUPPLY_PROP_ENERGY_NOW, 139 POWER_SUPPLY_PROP_ENERGY_NOW,
118 POWER_SUPPLY_PROP_ENERGY_FULL, 140 POWER_SUPPLY_PROP_ENERGY_FULL,
119 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 141 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
142 POWER_SUPPLY_PROP_CHARGE_NOW,
143 POWER_SUPPLY_PROP_CHARGE_FULL,
144 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
120}; 145};
121 146
122struct bq20z75_info { 147struct bq20z75_info {
123 struct i2c_client *client; 148 struct i2c_client *client;
124 struct power_supply power_supply; 149 struct power_supply power_supply;
150 struct bq20z75_platform_data *pdata;
151 bool is_present;
152 bool gpio_detect;
153 bool enable_detection;
154 int irq;
125}; 155};
126 156
127static int bq20z75_read_word_data(struct i2c_client *client, u8 address) 157static int bq20z75_read_word_data(struct i2c_client *client, u8 address)
128{ 158{
129 s32 ret; 159 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
160 s32 ret = 0;
161 int retries = 1;
162
163 if (bq20z75_device->pdata)
164 retries = max(bq20z75_device->pdata->i2c_retry_count + 1, 1);
165
166 while (retries > 0) {
167 ret = i2c_smbus_read_word_data(client, address);
168 if (ret >= 0)
169 break;
170 retries--;
171 }
130 172
131 ret = i2c_smbus_read_word_data(client, address);
132 if (ret < 0) { 173 if (ret < 0) {
133 dev_err(&client->dev, 174 dev_dbg(&client->dev,
134 "%s: i2c read at address 0x%x failed\n", 175 "%s: i2c read at address 0x%x failed\n",
135 __func__, address); 176 __func__, address);
136 return ret; 177 return ret;
137 } 178 }
179
138 return le16_to_cpu(ret); 180 return le16_to_cpu(ret);
139} 181}
140 182
141static int bq20z75_write_word_data(struct i2c_client *client, u8 address, 183static int bq20z75_write_word_data(struct i2c_client *client, u8 address,
142 u16 value) 184 u16 value)
143{ 185{
144 s32 ret; 186 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
187 s32 ret = 0;
188 int retries = 1;
189
190 if (bq20z75_device->pdata)
191 retries = max(bq20z75_device->pdata->i2c_retry_count + 1, 1);
192
193 while (retries > 0) {
194 ret = i2c_smbus_write_word_data(client, address,
195 le16_to_cpu(value));
196 if (ret >= 0)
197 break;
198 retries--;
199 }
145 200
146 ret = i2c_smbus_write_word_data(client, address, le16_to_cpu(value));
147 if (ret < 0) { 201 if (ret < 0) {
148 dev_err(&client->dev, 202 dev_dbg(&client->dev,
149 "%s: i2c write to address 0x%x failed\n", 203 "%s: i2c write to address 0x%x failed\n",
150 __func__, address); 204 __func__, address);
151 return ret; 205 return ret;
152 } 206 }
207
153 return 0; 208 return 0;
154} 209}
155 210
@@ -158,6 +213,19 @@ static int bq20z75_get_battery_presence_and_health(
158 union power_supply_propval *val) 213 union power_supply_propval *val)
159{ 214{
160 s32 ret; 215 s32 ret;
216 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
217
218 if (psp == POWER_SUPPLY_PROP_PRESENT &&
219 bq20z75_device->gpio_detect) {
220 ret = gpio_get_value(
221 bq20z75_device->pdata->battery_detect);
222 if (ret == bq20z75_device->pdata->battery_detect_present)
223 val->intval = 1;
224 else
225 val->intval = 0;
226 bq20z75_device->is_present = val->intval;
227 return ret;
228 }
161 229
162 /* Write to ManufacturerAccess with 230 /* Write to ManufacturerAccess with
163 * ManufacturerAccess command and then 231 * ManufacturerAccess command and then
@@ -165,9 +233,11 @@ static int bq20z75_get_battery_presence_and_health(
165 ret = bq20z75_write_word_data(client, 233 ret = bq20z75_write_word_data(client,
166 bq20z75_data[REG_MANUFACTURER_DATA].addr, 234 bq20z75_data[REG_MANUFACTURER_DATA].addr,
167 MANUFACTURER_ACCESS_STATUS); 235 MANUFACTURER_ACCESS_STATUS);
168 if (ret < 0) 236 if (ret < 0) {
237 if (psp == POWER_SUPPLY_PROP_PRESENT)
238 val->intval = 0; /* battery removed */
169 return ret; 239 return ret;
170 240 }
171 241
172 ret = bq20z75_read_word_data(client, 242 ret = bq20z75_read_word_data(client,
173 bq20z75_data[REG_MANUFACTURER_DATA].addr); 243 bq20z75_data[REG_MANUFACTURER_DATA].addr);
@@ -248,30 +318,39 @@ static void bq20z75_unit_adjustment(struct i2c_client *client,
248{ 318{
249#define BASE_UNIT_CONVERSION 1000 319#define BASE_UNIT_CONVERSION 1000
250#define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION) 320#define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION)
251#define TIME_UNIT_CONVERSION 600 321#define TIME_UNIT_CONVERSION 60
252#define TEMP_KELVIN_TO_CELCIUS 2731 322#define TEMP_KELVIN_TO_CELSIUS 2731
253 switch (psp) { 323 switch (psp) {
254 case POWER_SUPPLY_PROP_ENERGY_NOW: 324 case POWER_SUPPLY_PROP_ENERGY_NOW:
255 case POWER_SUPPLY_PROP_ENERGY_FULL: 325 case POWER_SUPPLY_PROP_ENERGY_FULL:
256 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 326 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
327 /* bq20z75 provides energy in units of 10mWh.
328 * Convert to µWh
329 */
257 val->intval *= BATTERY_MODE_CAP_MULT_WATT; 330 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
258 break; 331 break;
259 332
260 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 333 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
261 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 334 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
262 case POWER_SUPPLY_PROP_CURRENT_NOW: 335 case POWER_SUPPLY_PROP_CURRENT_NOW:
336 case POWER_SUPPLY_PROP_CHARGE_NOW:
337 case POWER_SUPPLY_PROP_CHARGE_FULL:
338 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
263 val->intval *= BASE_UNIT_CONVERSION; 339 val->intval *= BASE_UNIT_CONVERSION;
264 break; 340 break;
265 341
266 case POWER_SUPPLY_PROP_TEMP: 342 case POWER_SUPPLY_PROP_TEMP:
267 /* bq20z75 provides battery tempreture in 0.1°K 343 /* bq20z75 provides battery temperature in 0.1K
268 * so convert it to 0.1°C */ 344 * so convert it to 0.1°C
269 val->intval -= TEMP_KELVIN_TO_CELCIUS; 345 */
270 val->intval *= 10; 346 val->intval -= TEMP_KELVIN_TO_CELSIUS;
271 break; 347 break;
272 348
273 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 349 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
274 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 350 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
351 /* bq20z75 provides time to empty and time to full in minutes.
352 * Convert to seconds
353 */
275 val->intval *= TIME_UNIT_CONVERSION; 354 val->intval *= TIME_UNIT_CONVERSION;
276 break; 355 break;
277 356
@@ -281,11 +360,44 @@ static void bq20z75_unit_adjustment(struct i2c_client *client,
281 } 360 }
282} 361}
283 362
363static enum bq20z75_battery_mode
364bq20z75_set_battery_mode(struct i2c_client *client,
365 enum bq20z75_battery_mode mode)
366{
367 int ret, original_val;
368
369 original_val = bq20z75_read_word_data(client, BATTERY_MODE_OFFSET);
370 if (original_val < 0)
371 return original_val;
372
373 if ((original_val & BATTERY_MODE_MASK) == mode)
374 return mode;
375
376 if (mode == BATTERY_MODE_AMPS)
377 ret = original_val & ~BATTERY_MODE_MASK;
378 else
379 ret = original_val | BATTERY_MODE_MASK;
380
381 ret = bq20z75_write_word_data(client, BATTERY_MODE_OFFSET, ret);
382 if (ret < 0)
383 return ret;
384
385 return original_val & BATTERY_MODE_MASK;
386}
387
284static int bq20z75_get_battery_capacity(struct i2c_client *client, 388static int bq20z75_get_battery_capacity(struct i2c_client *client,
285 int reg_offset, enum power_supply_property psp, 389 int reg_offset, enum power_supply_property psp,
286 union power_supply_propval *val) 390 union power_supply_propval *val)
287{ 391{
288 s32 ret; 392 s32 ret;
393 enum bq20z75_battery_mode mode = BATTERY_MODE_WATTS;
394
395 if (power_supply_is_amp_property(psp))
396 mode = BATTERY_MODE_AMPS;
397
398 mode = bq20z75_set_battery_mode(client, mode);
399 if (mode < 0)
400 return mode;
289 401
290 ret = bq20z75_read_word_data(client, bq20z75_data[reg_offset].addr); 402 ret = bq20z75_read_word_data(client, bq20z75_data[reg_offset].addr);
291 if (ret < 0) 403 if (ret < 0)
@@ -298,6 +410,10 @@ static int bq20z75_get_battery_capacity(struct i2c_client *client,
298 } else 410 } else
299 val->intval = ret; 411 val->intval = ret;
300 412
413 ret = bq20z75_set_battery_mode(client, mode);
414 if (ret < 0)
415 return ret;
416
301 return 0; 417 return 0;
302} 418}
303 419
@@ -318,12 +434,25 @@ static int bq20z75_get_battery_serial_number(struct i2c_client *client,
318 return 0; 434 return 0;
319} 435}
320 436
437static int bq20z75_get_property_index(struct i2c_client *client,
438 enum power_supply_property psp)
439{
440 int count;
441 for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++)
442 if (psp == bq20z75_data[count].psp)
443 return count;
444
445 dev_warn(&client->dev,
446 "%s: Invalid Property - %d\n", __func__, psp);
447
448 return -EINVAL;
449}
450
321static int bq20z75_get_property(struct power_supply *psy, 451static int bq20z75_get_property(struct power_supply *psy,
322 enum power_supply_property psp, 452 enum power_supply_property psp,
323 union power_supply_propval *val) 453 union power_supply_propval *val)
324{ 454{
325 int count; 455 int ret = 0;
326 int ret;
327 struct bq20z75_info *bq20z75_device = container_of(psy, 456 struct bq20z75_info *bq20z75_device = container_of(psy,
328 struct bq20z75_info, power_supply); 457 struct bq20z75_info, power_supply);
329 struct i2c_client *client = bq20z75_device->client; 458 struct i2c_client *client = bq20z75_device->client;
@@ -332,8 +461,8 @@ static int bq20z75_get_property(struct power_supply *psy,
332 case POWER_SUPPLY_PROP_PRESENT: 461 case POWER_SUPPLY_PROP_PRESENT:
333 case POWER_SUPPLY_PROP_HEALTH: 462 case POWER_SUPPLY_PROP_HEALTH:
334 ret = bq20z75_get_battery_presence_and_health(client, psp, val); 463 ret = bq20z75_get_battery_presence_and_health(client, psp, val);
335 if (ret) 464 if (psp == POWER_SUPPLY_PROP_PRESENT)
336 return ret; 465 return 0;
337 break; 466 break;
338 467
339 case POWER_SUPPLY_PROP_TECHNOLOGY: 468 case POWER_SUPPLY_PROP_TECHNOLOGY:
@@ -343,22 +472,19 @@ static int bq20z75_get_property(struct power_supply *psy,
343 case POWER_SUPPLY_PROP_ENERGY_NOW: 472 case POWER_SUPPLY_PROP_ENERGY_NOW:
344 case POWER_SUPPLY_PROP_ENERGY_FULL: 473 case POWER_SUPPLY_PROP_ENERGY_FULL:
345 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 474 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
475 case POWER_SUPPLY_PROP_CHARGE_NOW:
476 case POWER_SUPPLY_PROP_CHARGE_FULL:
477 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
346 case POWER_SUPPLY_PROP_CAPACITY: 478 case POWER_SUPPLY_PROP_CAPACITY:
347 for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++) { 479 ret = bq20z75_get_property_index(client, psp);
348 if (psp == bq20z75_data[count].psp) 480 if (ret < 0)
349 break; 481 break;
350 }
351
352 ret = bq20z75_get_battery_capacity(client, count, psp, val);
353 if (ret)
354 return ret;
355 482
483 ret = bq20z75_get_battery_capacity(client, ret, psp, val);
356 break; 484 break;
357 485
358 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 486 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
359 ret = bq20z75_get_battery_serial_number(client, val); 487 ret = bq20z75_get_battery_serial_number(client, val);
360 if (ret)
361 return ret;
362 break; 488 break;
363 489
364 case POWER_SUPPLY_PROP_STATUS: 490 case POWER_SUPPLY_PROP_STATUS:
@@ -369,15 +495,11 @@ static int bq20z75_get_property(struct power_supply *psy,
369 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 495 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
370 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 496 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
371 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 497 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
372 for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++) { 498 ret = bq20z75_get_property_index(client, psp);
373 if (psp == bq20z75_data[count].psp) 499 if (ret < 0)
374 break; 500 break;
375 }
376
377 ret = bq20z75_get_battery_property(client, count, psp, val);
378 if (ret)
379 return ret;
380 501
502 ret = bq20z75_get_battery_property(client, ret, psp, val);
381 break; 503 break;
382 504
383 default: 505 default:
@@ -386,26 +508,58 @@ static int bq20z75_get_property(struct power_supply *psy,
386 return -EINVAL; 508 return -EINVAL;
387 } 509 }
388 510
389 /* Convert units to match requirements for power supply class */ 511 if (!bq20z75_device->enable_detection)
390 bq20z75_unit_adjustment(client, psp, val); 512 goto done;
513
514 if (!bq20z75_device->gpio_detect &&
515 bq20z75_device->is_present != (ret >= 0)) {
516 bq20z75_device->is_present = (ret >= 0);
517 power_supply_changed(&bq20z75_device->power_supply);
518 }
519
520done:
521 if (!ret) {
522 /* Convert units to match requirements for power supply class */
523 bq20z75_unit_adjustment(client, psp, val);
524 }
391 525
392 dev_dbg(&client->dev, 526 dev_dbg(&client->dev,
393 "%s: property = %d, value = %d\n", __func__, psp, val->intval); 527 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
528
529 if (ret && bq20z75_device->is_present)
530 return ret;
531
532 /* battery not present, so return NODATA for properties */
533 if (ret)
534 return -ENODATA;
394 535
395 return 0; 536 return 0;
396} 537}
397 538
398static int bq20z75_probe(struct i2c_client *client, 539static irqreturn_t bq20z75_irq(int irq, void *devid)
540{
541 struct power_supply *battery = devid;
542
543 power_supply_changed(battery);
544
545 return IRQ_HANDLED;
546}
547
548static int __devinit bq20z75_probe(struct i2c_client *client,
399 const struct i2c_device_id *id) 549 const struct i2c_device_id *id)
400{ 550{
401 struct bq20z75_info *bq20z75_device; 551 struct bq20z75_info *bq20z75_device;
552 struct bq20z75_platform_data *pdata = client->dev.platform_data;
402 int rc; 553 int rc;
554 int irq;
403 555
404 bq20z75_device = kzalloc(sizeof(struct bq20z75_info), GFP_KERNEL); 556 bq20z75_device = kzalloc(sizeof(struct bq20z75_info), GFP_KERNEL);
405 if (!bq20z75_device) 557 if (!bq20z75_device)
406 return -ENOMEM; 558 return -ENOMEM;
407 559
408 bq20z75_device->client = client; 560 bq20z75_device->client = client;
561 bq20z75_device->enable_detection = false;
562 bq20z75_device->gpio_detect = false;
409 bq20z75_device->power_supply.name = "battery"; 563 bq20z75_device->power_supply.name = "battery";
410 bq20z75_device->power_supply.type = POWER_SUPPLY_TYPE_BATTERY; 564 bq20z75_device->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;
411 bq20z75_device->power_supply.properties = bq20z75_properties; 565 bq20z75_device->power_supply.properties = bq20z75_properties;
@@ -413,26 +567,86 @@ static int bq20z75_probe(struct i2c_client *client,
413 ARRAY_SIZE(bq20z75_properties); 567 ARRAY_SIZE(bq20z75_properties);
414 bq20z75_device->power_supply.get_property = bq20z75_get_property; 568 bq20z75_device->power_supply.get_property = bq20z75_get_property;
415 569
570 if (pdata) {
571 bq20z75_device->gpio_detect =
572 gpio_is_valid(pdata->battery_detect);
573 bq20z75_device->pdata = pdata;
574 }
575
416 i2c_set_clientdata(client, bq20z75_device); 576 i2c_set_clientdata(client, bq20z75_device);
417 577
578 if (!bq20z75_device->gpio_detect)
579 goto skip_gpio;
580
581 rc = gpio_request(pdata->battery_detect, dev_name(&client->dev));
582 if (rc) {
583 dev_warn(&client->dev, "Failed to request gpio: %d\n", rc);
584 bq20z75_device->gpio_detect = false;
585 goto skip_gpio;
586 }
587
588 rc = gpio_direction_input(pdata->battery_detect);
589 if (rc) {
590 dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc);
591 gpio_free(pdata->battery_detect);
592 bq20z75_device->gpio_detect = false;
593 goto skip_gpio;
594 }
595
596 irq = gpio_to_irq(pdata->battery_detect);
597 if (irq <= 0) {
598 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
599 gpio_free(pdata->battery_detect);
600 bq20z75_device->gpio_detect = false;
601 goto skip_gpio;
602 }
603
604 rc = request_irq(irq, bq20z75_irq,
605 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
606 dev_name(&client->dev), &bq20z75_device->power_supply);
607 if (rc) {
608 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
609 gpio_free(pdata->battery_detect);
610 bq20z75_device->gpio_detect = false;
611 goto skip_gpio;
612 }
613
614 bq20z75_device->irq = irq;
615
616skip_gpio:
617
418 rc = power_supply_register(&client->dev, &bq20z75_device->power_supply); 618 rc = power_supply_register(&client->dev, &bq20z75_device->power_supply);
419 if (rc) { 619 if (rc) {
420 dev_err(&client->dev, 620 dev_err(&client->dev,
421 "%s: Failed to register power supply\n", __func__); 621 "%s: Failed to register power supply\n", __func__);
422 kfree(bq20z75_device); 622 goto exit_psupply;
423 return rc;
424 } 623 }
425 624
426 dev_info(&client->dev, 625 dev_info(&client->dev,
427 "%s: battery gas gauge device registered\n", client->name); 626 "%s: battery gas gauge device registered\n", client->name);
428 627
429 return 0; 628 return 0;
629
630exit_psupply:
631 if (bq20z75_device->irq)
632 free_irq(bq20z75_device->irq, &bq20z75_device->power_supply);
633 if (bq20z75_device->gpio_detect)
634 gpio_free(pdata->battery_detect);
635
636 kfree(bq20z75_device);
637
638 return rc;
430} 639}
431 640
432static int bq20z75_remove(struct i2c_client *client) 641static int __devexit bq20z75_remove(struct i2c_client *client)
433{ 642{
434 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client); 643 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
435 644
645 if (bq20z75_device->irq)
646 free_irq(bq20z75_device->irq, &bq20z75_device->power_supply);
647 if (bq20z75_device->gpio_detect)
648 gpio_free(bq20z75_device->pdata->battery_detect);
649
436 power_supply_unregister(&bq20z75_device->power_supply); 650 power_supply_unregister(&bq20z75_device->power_supply);
437 kfree(bq20z75_device); 651 kfree(bq20z75_device);
438 bq20z75_device = NULL; 652 bq20z75_device = NULL;
@@ -444,13 +658,14 @@ static int bq20z75_remove(struct i2c_client *client)
444static int bq20z75_suspend(struct i2c_client *client, 658static int bq20z75_suspend(struct i2c_client *client,
445 pm_message_t state) 659 pm_message_t state)
446{ 660{
661 struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
447 s32 ret; 662 s32 ret;
448 663
449 /* write to manufacturer access with sleep command */ 664 /* write to manufacturer access with sleep command */
450 ret = bq20z75_write_word_data(client, 665 ret = bq20z75_write_word_data(client,
451 bq20z75_data[REG_MANUFACTURER_DATA].addr, 666 bq20z75_data[REG_MANUFACTURER_DATA].addr,
452 MANUFACTURER_ACCESS_SLEEP); 667 MANUFACTURER_ACCESS_SLEEP);
453 if (ret < 0) 668 if (bq20z75_device->is_present && ret < 0)
454 return ret; 669 return ret;
455 670
456 return 0; 671 return 0;
@@ -465,10 +680,11 @@ static const struct i2c_device_id bq20z75_id[] = {
465 { "bq20z75", 0 }, 680 { "bq20z75", 0 },
466 {} 681 {}
467}; 682};
683MODULE_DEVICE_TABLE(i2c, bq20z75_id);
468 684
469static struct i2c_driver bq20z75_battery_driver = { 685static struct i2c_driver bq20z75_battery_driver = {
470 .probe = bq20z75_probe, 686 .probe = bq20z75_probe,
471 .remove = bq20z75_remove, 687 .remove = __devexit_p(bq20z75_remove),
472 .suspend = bq20z75_suspend, 688 .suspend = bq20z75_suspend,
473 .resume = bq20z75_resume, 689 .resume = bq20z75_resume,
474 .id_table = bq20z75_id, 690 .id_table = bq20z75_id,
diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index eff0273d4030..59e68dbd028b 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -3,6 +3,7 @@
3 * 3 *
4 * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it> 4 * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it> 5 * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
6 * Copyright (C) 2010-2011 Lars-Peter Clausen <lars@metafoo.de>
6 * 7 *
7 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc. 8 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
8 * 9 *
@@ -15,6 +16,13 @@
15 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 16 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16 * 17 *
17 */ 18 */
19
20/*
21 * Datasheets:
22 * http://focus.ti.com/docs/prod/folders/print/bq27000.html
23 * http://focus.ti.com/docs/prod/folders/print/bq27500.html
24 */
25
18#include <linux/module.h> 26#include <linux/module.h>
19#include <linux/param.h> 27#include <linux/param.h>
20#include <linux/jiffies.h> 28#include <linux/jiffies.h>
@@ -27,7 +35,9 @@
27#include <linux/slab.h> 35#include <linux/slab.h>
28#include <asm/unaligned.h> 36#include <asm/unaligned.h>
29 37
30#define DRIVER_VERSION "1.1.0" 38#include <linux/power/bq27x00_battery.h>
39
40#define DRIVER_VERSION "1.2.0"
31 41
32#define BQ27x00_REG_TEMP 0x06 42#define BQ27x00_REG_TEMP 0x06
33#define BQ27x00_REG_VOLT 0x08 43#define BQ27x00_REG_VOLT 0x08
@@ -36,36 +46,59 @@
36#define BQ27x00_REG_TTE 0x16 46#define BQ27x00_REG_TTE 0x16
37#define BQ27x00_REG_TTF 0x18 47#define BQ27x00_REG_TTF 0x18
38#define BQ27x00_REG_TTECP 0x26 48#define BQ27x00_REG_TTECP 0x26
49#define BQ27x00_REG_NAC 0x0C /* Nominal available capaciy */
50#define BQ27x00_REG_LMD 0x12 /* Last measured discharge */
51#define BQ27x00_REG_CYCT 0x2A /* Cycle count total */
52#define BQ27x00_REG_AE 0x22 /* Available enery */
39 53
40#define BQ27000_REG_RSOC 0x0B /* Relative State-of-Charge */ 54#define BQ27000_REG_RSOC 0x0B /* Relative State-of-Charge */
55#define BQ27000_REG_ILMD 0x76 /* Initial last measured discharge */
41#define BQ27000_FLAG_CHGS BIT(7) 56#define BQ27000_FLAG_CHGS BIT(7)
57#define BQ27000_FLAG_FC BIT(5)
42 58
43#define BQ27500_REG_SOC 0x2c 59#define BQ27500_REG_SOC 0x2C
60#define BQ27500_REG_DCAP 0x3C /* Design capacity */
44#define BQ27500_FLAG_DSC BIT(0) 61#define BQ27500_FLAG_DSC BIT(0)
45#define BQ27500_FLAG_FC BIT(9) 62#define BQ27500_FLAG_FC BIT(9)
46 63
47/* If the system has several batteries we need a different name for each 64#define BQ27000_RS 20 /* Resistor sense */
48 * of them...
49 */
50static DEFINE_IDR(battery_id);
51static DEFINE_MUTEX(battery_mutex);
52 65
53struct bq27x00_device_info; 66struct bq27x00_device_info;
54struct bq27x00_access_methods { 67struct bq27x00_access_methods {
55 int (*read)(u8 reg, int *rt_value, int b_single, 68 int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);
56 struct bq27x00_device_info *di);
57}; 69};
58 70
59enum bq27x00_chip { BQ27000, BQ27500 }; 71enum bq27x00_chip { BQ27000, BQ27500 };
60 72
73struct bq27x00_reg_cache {
74 int temperature;
75 int time_to_empty;
76 int time_to_empty_avg;
77 int time_to_full;
78 int charge_full;
79 int charge_counter;
80 int capacity;
81 int flags;
82
83 int current_now;
84};
85
61struct bq27x00_device_info { 86struct bq27x00_device_info {
62 struct device *dev; 87 struct device *dev;
63 int id; 88 int id;
64 struct bq27x00_access_methods *bus;
65 struct power_supply bat;
66 enum bq27x00_chip chip; 89 enum bq27x00_chip chip;
67 90
68 struct i2c_client *client; 91 struct bq27x00_reg_cache cache;
92 int charge_design_full;
93
94 unsigned long last_update;
95 struct delayed_work work;
96
97 struct power_supply bat;
98
99 struct bq27x00_access_methods bus;
100
101 struct mutex lock;
69}; 102};
70 103
71static enum power_supply_property bq27x00_battery_props[] = { 104static enum power_supply_property bq27x00_battery_props[] = {
@@ -78,164 +111,328 @@ static enum power_supply_property bq27x00_battery_props[] = {
78 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 111 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
79 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 112 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
80 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 113 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
114 POWER_SUPPLY_PROP_TECHNOLOGY,
115 POWER_SUPPLY_PROP_CHARGE_FULL,
116 POWER_SUPPLY_PROP_CHARGE_NOW,
117 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
118 POWER_SUPPLY_PROP_CHARGE_COUNTER,
119 POWER_SUPPLY_PROP_ENERGY_NOW,
81}; 120};
82 121
122static unsigned int poll_interval = 360;
123module_param(poll_interval, uint, 0644);
124MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
125 "0 disables polling");
126
83/* 127/*
84 * Common code for BQ27x00 devices 128 * Common code for BQ27x00 devices
85 */ 129 */
86 130
87static int bq27x00_read(u8 reg, int *rt_value, int b_single, 131static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
88 struct bq27x00_device_info *di) 132 bool single)
89{ 133{
90 return di->bus->read(reg, rt_value, b_single, di); 134 return di->bus.read(di, reg, single);
91} 135}
92 136
93/* 137/*
94 * Return the battery temperature in tenths of degree Celsius 138 * Return the battery Relative State-of-Charge
95 * Or < 0 if something fails. 139 * Or < 0 if something fails.
96 */ 140 */
97static int bq27x00_battery_temperature(struct bq27x00_device_info *di) 141static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
98{ 142{
99 int ret; 143 int rsoc;
100 int temp = 0;
101 144
102 ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di); 145 if (di->chip == BQ27500)
103 if (ret) { 146 rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);
104 dev_err(di->dev, "error reading temperature\n"); 147 else
105 return ret; 148 rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);
149
150 if (rsoc < 0)
151 dev_err(di->dev, "error reading relative State-of-Charge\n");
152
153 return rsoc;
154}
155
156/*
157 * Return a battery charge value in µAh
158 * Or < 0 if something fails.
159 */
160static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
161{
162 int charge;
163
164 charge = bq27x00_read(di, reg, false);
165 if (charge < 0) {
166 dev_err(di->dev, "error reading nominal available capacity\n");
167 return charge;
106 } 168 }
107 169
108 if (di->chip == BQ27500) 170 if (di->chip == BQ27500)
109 return temp - 2731; 171 charge *= 1000;
110 else 172 else
111 return ((temp >> 2) - 273) * 10; 173 charge = charge * 3570 / BQ27000_RS;
174
175 return charge;
112} 176}
113 177
114/* 178/*
115 * Return the battery Voltage in milivolts 179 * Return the battery Nominal available capaciy in µAh
116 * Or < 0 if something fails. 180 * Or < 0 if something fails.
117 */ 181 */
118static int bq27x00_battery_voltage(struct bq27x00_device_info *di) 182static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
119{ 183{
120 int ret; 184 return bq27x00_battery_read_charge(di, BQ27x00_REG_NAC);
121 int volt = 0; 185}
122 186
123 ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di); 187/*
124 if (ret) { 188 * Return the battery Last measured discharge in µAh
125 dev_err(di->dev, "error reading voltage\n"); 189 * Or < 0 if something fails.
126 return ret; 190 */
191static inline int bq27x00_battery_read_lmd(struct bq27x00_device_info *di)
192{
193 return bq27x00_battery_read_charge(di, BQ27x00_REG_LMD);
194}
195
196/*
197 * Return the battery Initial last measured discharge in µAh
198 * Or < 0 if something fails.
199 */
200static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
201{
202 int ilmd;
203
204 if (di->chip == BQ27500)
205 ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
206 else
207 ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
208
209 if (ilmd < 0) {
210 dev_err(di->dev, "error reading initial last measured discharge\n");
211 return ilmd;
127 } 212 }
128 213
129 return volt * 1000; 214 if (di->chip == BQ27500)
215 ilmd *= 1000;
216 else
217 ilmd = ilmd * 256 * 3570 / BQ27000_RS;
218
219 return ilmd;
130} 220}
131 221
132/* 222/*
133 * Return the battery average current 223 * Return the battery Cycle count total
134 * Note that current can be negative signed as well 224 * Or < 0 if something fails.
135 * Or 0 if something fails.
136 */ 225 */
137static int bq27x00_battery_current(struct bq27x00_device_info *di) 226static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
138{ 227{
139 int ret; 228 int cyct;
140 int curr = 0;
141 int flags = 0;
142 229
143 ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di); 230 cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false);
144 if (ret) { 231 if (cyct < 0)
145 dev_err(di->dev, "error reading current\n"); 232 dev_err(di->dev, "error reading cycle count total\n");
146 return 0; 233
234 return cyct;
235}
236
237/*
238 * Read a time register.
239 * Return < 0 if something fails.
240 */
241static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
242{
243 int tval;
244
245 tval = bq27x00_read(di, reg, false);
246 if (tval < 0) {
247 dev_err(di->dev, "error reading register %02x: %d\n", reg, tval);
248 return tval;
147 } 249 }
148 250
149 if (di->chip == BQ27500) { 251 if (tval == 65535)
150 /* bq27500 returns signed value */ 252 return -ENODATA;
151 curr = (int)(s16)curr; 253
152 } else { 254 return tval * 60;
153 ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di); 255}
154 if (ret < 0) { 256
155 dev_err(di->dev, "error reading flags\n"); 257static void bq27x00_update(struct bq27x00_device_info *di)
156 return 0; 258{
157 } 259 struct bq27x00_reg_cache cache = {0, };
158 if (flags & BQ27000_FLAG_CHGS) { 260 bool is_bq27500 = di->chip == BQ27500;
159 dev_dbg(di->dev, "negative current!\n"); 261
160 curr = -curr; 262 cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, is_bq27500);
161 } 263 if (cache.flags >= 0) {
264 cache.capacity = bq27x00_battery_read_rsoc(di);
265 cache.temperature = bq27x00_read(di, BQ27x00_REG_TEMP, false);
266 cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE);
267 cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP);
268 cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF);
269 cache.charge_full = bq27x00_battery_read_lmd(di);
270 cache.charge_counter = bq27x00_battery_read_cyct(di);
271
272 if (!is_bq27500)
273 cache.current_now = bq27x00_read(di, BQ27x00_REG_AI, false);
274
275 /* We only have to read charge design full once */
276 if (di->charge_design_full <= 0)
277 di->charge_design_full = bq27x00_battery_read_ilmd(di);
278 }
279
280 /* Ignore current_now which is a snapshot of the current battery state
281 * and is likely to be different even between two consecutive reads */
282 if (memcmp(&di->cache, &cache, sizeof(cache) - sizeof(int)) != 0) {
283 di->cache = cache;
284 power_supply_changed(&di->bat);
162 } 285 }
163 286
164 return curr * 1000; 287 di->last_update = jiffies;
288}
289
290static void bq27x00_battery_poll(struct work_struct *work)
291{
292 struct bq27x00_device_info *di =
293 container_of(work, struct bq27x00_device_info, work.work);
294
295 bq27x00_update(di);
296
297 if (poll_interval > 0) {
298 /* The timer does not have to be accurate. */
299 set_timer_slack(&di->work.timer, poll_interval * HZ / 4);
300 schedule_delayed_work(&di->work, poll_interval * HZ);
301 }
165} 302}
166 303
304
167/* 305/*
168 * Return the battery Relative State-of-Charge 306 * Return the battery temperature in tenths of degree Celsius
169 * Or < 0 if something fails. 307 * Or < 0 if something fails.
170 */ 308 */
171static int bq27x00_battery_rsoc(struct bq27x00_device_info *di) 309static int bq27x00_battery_temperature(struct bq27x00_device_info *di,
310 union power_supply_propval *val)
172{ 311{
173 int ret; 312 if (di->cache.temperature < 0)
174 int rsoc = 0; 313 return di->cache.temperature;
175 314
176 if (di->chip == BQ27500) 315 if (di->chip == BQ27500)
177 ret = bq27x00_read(BQ27500_REG_SOC, &rsoc, 0, di); 316 val->intval = di->cache.temperature - 2731;
178 else 317 else
179 ret = bq27x00_read(BQ27000_REG_RSOC, &rsoc, 1, di); 318 val->intval = ((di->cache.temperature * 5) - 5463) / 2;
180 if (ret) { 319
181 dev_err(di->dev, "error reading relative State-of-Charge\n"); 320 return 0;
182 return ret; 321}
322
323/*
324 * Return the battery average current in µA
325 * Note that current can be negative signed as well
326 * Or 0 if something fails.
327 */
328static int bq27x00_battery_current(struct bq27x00_device_info *di,
329 union power_supply_propval *val)
330{
331 int curr;
332
333 if (di->chip == BQ27500)
334 curr = bq27x00_read(di, BQ27x00_REG_AI, false);
335 else
336 curr = di->cache.current_now;
337
338 if (curr < 0)
339 return curr;
340
341 if (di->chip == BQ27500) {
342 /* bq27500 returns signed value */
343 val->intval = (int)((s16)curr) * 1000;
344 } else {
345 if (di->cache.flags & BQ27000_FLAG_CHGS) {
346 dev_dbg(di->dev, "negative current!\n");
347 curr = -curr;
348 }
349
350 val->intval = curr * 3570 / BQ27000_RS;
183 } 351 }
184 352
185 return rsoc; 353 return 0;
186} 354}
187 355
188static int bq27x00_battery_status(struct bq27x00_device_info *di, 356static int bq27x00_battery_status(struct bq27x00_device_info *di,
189 union power_supply_propval *val) 357 union power_supply_propval *val)
190{ 358{
191 int flags = 0;
192 int status; 359 int status;
193 int ret;
194
195 ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di);
196 if (ret < 0) {
197 dev_err(di->dev, "error reading flags\n");
198 return ret;
199 }
200 360
201 if (di->chip == BQ27500) { 361 if (di->chip == BQ27500) {
202 if (flags & BQ27500_FLAG_FC) 362 if (di->cache.flags & BQ27500_FLAG_FC)
203 status = POWER_SUPPLY_STATUS_FULL; 363 status = POWER_SUPPLY_STATUS_FULL;
204 else if (flags & BQ27500_FLAG_DSC) 364 else if (di->cache.flags & BQ27500_FLAG_DSC)
205 status = POWER_SUPPLY_STATUS_DISCHARGING; 365 status = POWER_SUPPLY_STATUS_DISCHARGING;
206 else 366 else
207 status = POWER_SUPPLY_STATUS_CHARGING; 367 status = POWER_SUPPLY_STATUS_CHARGING;
208 } else { 368 } else {
209 if (flags & BQ27000_FLAG_CHGS) 369 if (di->cache.flags & BQ27000_FLAG_FC)
370 status = POWER_SUPPLY_STATUS_FULL;
371 else if (di->cache.flags & BQ27000_FLAG_CHGS)
210 status = POWER_SUPPLY_STATUS_CHARGING; 372 status = POWER_SUPPLY_STATUS_CHARGING;
373 else if (power_supply_am_i_supplied(&di->bat))
374 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
211 else 375 else
212 status = POWER_SUPPLY_STATUS_DISCHARGING; 376 status = POWER_SUPPLY_STATUS_DISCHARGING;
213 } 377 }
214 378
215 val->intval = status; 379 val->intval = status;
380
216 return 0; 381 return 0;
217} 382}
218 383
219/* 384/*
220 * Read a time register. 385 * Return the battery Voltage in milivolts
221 * Return < 0 if something fails. 386 * Or < 0 if something fails.
222 */ 387 */
223static int bq27x00_battery_time(struct bq27x00_device_info *di, int reg, 388static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
224 union power_supply_propval *val) 389 union power_supply_propval *val)
225{ 390{
226 int tval = 0; 391 int volt;
227 int ret;
228 392
229 ret = bq27x00_read(reg, &tval, 0, di); 393 volt = bq27x00_read(di, BQ27x00_REG_VOLT, false);
230 if (ret) { 394 if (volt < 0)
231 dev_err(di->dev, "error reading register %02x\n", reg); 395 return volt;
232 return ret; 396
397 val->intval = volt * 1000;
398
399 return 0;
400}
401
402/*
403 * Return the battery Available energy in µWh
404 * Or < 0 if something fails.
405 */
406static int bq27x00_battery_energy(struct bq27x00_device_info *di,
407 union power_supply_propval *val)
408{
409 int ae;
410
411 ae = bq27x00_read(di, BQ27x00_REG_AE, false);
412 if (ae < 0) {
413 dev_err(di->dev, "error reading available energy\n");
414 return ae;
233 } 415 }
234 416
235 if (tval == 65535) 417 if (di->chip == BQ27500)
236 return -ENODATA; 418 ae *= 1000;
419 else
420 ae = ae * 29200 / BQ27000_RS;
421
422 val->intval = ae;
423
424 return 0;
425}
426
427
428static int bq27x00_simple_value(int value,
429 union power_supply_propval *val)
430{
431 if (value < 0)
432 return value;
433
434 val->intval = value;
237 435
238 val->intval = tval * 60;
239 return 0; 436 return 0;
240} 437}
241 438
@@ -249,33 +446,61 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
249 int ret = 0; 446 int ret = 0;
250 struct bq27x00_device_info *di = to_bq27x00_device_info(psy); 447 struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
251 448
449 mutex_lock(&di->lock);
450 if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
451 cancel_delayed_work_sync(&di->work);
452 bq27x00_battery_poll(&di->work.work);
453 }
454 mutex_unlock(&di->lock);
455
456 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
457 return -ENODEV;
458
252 switch (psp) { 459 switch (psp) {
253 case POWER_SUPPLY_PROP_STATUS: 460 case POWER_SUPPLY_PROP_STATUS:
254 ret = bq27x00_battery_status(di, val); 461 ret = bq27x00_battery_status(di, val);
255 break; 462 break;
256 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 463 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
464 ret = bq27x00_battery_voltage(di, val);
465 break;
257 case POWER_SUPPLY_PROP_PRESENT: 466 case POWER_SUPPLY_PROP_PRESENT:
258 val->intval = bq27x00_battery_voltage(di); 467 val->intval = di->cache.flags < 0 ? 0 : 1;
259 if (psp == POWER_SUPPLY_PROP_PRESENT)
260 val->intval = val->intval <= 0 ? 0 : 1;
261 break; 468 break;
262 case POWER_SUPPLY_PROP_CURRENT_NOW: 469 case POWER_SUPPLY_PROP_CURRENT_NOW:
263 val->intval = bq27x00_battery_current(di); 470 ret = bq27x00_battery_current(di, val);
264 break; 471 break;
265 case POWER_SUPPLY_PROP_CAPACITY: 472 case POWER_SUPPLY_PROP_CAPACITY:
266 val->intval = bq27x00_battery_rsoc(di); 473 ret = bq27x00_simple_value(di->cache.capacity, val);
267 break; 474 break;
268 case POWER_SUPPLY_PROP_TEMP: 475 case POWER_SUPPLY_PROP_TEMP:
269 val->intval = bq27x00_battery_temperature(di); 476 ret = bq27x00_battery_temperature(di, val);
270 break; 477 break;
271 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: 478 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
272 ret = bq27x00_battery_time(di, BQ27x00_REG_TTE, val); 479 ret = bq27x00_simple_value(di->cache.time_to_empty, val);
273 break; 480 break;
274 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 481 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
275 ret = bq27x00_battery_time(di, BQ27x00_REG_TTECP, val); 482 ret = bq27x00_simple_value(di->cache.time_to_empty_avg, val);
276 break; 483 break;
277 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW: 484 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
278 ret = bq27x00_battery_time(di, BQ27x00_REG_TTF, val); 485 ret = bq27x00_simple_value(di->cache.time_to_full, val);
486 break;
487 case POWER_SUPPLY_PROP_TECHNOLOGY:
488 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
489 break;
490 case POWER_SUPPLY_PROP_CHARGE_NOW:
491 ret = bq27x00_simple_value(bq27x00_battery_read_nac(di), val);
492 break;
493 case POWER_SUPPLY_PROP_CHARGE_FULL:
494 ret = bq27x00_simple_value(di->cache.charge_full, val);
495 break;
496 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
497 ret = bq27x00_simple_value(di->charge_design_full, val);
498 break;
499 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
500 ret = bq27x00_simple_value(di->cache.charge_counter, val);
501 break;
502 case POWER_SUPPLY_PROP_ENERGY_NOW:
503 ret = bq27x00_battery_energy(di, val);
279 break; 504 break;
280 default: 505 default:
281 return -EINVAL; 506 return -EINVAL;
@@ -284,56 +509,91 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
284 return ret; 509 return ret;
285} 510}
286 511
287static void bq27x00_powersupply_init(struct bq27x00_device_info *di) 512static void bq27x00_external_power_changed(struct power_supply *psy)
288{ 513{
514 struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
515
516 cancel_delayed_work_sync(&di->work);
517 schedule_delayed_work(&di->work, 0);
518}
519
520static int bq27x00_powersupply_init(struct bq27x00_device_info *di)
521{
522 int ret;
523
289 di->bat.type = POWER_SUPPLY_TYPE_BATTERY; 524 di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
290 di->bat.properties = bq27x00_battery_props; 525 di->bat.properties = bq27x00_battery_props;
291 di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props); 526 di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
292 di->bat.get_property = bq27x00_battery_get_property; 527 di->bat.get_property = bq27x00_battery_get_property;
293 di->bat.external_power_changed = NULL; 528 di->bat.external_power_changed = bq27x00_external_power_changed;
529
530 INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll);
531 mutex_init(&di->lock);
532
533 ret = power_supply_register(di->dev, &di->bat);
534 if (ret) {
535 dev_err(di->dev, "failed to register battery: %d\n", ret);
536 return ret;
537 }
538
539 dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION);
540
541 bq27x00_update(di);
542
543 return 0;
294} 544}
295 545
296/* 546static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
297 * i2c specific code 547{
548 cancel_delayed_work_sync(&di->work);
549
550 power_supply_unregister(&di->bat);
551
552 mutex_destroy(&di->lock);
553}
554
555
556/* i2c specific code */
557#ifdef CONFIG_BATTERY_BQ27X00_I2C
558
559/* If the system has several batteries we need a different name for each
560 * of them...
298 */ 561 */
562static DEFINE_IDR(battery_id);
563static DEFINE_MUTEX(battery_mutex);
299 564
300static int bq27x00_read_i2c(u8 reg, int *rt_value, int b_single, 565static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
301 struct bq27x00_device_info *di)
302{ 566{
303 struct i2c_client *client = di->client; 567 struct i2c_client *client = to_i2c_client(di->dev);
304 struct i2c_msg msg[1]; 568 struct i2c_msg msg[2];
305 unsigned char data[2]; 569 unsigned char data[2];
306 int err; 570 int ret;
307 571
308 if (!client->adapter) 572 if (!client->adapter)
309 return -ENODEV; 573 return -ENODEV;
310 574
311 msg->addr = client->addr; 575 msg[0].addr = client->addr;
312 msg->flags = 0; 576 msg[0].flags = 0;
313 msg->len = 1; 577 msg[0].buf = &reg;
314 msg->buf = data; 578 msg[0].len = sizeof(reg);
315 579 msg[1].addr = client->addr;
316 data[0] = reg; 580 msg[1].flags = I2C_M_RD;
317 err = i2c_transfer(client->adapter, msg, 1); 581 msg[1].buf = data;
582 if (single)
583 msg[1].len = 1;
584 else
585 msg[1].len = 2;
318 586
319 if (err >= 0) { 587 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
320 if (!b_single) 588 if (ret < 0)
321 msg->len = 2; 589 return ret;
322 else
323 msg->len = 1;
324 590
325 msg->flags = I2C_M_RD; 591 if (!single)
326 err = i2c_transfer(client->adapter, msg, 1); 592 ret = get_unaligned_le16(data);
327 if (err >= 0) { 593 else
328 if (!b_single) 594 ret = data[0];
329 *rt_value = get_unaligned_le16(data);
330 else
331 *rt_value = data[0];
332 595
333 return 0; 596 return ret;
334 }
335 }
336 return err;
337} 597}
338 598
339static int bq27x00_battery_probe(struct i2c_client *client, 599static int bq27x00_battery_probe(struct i2c_client *client,
@@ -341,7 +601,6 @@ static int bq27x00_battery_probe(struct i2c_client *client,
341{ 601{
342 char *name; 602 char *name;
343 struct bq27x00_device_info *di; 603 struct bq27x00_device_info *di;
344 struct bq27x00_access_methods *bus;
345 int num; 604 int num;
346 int retval = 0; 605 int retval = 0;
347 606
@@ -368,38 +627,20 @@ static int bq27x00_battery_probe(struct i2c_client *client,
368 retval = -ENOMEM; 627 retval = -ENOMEM;
369 goto batt_failed_2; 628 goto batt_failed_2;
370 } 629 }
630
371 di->id = num; 631 di->id = num;
632 di->dev = &client->dev;
372 di->chip = id->driver_data; 633 di->chip = id->driver_data;
634 di->bat.name = name;
635 di->bus.read = &bq27x00_read_i2c;
373 636
374 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 637 if (bq27x00_powersupply_init(di))
375 if (!bus) {
376 dev_err(&client->dev, "failed to allocate access method "
377 "data\n");
378 retval = -ENOMEM;
379 goto batt_failed_3; 638 goto batt_failed_3;
380 }
381 639
382 i2c_set_clientdata(client, di); 640 i2c_set_clientdata(client, di);
383 di->dev = &client->dev;
384 di->bat.name = name;
385 bus->read = &bq27x00_read_i2c;
386 di->bus = bus;
387 di->client = client;
388
389 bq27x00_powersupply_init(di);
390
391 retval = power_supply_register(&client->dev, &di->bat);
392 if (retval) {
393 dev_err(&client->dev, "failed to register battery\n");
394 goto batt_failed_4;
395 }
396
397 dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
398 641
399 return 0; 642 return 0;
400 643
401batt_failed_4:
402 kfree(bus);
403batt_failed_3: 644batt_failed_3:
404 kfree(di); 645 kfree(di);
405batt_failed_2: 646batt_failed_2:
@@ -416,9 +657,8 @@ static int bq27x00_battery_remove(struct i2c_client *client)
416{ 657{
417 struct bq27x00_device_info *di = i2c_get_clientdata(client); 658 struct bq27x00_device_info *di = i2c_get_clientdata(client);
418 659
419 power_supply_unregister(&di->bat); 660 bq27x00_powersupply_unregister(di);
420 661
421 kfree(di->bus);
422 kfree(di->bat.name); 662 kfree(di->bat.name);
423 663
424 mutex_lock(&battery_mutex); 664 mutex_lock(&battery_mutex);
@@ -430,15 +670,12 @@ static int bq27x00_battery_remove(struct i2c_client *client)
430 return 0; 670 return 0;
431} 671}
432 672
433/*
434 * Module stuff
435 */
436
437static const struct i2c_device_id bq27x00_id[] = { 673static const struct i2c_device_id bq27x00_id[] = {
438 { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */ 674 { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */
439 { "bq27500", BQ27500 }, 675 { "bq27500", BQ27500 },
440 {}, 676 {},
441}; 677};
678MODULE_DEVICE_TABLE(i2c, bq27x00_id);
442 679
443static struct i2c_driver bq27x00_battery_driver = { 680static struct i2c_driver bq27x00_battery_driver = {
444 .driver = { 681 .driver = {
@@ -449,13 +686,164 @@ static struct i2c_driver bq27x00_battery_driver = {
449 .id_table = bq27x00_id, 686 .id_table = bq27x00_id,
450}; 687};
451 688
689static inline int bq27x00_battery_i2c_init(void)
690{
691 int ret = i2c_add_driver(&bq27x00_battery_driver);
692 if (ret)
693 printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n");
694
695 return ret;
696}
697
698static inline void bq27x00_battery_i2c_exit(void)
699{
700 i2c_del_driver(&bq27x00_battery_driver);
701}
702
703#else
704
705static inline int bq27x00_battery_i2c_init(void) { return 0; }
706static inline void bq27x00_battery_i2c_exit(void) {};
707
708#endif
709
710/* platform specific code */
711#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
712
713static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
714 bool single)
715{
716 struct device *dev = di->dev;
717 struct bq27000_platform_data *pdata = dev->platform_data;
718 unsigned int timeout = 3;
719 int upper, lower;
720 int temp;
721
722 if (!single) {
723 /* Make sure the value has not changed in between reading the
724 * lower and the upper part */
725 upper = pdata->read(dev, reg + 1);
726 do {
727 temp = upper;
728 if (upper < 0)
729 return upper;
730
731 lower = pdata->read(dev, reg);
732 if (lower < 0)
733 return lower;
734
735 upper = pdata->read(dev, reg + 1);
736 } while (temp != upper && --timeout);
737
738 if (timeout == 0)
739 return -EIO;
740
741 return (upper << 8) | lower;
742 }
743
744 return pdata->read(dev, reg);
745}
746
747static int __devinit bq27000_battery_probe(struct platform_device *pdev)
748{
749 struct bq27x00_device_info *di;
750 struct bq27000_platform_data *pdata = pdev->dev.platform_data;
751 int ret;
752
753 if (!pdata) {
754 dev_err(&pdev->dev, "no platform_data supplied\n");
755 return -EINVAL;
756 }
757
758 if (!pdata->read) {
759 dev_err(&pdev->dev, "no hdq read callback supplied\n");
760 return -EINVAL;
761 }
762
763 di = kzalloc(sizeof(*di), GFP_KERNEL);
764 if (!di) {
765 dev_err(&pdev->dev, "failed to allocate device info data\n");
766 return -ENOMEM;
767 }
768
769 platform_set_drvdata(pdev, di);
770
771 di->dev = &pdev->dev;
772 di->chip = BQ27000;
773
774 di->bat.name = pdata->name ?: dev_name(&pdev->dev);
775 di->bus.read = &bq27000_read_platform;
776
777 ret = bq27x00_powersupply_init(di);
778 if (ret)
779 goto err_free;
780
781 return 0;
782
783err_free:
784 platform_set_drvdata(pdev, NULL);
785 kfree(di);
786
787 return ret;
788}
789
790static int __devexit bq27000_battery_remove(struct platform_device *pdev)
791{
792 struct bq27x00_device_info *di = platform_get_drvdata(pdev);
793
794 bq27x00_powersupply_unregister(di);
795
796 platform_set_drvdata(pdev, NULL);
797 kfree(di);
798
799 return 0;
800}
801
802static struct platform_driver bq27000_battery_driver = {
803 .probe = bq27000_battery_probe,
804 .remove = __devexit_p(bq27000_battery_remove),
805 .driver = {
806 .name = "bq27000-battery",
807 .owner = THIS_MODULE,
808 },
809};
810
811static inline int bq27x00_battery_platform_init(void)
812{
813 int ret = platform_driver_register(&bq27000_battery_driver);
814 if (ret)
815 printk(KERN_ERR "Unable to register BQ27000 platform driver\n");
816
817 return ret;
818}
819
820static inline void bq27x00_battery_platform_exit(void)
821{
822 platform_driver_unregister(&bq27000_battery_driver);
823}
824
825#else
826
827static inline int bq27x00_battery_platform_init(void) { return 0; }
828static inline void bq27x00_battery_platform_exit(void) {};
829
830#endif
831
832/*
833 * Module stuff
834 */
835
452static int __init bq27x00_battery_init(void) 836static int __init bq27x00_battery_init(void)
453{ 837{
454 int ret; 838 int ret;
455 839
456 ret = i2c_add_driver(&bq27x00_battery_driver); 840 ret = bq27x00_battery_i2c_init();
457 if (ret) 841 if (ret)
458 printk(KERN_ERR "Unable to register BQ27x00 driver\n"); 842 return ret;
843
844 ret = bq27x00_battery_platform_init();
845 if (ret)
846 bq27x00_battery_i2c_exit();
459 847
460 return ret; 848 return ret;
461} 849}
@@ -463,7 +851,8 @@ module_init(bq27x00_battery_init);
463 851
464static void __exit bq27x00_battery_exit(void) 852static void __exit bq27x00_battery_exit(void)
465{ 853{
466 i2c_del_driver(&bq27x00_battery_driver); 854 bq27x00_battery_platform_exit();
855 bq27x00_battery_i2c_exit();
467} 856}
468module_exit(bq27x00_battery_exit); 857module_exit(bq27x00_battery_exit);
469 858
diff --git a/drivers/power/ds2782_battery.c b/drivers/power/ds2782_battery.c
index 6957e8af6449..4d2dc4fa2888 100644
--- a/drivers/power/ds2782_battery.c
+++ b/drivers/power/ds2782_battery.c
@@ -393,6 +393,7 @@ static const struct i2c_device_id ds278x_id[] = {
393 {"ds2786", DS2786}, 393 {"ds2786", DS2786},
394 {}, 394 {},
395}; 395};
396MODULE_DEVICE_TABLE(i2c, ds278x_id);
396 397
397static struct i2c_driver ds278x_battery_driver = { 398static struct i2c_driver ds278x_battery_driver = {
398 .driver = { 399 .driver = {
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index 970f7335d3a7..329b46b2327d 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -171,6 +171,8 @@ int power_supply_register(struct device *parent, struct power_supply *psy)
171 dev_set_drvdata(dev, psy); 171 dev_set_drvdata(dev, psy);
172 psy->dev = dev; 172 psy->dev = dev;
173 173
174 INIT_WORK(&psy->changed_work, power_supply_changed_work);
175
174 rc = kobject_set_name(&dev->kobj, "%s", psy->name); 176 rc = kobject_set_name(&dev->kobj, "%s", psy->name);
175 if (rc) 177 if (rc)
176 goto kobject_set_name_failed; 178 goto kobject_set_name_failed;
@@ -179,8 +181,6 @@ int power_supply_register(struct device *parent, struct power_supply *psy)
179 if (rc) 181 if (rc)
180 goto device_add_failed; 182 goto device_add_failed;
181 183
182 INIT_WORK(&psy->changed_work, power_supply_changed_work);
183
184 rc = power_supply_create_triggers(psy); 184 rc = power_supply_create_triggers(psy);
185 if (rc) 185 if (rc)
186 goto create_triggers_failed; 186 goto create_triggers_failed;
diff --git a/drivers/power/power_supply_leds.c b/drivers/power/power_supply_leds.c
index 031a554837f7..da25eb94e5c6 100644
--- a/drivers/power/power_supply_leds.c
+++ b/drivers/power/power_supply_leds.c
@@ -21,6 +21,8 @@
21static void power_supply_update_bat_leds(struct power_supply *psy) 21static void power_supply_update_bat_leds(struct power_supply *psy)
22{ 22{
23 union power_supply_propval status; 23 union power_supply_propval status;
24 unsigned long delay_on = 0;
25 unsigned long delay_off = 0;
24 26
25 if (psy->get_property(psy, POWER_SUPPLY_PROP_STATUS, &status)) 27 if (psy->get_property(psy, POWER_SUPPLY_PROP_STATUS, &status))
26 return; 28 return;
@@ -32,16 +34,22 @@ static void power_supply_update_bat_leds(struct power_supply *psy)
32 led_trigger_event(psy->charging_full_trig, LED_FULL); 34 led_trigger_event(psy->charging_full_trig, LED_FULL);
33 led_trigger_event(psy->charging_trig, LED_OFF); 35 led_trigger_event(psy->charging_trig, LED_OFF);
34 led_trigger_event(psy->full_trig, LED_FULL); 36 led_trigger_event(psy->full_trig, LED_FULL);
37 led_trigger_event(psy->charging_blink_full_solid_trig,
38 LED_FULL);
35 break; 39 break;
36 case POWER_SUPPLY_STATUS_CHARGING: 40 case POWER_SUPPLY_STATUS_CHARGING:
37 led_trigger_event(psy->charging_full_trig, LED_FULL); 41 led_trigger_event(psy->charging_full_trig, LED_FULL);
38 led_trigger_event(psy->charging_trig, LED_FULL); 42 led_trigger_event(psy->charging_trig, LED_FULL);
39 led_trigger_event(psy->full_trig, LED_OFF); 43 led_trigger_event(psy->full_trig, LED_OFF);
44 led_trigger_blink(psy->charging_blink_full_solid_trig,
45 &delay_on, &delay_off);
40 break; 46 break;
41 default: 47 default:
42 led_trigger_event(psy->charging_full_trig, LED_OFF); 48 led_trigger_event(psy->charging_full_trig, LED_OFF);
43 led_trigger_event(psy->charging_trig, LED_OFF); 49 led_trigger_event(psy->charging_trig, LED_OFF);
44 led_trigger_event(psy->full_trig, LED_OFF); 50 led_trigger_event(psy->full_trig, LED_OFF);
51 led_trigger_event(psy->charging_blink_full_solid_trig,
52 LED_OFF);
45 break; 53 break;
46 } 54 }
47} 55}
@@ -64,15 +72,24 @@ static int power_supply_create_bat_triggers(struct power_supply *psy)
64 if (!psy->full_trig_name) 72 if (!psy->full_trig_name)
65 goto full_failed; 73 goto full_failed;
66 74
75 psy->charging_blink_full_solid_trig_name = kasprintf(GFP_KERNEL,
76 "%s-charging-blink-full-solid", psy->name);
77 if (!psy->charging_blink_full_solid_trig_name)
78 goto charging_blink_full_solid_failed;
79
67 led_trigger_register_simple(psy->charging_full_trig_name, 80 led_trigger_register_simple(psy->charging_full_trig_name,
68 &psy->charging_full_trig); 81 &psy->charging_full_trig);
69 led_trigger_register_simple(psy->charging_trig_name, 82 led_trigger_register_simple(psy->charging_trig_name,
70 &psy->charging_trig); 83 &psy->charging_trig);
71 led_trigger_register_simple(psy->full_trig_name, 84 led_trigger_register_simple(psy->full_trig_name,
72 &psy->full_trig); 85 &psy->full_trig);
86 led_trigger_register_simple(psy->charging_blink_full_solid_trig_name,
87 &psy->charging_blink_full_solid_trig);
73 88
74 goto success; 89 goto success;
75 90
91charging_blink_full_solid_failed:
92 kfree(psy->full_trig_name);
76full_failed: 93full_failed:
77 kfree(psy->charging_trig_name); 94 kfree(psy->charging_trig_name);
78charging_failed: 95charging_failed:
@@ -88,6 +105,8 @@ static void power_supply_remove_bat_triggers(struct power_supply *psy)
88 led_trigger_unregister_simple(psy->charging_full_trig); 105 led_trigger_unregister_simple(psy->charging_full_trig);
89 led_trigger_unregister_simple(psy->charging_trig); 106 led_trigger_unregister_simple(psy->charging_trig);
90 led_trigger_unregister_simple(psy->full_trig); 107 led_trigger_unregister_simple(psy->full_trig);
108 led_trigger_unregister_simple(psy->charging_blink_full_solid_trig);
109 kfree(psy->charging_blink_full_solid_trig_name);
91 kfree(psy->full_trig_name); 110 kfree(psy->full_trig_name);
92 kfree(psy->charging_trig_name); 111 kfree(psy->charging_trig_name);
93 kfree(psy->charging_full_trig_name); 112 kfree(psy->charging_full_trig_name);
diff --git a/drivers/power/power_supply_sysfs.c b/drivers/power/power_supply_sysfs.c
index cd1f90754a3a..605514afc29f 100644
--- a/drivers/power/power_supply_sysfs.c
+++ b/drivers/power/power_supply_sysfs.c
@@ -270,7 +270,7 @@ int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
270 attr = &power_supply_attrs[psy->properties[j]]; 270 attr = &power_supply_attrs[psy->properties[j]];
271 271
272 ret = power_supply_show_property(dev, attr, prop_buf); 272 ret = power_supply_show_property(dev, attr, prop_buf);
273 if (ret == -ENODEV) { 273 if (ret == -ENODEV || ret == -ENODATA) {
274 /* When a battery is absent, we expect -ENODEV. Don't abort; 274 /* When a battery is absent, we expect -ENODEV. Don't abort;
275 send the uevent with at least the the PRESENT=0 property */ 275 send the uevent with at least the the PRESENT=0 property */
276 ret = 0; 276 ret = 0;
diff --git a/drivers/power/s3c_adc_battery.c b/drivers/power/s3c_adc_battery.c
index 4255f2358b13..d36c289aaef5 100644
--- a/drivers/power/s3c_adc_battery.c
+++ b/drivers/power/s3c_adc_battery.c
@@ -406,8 +406,8 @@ static int s3c_adc_bat_resume(struct platform_device *pdev)
406 return 0; 406 return 0;
407} 407}
408#else 408#else
409#define s3c_adc_battery_suspend NULL 409#define s3c_adc_bat_suspend NULL
410#define s3c_adc_battery_resume NULL 410#define s3c_adc_bat_resume NULL
411#endif 411#endif
412 412
413static struct platform_driver s3c_adc_bat_driver = { 413static struct platform_driver s3c_adc_bat_driver = {
diff --git a/drivers/power/twl4030_charger.c b/drivers/power/twl4030_charger.c
index ff1f42398a2e..92c16e1677bd 100644
--- a/drivers/power/twl4030_charger.c
+++ b/drivers/power/twl4030_charger.c
@@ -71,8 +71,11 @@ struct twl4030_bci {
71 struct power_supply usb; 71 struct power_supply usb;
72 struct otg_transceiver *transceiver; 72 struct otg_transceiver *transceiver;
73 struct notifier_block otg_nb; 73 struct notifier_block otg_nb;
74 struct work_struct work;
74 int irq_chg; 75 int irq_chg;
75 int irq_bci; 76 int irq_bci;
77
78 unsigned long event;
76}; 79};
77 80
78/* 81/*
@@ -258,14 +261,11 @@ static irqreturn_t twl4030_bci_interrupt(int irq, void *arg)
258 return IRQ_HANDLED; 261 return IRQ_HANDLED;
259} 262}
260 263
261static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val, 264static void twl4030_bci_usb_work(struct work_struct *data)
262 void *priv)
263{ 265{
264 struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, otg_nb); 266 struct twl4030_bci *bci = container_of(data, struct twl4030_bci, work);
265 267
266 dev_dbg(bci->dev, "OTG notify %lu\n", val); 268 switch (bci->event) {
267
268 switch (val) {
269 case USB_EVENT_VBUS: 269 case USB_EVENT_VBUS:
270 case USB_EVENT_CHARGER: 270 case USB_EVENT_CHARGER:
271 twl4030_charger_enable_usb(bci, true); 271 twl4030_charger_enable_usb(bci, true);
@@ -274,6 +274,17 @@ static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
274 twl4030_charger_enable_usb(bci, false); 274 twl4030_charger_enable_usb(bci, false);
275 break; 275 break;
276 } 276 }
277}
278
279static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
280 void *priv)
281{
282 struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, otg_nb);
283
284 dev_dbg(bci->dev, "OTG notify %lu\n", val);
285
286 bci->event = val;
287 schedule_work(&bci->work);
277 288
278 return NOTIFY_OK; 289 return NOTIFY_OK;
279} 290}
@@ -466,6 +477,8 @@ static int __init twl4030_bci_probe(struct platform_device *pdev)
466 goto fail_bci_irq; 477 goto fail_bci_irq;
467 } 478 }
468 479
480 INIT_WORK(&bci->work, twl4030_bci_usb_work);
481
469 bci->transceiver = otg_get_transceiver(); 482 bci->transceiver = otg_get_transceiver();
470 if (bci->transceiver != NULL) { 483 if (bci->transceiver != NULL) {
471 bci->otg_nb.notifier_call = twl4030_bci_usb_ncb; 484 bci->otg_nb.notifier_call = twl4030_bci_usb_ncb;
diff --git a/drivers/power/z2_battery.c b/drivers/power/z2_battery.c
index e5ed52d71937..2a9ab89f83b8 100644
--- a/drivers/power/z2_battery.c
+++ b/drivers/power/z2_battery.c
@@ -134,6 +134,8 @@ static int z2_batt_ps_init(struct z2_charger *charger, int props)
134 enum power_supply_property *prop; 134 enum power_supply_property *prop;
135 struct z2_battery_info *info = charger->info; 135 struct z2_battery_info *info = charger->info;
136 136
137 if (info->charge_gpio >= 0)
138 props++; /* POWER_SUPPLY_PROP_STATUS */
137 if (info->batt_tech >= 0) 139 if (info->batt_tech >= 0)
138 props++; /* POWER_SUPPLY_PROP_TECHNOLOGY */ 140 props++; /* POWER_SUPPLY_PROP_TECHNOLOGY */
139 if (info->batt_I2C_reg >= 0) 141 if (info->batt_I2C_reg >= 0)
@@ -293,6 +295,7 @@ static const struct i2c_device_id z2_batt_id[] = {
293 { "aer915", 0 }, 295 { "aer915", 0 },
294 { } 296 { }
295}; 297};
298MODULE_DEVICE_TABLE(i2c, z2_batt_id);
296 299
297static struct i2c_driver z2_batt_driver = { 300static struct i2c_driver z2_batt_driver = {
298 .driver = { 301 .driver = {
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 383811d9af83..61e0340a4b77 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -145,6 +145,9 @@ extern void led_trigger_register_simple(const char *name,
145extern void led_trigger_unregister_simple(struct led_trigger *trigger); 145extern void led_trigger_unregister_simple(struct led_trigger *trigger);
146extern void led_trigger_event(struct led_trigger *trigger, 146extern void led_trigger_event(struct led_trigger *trigger,
147 enum led_brightness event); 147 enum led_brightness event);
148extern void led_trigger_blink(struct led_trigger *trigger,
149 unsigned long *delay_on,
150 unsigned long *delay_off);
148 151
149#else 152#else
150 153
diff --git a/include/linux/power/bq20z75.h b/include/linux/power/bq20z75.h
new file mode 100644
index 000000000000..b0843b68af92
--- /dev/null
+++ b/include/linux/power/bq20z75.h
@@ -0,0 +1,39 @@
1/*
2 * Gas Gauge driver for TI's BQ20Z75
3 *
4 * Copyright (c) 2010, NVIDIA Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20
21#ifndef __LINUX_POWER_BQ20Z75_H_
22#define __LINUX_POWER_BQ20Z75_H_
23
24#include <linux/power_supply.h>
25#include <linux/types.h>
26
27/**
28 * struct bq20z75_platform_data - platform data for bq20z75 devices
29 * @battery_detect: GPIO which is used to detect battery presence
30 * @battery_detect_present: gpio state when battery is present (0 / 1)
31 * @i2c_retry_count: # of times to retry on i2c IO failure
32 */
33struct bq20z75_platform_data {
34 int battery_detect;
35 int battery_detect_present;
36 int i2c_retry_count;
37};
38
39#endif
diff --git a/include/linux/power/bq27x00_battery.h b/include/linux/power/bq27x00_battery.h
new file mode 100644
index 000000000000..a857f719bf40
--- /dev/null
+++ b/include/linux/power/bq27x00_battery.h
@@ -0,0 +1,19 @@
1#ifndef __LINUX_BQ27X00_BATTERY_H__
2#define __LINUX_BQ27X00_BATTERY_H__
3
4/**
5 * struct bq27000_plaform_data - Platform data for bq27000 devices
6 * @name: Name of the battery. If NULL the driver will fallback to "bq27000".
7 * @read: HDQ read callback.
8 * This function should provide access to the HDQ bus the battery is
9 * connected to.
10 * The first parameter is a pointer to the battery device, the second the
11 * register to be read. The return value should either be the content of
12 * the passed register or an error value.
13 */
14struct bq27000_platform_data {
15 const char *name;
16 int (*read)(struct device *dev, unsigned int);
17};
18
19#endif
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 7d7325685c42..204c18dfdc9e 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -173,6 +173,8 @@ struct power_supply {
173 char *full_trig_name; 173 char *full_trig_name;
174 struct led_trigger *online_trig; 174 struct led_trigger *online_trig;
175 char *online_trig_name; 175 char *online_trig_name;
176 struct led_trigger *charging_blink_full_solid_trig;
177 char *charging_blink_full_solid_trig_name;
176#endif 178#endif
177}; 179};
178 180
@@ -213,4 +215,49 @@ extern void power_supply_unregister(struct power_supply *psy);
213/* For APM emulation, think legacy userspace. */ 215/* For APM emulation, think legacy userspace. */
214extern struct class *power_supply_class; 216extern struct class *power_supply_class;
215 217
218static inline bool power_supply_is_amp_property(enum power_supply_property psp)
219{
220 switch (psp) {
221 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
222 case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
223 case POWER_SUPPLY_PROP_CHARGE_FULL:
224 case POWER_SUPPLY_PROP_CHARGE_EMPTY:
225 case POWER_SUPPLY_PROP_CHARGE_NOW:
226 case POWER_SUPPLY_PROP_CHARGE_AVG:
227 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
228 case POWER_SUPPLY_PROP_CURRENT_MAX:
229 case POWER_SUPPLY_PROP_CURRENT_NOW:
230 case POWER_SUPPLY_PROP_CURRENT_AVG:
231 return 1;
232 default:
233 break;
234 }
235
236 return 0;
237}
238
239static inline bool power_supply_is_watt_property(enum power_supply_property psp)
240{
241 switch (psp) {
242 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
243 case POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN:
244 case POWER_SUPPLY_PROP_ENERGY_FULL:
245 case POWER_SUPPLY_PROP_ENERGY_EMPTY:
246 case POWER_SUPPLY_PROP_ENERGY_NOW:
247 case POWER_SUPPLY_PROP_ENERGY_AVG:
248 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
249 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
250 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
251 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
252 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
253 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
254 case POWER_SUPPLY_PROP_POWER_NOW:
255 return 1;
256 default:
257 break;
258 }
259
260 return 0;
261}
262
216#endif /* __LINUX_POWER_SUPPLY_H__ */ 263#endif /* __LINUX_POWER_SUPPLY_H__ */
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-25 10:03:18 -0500