2 * Battery measurement code for Ingenic JZ SOC.
4 * Copyright (C) 2009 Jiejing Zhang <kzjeef@gmail.com>
5 * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
7 * based on tosa_battery.c
9 * Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
11 * This program 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.
17 #include <linux/interrupt.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/slab.h>
23 #include <linux/delay.h>
24 #include <linux/gpio.h>
25 #include <linux/mfd/core.h>
26 #include <linux/power_supply.h>
28 #include <linux/power/jz4740-battery.h>
29 #include <linux/jz4740-adc.h>
32 struct jz_battery_platform_data
*pdata
;
33 struct platform_device
*pdev
;
41 struct mfd_cell
*cell
;
46 struct completion read_completion
;
48 struct power_supply battery
;
49 struct delayed_work work
;
54 static inline struct jz_battery
*psy_to_jz_battery(struct power_supply
*psy
)
56 return container_of(psy
, struct jz_battery
, battery
);
59 static irqreturn_t
jz_battery_irq_handler(int irq
, void *devid
)
61 struct jz_battery
*battery
= devid
;
63 complete(&battery
->read_completion
);
67 static long jz_battery_read_voltage(struct jz_battery
*battery
)
73 mutex_lock(&battery
->lock
);
75 INIT_COMPLETION(battery
->read_completion
);
77 enable_irq(battery
->irq
);
78 battery
->cell
->enable(battery
->pdev
);
80 t
= wait_for_completion_interruptible_timeout(&battery
->read_completion
,
84 val
= readw(battery
->base
) & 0xfff;
86 if (battery
->pdata
->info
.voltage_max_design
<= 2500000)
87 val
= (val
* 78125UL) >> 7UL;
89 val
= ((val
* 924375UL) >> 9UL) + 33000;
92 voltage
= t
? t
: -ETIMEDOUT
;
95 battery
->cell
->disable(battery
->pdev
);
96 disable_irq(battery
->irq
);
98 mutex_unlock(&battery
->lock
);
103 static int jz_battery_get_capacity(struct power_supply
*psy
)
105 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
106 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
111 voltage
= jz_battery_read_voltage(jz_battery
);
116 voltage_span
= info
->voltage_max_design
- info
->voltage_min_design
;
117 ret
= ((voltage
- info
->voltage_min_design
) * 100) / voltage_span
;
127 static int jz_battery_get_property(struct power_supply
*psy
,
128 enum power_supply_property psp
, union power_supply_propval
*val
)
130 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
131 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
135 case POWER_SUPPLY_PROP_STATUS
:
136 val
->intval
= jz_battery
->status
;
138 case POWER_SUPPLY_PROP_TECHNOLOGY
:
139 val
->intval
= jz_battery
->pdata
->info
.technology
;
141 case POWER_SUPPLY_PROP_HEALTH
:
142 voltage
= jz_battery_read_voltage(jz_battery
);
143 if (voltage
< info
->voltage_min_design
)
144 val
->intval
= POWER_SUPPLY_HEALTH_DEAD
;
146 val
->intval
= POWER_SUPPLY_HEALTH_GOOD
;
148 case POWER_SUPPLY_PROP_CAPACITY
:
149 val
->intval
= jz_battery_get_capacity(psy
);
151 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
152 val
->intval
= jz_battery_read_voltage(jz_battery
);
156 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
157 val
->intval
= info
->voltage_max_design
;
159 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
160 val
->intval
= info
->voltage_min_design
;
162 case POWER_SUPPLY_PROP_PRESENT
:
171 static void jz_battery_external_power_changed(struct power_supply
*psy
)
173 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
175 cancel_delayed_work(&jz_battery
->work
);
176 schedule_delayed_work(&jz_battery
->work
, 0);
179 static irqreturn_t
jz_battery_charge_irq(int irq
, void *data
)
181 struct jz_battery
*jz_battery
= data
;
183 cancel_delayed_work(&jz_battery
->work
);
184 schedule_delayed_work(&jz_battery
->work
, 0);
189 static void jz_battery_update(struct jz_battery
*jz_battery
)
193 bool has_changed
= false;
196 if (gpio_is_valid(jz_battery
->pdata
->gpio_charge
)) {
197 is_charging
= gpio_get_value(jz_battery
->pdata
->gpio_charge
);
198 is_charging
^= jz_battery
->pdata
->gpio_charge_active_low
;
200 status
= POWER_SUPPLY_STATUS_CHARGING
;
202 status
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
204 if (status
!= jz_battery
->status
) {
205 jz_battery
->status
= status
;
210 voltage
= jz_battery_read_voltage(jz_battery
);
211 if (abs(voltage
- jz_battery
->voltage
) < 50000) {
212 jz_battery
->voltage
= voltage
;
217 power_supply_changed(&jz_battery
->battery
);
220 static enum power_supply_property jz_battery_properties
[] = {
221 POWER_SUPPLY_PROP_STATUS
,
222 POWER_SUPPLY_PROP_TECHNOLOGY
,
223 POWER_SUPPLY_PROP_HEALTH
,
224 POWER_SUPPLY_PROP_CAPACITY
,
225 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
226 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
,
227 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
228 POWER_SUPPLY_PROP_PRESENT
,
231 static void jz_battery_work(struct work_struct
*work
)
233 /* Too small interval will increase system workload */
234 const int interval
= HZ
* 30;
235 struct jz_battery
*jz_battery
= container_of(work
, struct jz_battery
,
238 jz_battery_update(jz_battery
);
239 schedule_delayed_work(&jz_battery
->work
, interval
);
242 static int __devinit
jz_battery_probe(struct platform_device
*pdev
)
245 struct jz_battery_platform_data
*pdata
= pdev
->dev
.parent
->platform_data
;
246 struct jz_battery
*jz_battery
;
247 struct power_supply
*battery
;
249 jz_battery
= kzalloc(sizeof(*jz_battery
), GFP_KERNEL
);
251 dev_err(&pdev
->dev
, "Failed to allocate driver structure\n");
255 jz_battery
->cell
= pdev
->dev
.platform_data
;
257 jz_battery
->irq
= platform_get_irq(pdev
, 0);
258 if (jz_battery
->irq
< 0) {
259 ret
= jz_battery
->irq
;
260 dev_err(&pdev
->dev
, "Failed to get platform irq: %d\n", ret
);
264 jz_battery
->mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
265 if (!jz_battery
->mem
) {
267 dev_err(&pdev
->dev
, "Failed to get platform mmio resource\n");
271 jz_battery
->mem
= request_mem_region(jz_battery
->mem
->start
,
272 resource_size(jz_battery
->mem
), pdev
->name
);
273 if (!jz_battery
->mem
) {
275 dev_err(&pdev
->dev
, "Failed to request mmio memory region\n");
279 jz_battery
->base
= ioremap_nocache(jz_battery
->mem
->start
,
280 resource_size(jz_battery
->mem
));
281 if (!jz_battery
->base
) {
283 dev_err(&pdev
->dev
, "Failed to ioremap mmio memory\n");
284 goto err_release_mem_region
;
287 battery
= &jz_battery
->battery
;
288 battery
->name
= pdata
->info
.name
;
289 battery
->type
= POWER_SUPPLY_TYPE_BATTERY
;
290 battery
->properties
= jz_battery_properties
;
291 battery
->num_properties
= ARRAY_SIZE(jz_battery_properties
);
292 battery
->get_property
= jz_battery_get_property
;
293 battery
->external_power_changed
= jz_battery_external_power_changed
;
294 battery
->use_for_apm
= 1;
296 jz_battery
->pdata
= pdata
;
297 jz_battery
->pdev
= pdev
;
299 init_completion(&jz_battery
->read_completion
);
300 mutex_init(&jz_battery
->lock
);
302 INIT_DELAYED_WORK(&jz_battery
->work
, jz_battery_work
);
304 ret
= request_irq(jz_battery
->irq
, jz_battery_irq_handler
, 0, pdev
->name
,
307 dev_err(&pdev
->dev
, "Failed to request irq %d\n", ret
);
310 disable_irq(jz_battery
->irq
);
312 if (gpio_is_valid(pdata
->gpio_charge
)) {
313 ret
= gpio_request(pdata
->gpio_charge
, dev_name(&pdev
->dev
));
315 dev_err(&pdev
->dev
, "charger state gpio request failed.\n");
318 ret
= gpio_direction_input(pdata
->gpio_charge
);
320 dev_err(&pdev
->dev
, "charger state gpio set direction failed.\n");
324 jz_battery
->charge_irq
= gpio_to_irq(pdata
->gpio_charge
);
326 if (jz_battery
->charge_irq
>= 0) {
327 ret
= request_irq(jz_battery
->charge_irq
,
328 jz_battery_charge_irq
,
329 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
330 dev_name(&pdev
->dev
), jz_battery
);
332 dev_err(&pdev
->dev
, "Failed to request charge irq: %d\n", ret
);
337 jz_battery
->charge_irq
= -1;
340 if (jz_battery
->pdata
->info
.voltage_max_design
<= 2500000)
341 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
,
342 JZ_ADC_CONFIG_BAT_MB
);
344 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
, 0);
346 ret
= power_supply_register(&pdev
->dev
, &jz_battery
->battery
);
348 dev_err(&pdev
->dev
, "power supply battery register failed.\n");
349 goto err_free_charge_irq
;
352 platform_set_drvdata(pdev
, jz_battery
);
353 schedule_delayed_work(&jz_battery
->work
, 0);
358 if (jz_battery
->charge_irq
>= 0)
359 free_irq(jz_battery
->charge_irq
, jz_battery
);
361 if (gpio_is_valid(pdata
->gpio_charge
))
362 gpio_free(jz_battery
->pdata
->gpio_charge
);
364 free_irq(jz_battery
->irq
, jz_battery
);
366 platform_set_drvdata(pdev
, NULL
);
367 iounmap(jz_battery
->base
);
368 err_release_mem_region
:
369 release_mem_region(jz_battery
->mem
->start
, resource_size(jz_battery
->mem
));
375 static int __devexit
jz_battery_remove(struct platform_device
*pdev
)
377 struct jz_battery
*jz_battery
= platform_get_drvdata(pdev
);
379 cancel_delayed_work_sync(&jz_battery
->work
);
381 if (gpio_is_valid(jz_battery
->pdata
->gpio_charge
)) {
382 if (jz_battery
->charge_irq
>= 0)
383 free_irq(jz_battery
->charge_irq
, jz_battery
);
384 gpio_free(jz_battery
->pdata
->gpio_charge
);
387 power_supply_unregister(&jz_battery
->battery
);
389 free_irq(jz_battery
->irq
, jz_battery
);
391 iounmap(jz_battery
->base
);
392 release_mem_region(jz_battery
->mem
->start
, resource_size(jz_battery
->mem
));
398 static int jz_battery_suspend(struct device
*dev
)
400 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
402 cancel_delayed_work_sync(&jz_battery
->work
);
403 jz_battery
->status
= POWER_SUPPLY_STATUS_UNKNOWN
;
408 static int jz_battery_resume(struct device
*dev
)
410 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
412 schedule_delayed_work(&jz_battery
->work
, 0);
417 static const struct dev_pm_ops jz_battery_pm_ops
= {
418 .suspend
= jz_battery_suspend
,
419 .resume
= jz_battery_resume
,
422 #define JZ_BATTERY_PM_OPS (&jz_battery_pm_ops)
424 #define JZ_BATTERY_PM_OPS NULL
427 static struct platform_driver jz_battery_driver
= {
428 .probe
= jz_battery_probe
,
429 .remove
= __devexit_p(jz_battery_remove
),
431 .name
= "jz4740-battery",
432 .owner
= THIS_MODULE
,
433 .pm
= JZ_BATTERY_PM_OPS
,
437 static int __init
jz_battery_init(void)
439 return platform_driver_register(&jz_battery_driver
);
441 module_init(jz_battery_init
);
443 static void __exit
jz_battery_exit(void)
445 platform_driver_unregister(&jz_battery_driver
);
447 module_exit(jz_battery_exit
);
449 MODULE_ALIAS("platform:jz4740-battery");
450 MODULE_LICENSE("GPL");
451 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
452 MODULE_DESCRIPTION("JZ4740 SoC battery driver");