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>
24 #include <linux/delay.h>
25 #include <linux/gpio.h>
26 #include <linux/mfd/core.h>
27 #include <linux/power_supply.h>
29 #include <linux/power/jz4740-battery.h>
30 #include <linux/jz4740-adc.h>
33 struct jz_battery_platform_data
*pdata
;
34 struct platform_device
*pdev
;
42 const struct mfd_cell
*cell
;
47 struct completion read_completion
;
49 struct power_supply battery
;
50 struct delayed_work work
;
55 static inline struct jz_battery
*psy_to_jz_battery(struct power_supply
*psy
)
57 return container_of(psy
, struct jz_battery
, battery
);
60 static irqreturn_t
jz_battery_irq_handler(int irq
, void *devid
)
62 struct jz_battery
*battery
= devid
;
64 complete(&battery
->read_completion
);
68 static long jz_battery_read_voltage(struct jz_battery
*battery
)
74 mutex_lock(&battery
->lock
);
76 INIT_COMPLETION(battery
->read_completion
);
78 enable_irq(battery
->irq
);
79 battery
->cell
->enable(battery
->pdev
);
81 t
= wait_for_completion_interruptible_timeout(&battery
->read_completion
,
85 val
= readw(battery
->base
) & 0xfff;
87 if (battery
->pdata
->info
.voltage_max_design
<= 2500000)
88 val
= (val
* 78125UL) >> 7UL;
90 val
= ((val
* 924375UL) >> 9UL) + 33000;
93 voltage
= t
? t
: -ETIMEDOUT
;
96 battery
->cell
->disable(battery
->pdev
);
97 disable_irq(battery
->irq
);
99 mutex_unlock(&battery
->lock
);
104 static int jz_battery_get_capacity(struct power_supply
*psy
)
106 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
107 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
112 voltage
= jz_battery_read_voltage(jz_battery
);
117 voltage_span
= info
->voltage_max_design
- info
->voltage_min_design
;
118 ret
= ((voltage
- info
->voltage_min_design
) * 100) / voltage_span
;
128 static int jz_battery_get_property(struct power_supply
*psy
,
129 enum power_supply_property psp
, union power_supply_propval
*val
)
131 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
132 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
136 case POWER_SUPPLY_PROP_STATUS
:
137 val
->intval
= jz_battery
->status
;
139 case POWER_SUPPLY_PROP_TECHNOLOGY
:
140 val
->intval
= jz_battery
->pdata
->info
.technology
;
142 case POWER_SUPPLY_PROP_HEALTH
:
143 voltage
= jz_battery_read_voltage(jz_battery
);
144 if (voltage
< info
->voltage_min_design
)
145 val
->intval
= POWER_SUPPLY_HEALTH_DEAD
;
147 val
->intval
= POWER_SUPPLY_HEALTH_GOOD
;
149 case POWER_SUPPLY_PROP_CAPACITY
:
150 val
->intval
= jz_battery_get_capacity(psy
);
152 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
153 val
->intval
= jz_battery_read_voltage(jz_battery
);
157 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
158 val
->intval
= info
->voltage_max_design
;
160 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
161 val
->intval
= info
->voltage_min_design
;
163 case POWER_SUPPLY_PROP_PRESENT
:
172 static void jz_battery_external_power_changed(struct power_supply
*psy
)
174 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
176 mod_delayed_work(system_wq
, &jz_battery
->work
, 0);
179 static irqreturn_t
jz_battery_charge_irq(int irq
, void *data
)
181 struct jz_battery
*jz_battery
= data
;
183 mod_delayed_work(system_wq
, &jz_battery
->work
, 0);
188 static void jz_battery_update(struct jz_battery
*jz_battery
)
192 bool has_changed
= false;
195 if (gpio_is_valid(jz_battery
->pdata
->gpio_charge
)) {
196 is_charging
= gpio_get_value(jz_battery
->pdata
->gpio_charge
);
197 is_charging
^= jz_battery
->pdata
->gpio_charge_active_low
;
199 status
= POWER_SUPPLY_STATUS_CHARGING
;
201 status
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
203 if (status
!= jz_battery
->status
) {
204 jz_battery
->status
= status
;
209 voltage
= jz_battery_read_voltage(jz_battery
);
210 if (abs(voltage
- jz_battery
->voltage
) < 50000) {
211 jz_battery
->voltage
= voltage
;
216 power_supply_changed(&jz_battery
->battery
);
219 static enum power_supply_property jz_battery_properties
[] = {
220 POWER_SUPPLY_PROP_STATUS
,
221 POWER_SUPPLY_PROP_TECHNOLOGY
,
222 POWER_SUPPLY_PROP_HEALTH
,
223 POWER_SUPPLY_PROP_CAPACITY
,
224 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
225 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
,
226 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
227 POWER_SUPPLY_PROP_PRESENT
,
230 static void jz_battery_work(struct work_struct
*work
)
232 /* Too small interval will increase system workload */
233 const int interval
= HZ
* 30;
234 struct jz_battery
*jz_battery
= container_of(work
, struct jz_battery
,
237 jz_battery_update(jz_battery
);
238 schedule_delayed_work(&jz_battery
->work
, interval
);
241 static int __devinit
jz_battery_probe(struct platform_device
*pdev
)
244 struct jz_battery_platform_data
*pdata
= pdev
->dev
.parent
->platform_data
;
245 struct jz_battery
*jz_battery
;
246 struct power_supply
*battery
;
249 dev_err(&pdev
->dev
, "No platform_data supplied\n");
253 jz_battery
= kzalloc(sizeof(*jz_battery
), GFP_KERNEL
);
255 dev_err(&pdev
->dev
, "Failed to allocate driver structure\n");
259 jz_battery
->cell
= mfd_get_cell(pdev
);
261 jz_battery
->irq
= platform_get_irq(pdev
, 0);
262 if (jz_battery
->irq
< 0) {
263 ret
= jz_battery
->irq
;
264 dev_err(&pdev
->dev
, "Failed to get platform irq: %d\n", ret
);
268 jz_battery
->mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
269 if (!jz_battery
->mem
) {
271 dev_err(&pdev
->dev
, "Failed to get platform mmio resource\n");
275 jz_battery
->mem
= request_mem_region(jz_battery
->mem
->start
,
276 resource_size(jz_battery
->mem
), pdev
->name
);
277 if (!jz_battery
->mem
) {
279 dev_err(&pdev
->dev
, "Failed to request mmio memory region\n");
283 jz_battery
->base
= ioremap_nocache(jz_battery
->mem
->start
,
284 resource_size(jz_battery
->mem
));
285 if (!jz_battery
->base
) {
287 dev_err(&pdev
->dev
, "Failed to ioremap mmio memory\n");
288 goto err_release_mem_region
;
291 battery
= &jz_battery
->battery
;
292 battery
->name
= pdata
->info
.name
;
293 battery
->type
= POWER_SUPPLY_TYPE_BATTERY
;
294 battery
->properties
= jz_battery_properties
;
295 battery
->num_properties
= ARRAY_SIZE(jz_battery_properties
);
296 battery
->get_property
= jz_battery_get_property
;
297 battery
->external_power_changed
= jz_battery_external_power_changed
;
298 battery
->use_for_apm
= 1;
300 jz_battery
->pdata
= pdata
;
301 jz_battery
->pdev
= pdev
;
303 init_completion(&jz_battery
->read_completion
);
304 mutex_init(&jz_battery
->lock
);
306 INIT_DELAYED_WORK(&jz_battery
->work
, jz_battery_work
);
308 ret
= request_irq(jz_battery
->irq
, jz_battery_irq_handler
, 0, pdev
->name
,
311 dev_err(&pdev
->dev
, "Failed to request irq %d\n", ret
);
314 disable_irq(jz_battery
->irq
);
316 if (gpio_is_valid(pdata
->gpio_charge
)) {
317 ret
= gpio_request(pdata
->gpio_charge
, dev_name(&pdev
->dev
));
319 dev_err(&pdev
->dev
, "charger state gpio request failed.\n");
322 ret
= gpio_direction_input(pdata
->gpio_charge
);
324 dev_err(&pdev
->dev
, "charger state gpio set direction failed.\n");
328 jz_battery
->charge_irq
= gpio_to_irq(pdata
->gpio_charge
);
330 if (jz_battery
->charge_irq
>= 0) {
331 ret
= request_irq(jz_battery
->charge_irq
,
332 jz_battery_charge_irq
,
333 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
334 dev_name(&pdev
->dev
), jz_battery
);
336 dev_err(&pdev
->dev
, "Failed to request charge irq: %d\n", ret
);
341 jz_battery
->charge_irq
= -1;
344 if (jz_battery
->pdata
->info
.voltage_max_design
<= 2500000)
345 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
,
346 JZ_ADC_CONFIG_BAT_MB
);
348 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
, 0);
350 ret
= power_supply_register(&pdev
->dev
, &jz_battery
->battery
);
352 dev_err(&pdev
->dev
, "power supply battery register failed.\n");
353 goto err_free_charge_irq
;
356 platform_set_drvdata(pdev
, jz_battery
);
357 schedule_delayed_work(&jz_battery
->work
, 0);
362 if (jz_battery
->charge_irq
>= 0)
363 free_irq(jz_battery
->charge_irq
, jz_battery
);
365 if (gpio_is_valid(pdata
->gpio_charge
))
366 gpio_free(jz_battery
->pdata
->gpio_charge
);
368 free_irq(jz_battery
->irq
, jz_battery
);
370 platform_set_drvdata(pdev
, NULL
);
371 iounmap(jz_battery
->base
);
372 err_release_mem_region
:
373 release_mem_region(jz_battery
->mem
->start
, resource_size(jz_battery
->mem
));
379 static int __devexit
jz_battery_remove(struct platform_device
*pdev
)
381 struct jz_battery
*jz_battery
= platform_get_drvdata(pdev
);
383 cancel_delayed_work_sync(&jz_battery
->work
);
385 if (gpio_is_valid(jz_battery
->pdata
->gpio_charge
)) {
386 if (jz_battery
->charge_irq
>= 0)
387 free_irq(jz_battery
->charge_irq
, jz_battery
);
388 gpio_free(jz_battery
->pdata
->gpio_charge
);
391 power_supply_unregister(&jz_battery
->battery
);
393 free_irq(jz_battery
->irq
, jz_battery
);
395 iounmap(jz_battery
->base
);
396 release_mem_region(jz_battery
->mem
->start
, resource_size(jz_battery
->mem
));
403 static int jz_battery_suspend(struct device
*dev
)
405 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
407 cancel_delayed_work_sync(&jz_battery
->work
);
408 jz_battery
->status
= POWER_SUPPLY_STATUS_UNKNOWN
;
413 static int jz_battery_resume(struct device
*dev
)
415 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
417 schedule_delayed_work(&jz_battery
->work
, 0);
422 static const struct dev_pm_ops jz_battery_pm_ops
= {
423 .suspend
= jz_battery_suspend
,
424 .resume
= jz_battery_resume
,
427 #define JZ_BATTERY_PM_OPS (&jz_battery_pm_ops)
429 #define JZ_BATTERY_PM_OPS NULL
432 static struct platform_driver jz_battery_driver
= {
433 .probe
= jz_battery_probe
,
434 .remove
= __devexit_p(jz_battery_remove
),
436 .name
= "jz4740-battery",
437 .owner
= THIS_MODULE
,
438 .pm
= JZ_BATTERY_PM_OPS
,
442 module_platform_driver(jz_battery_driver
);
444 MODULE_ALIAS("platform:jz4740-battery");
445 MODULE_LICENSE("GPL");
446 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
447 MODULE_DESCRIPTION("JZ4740 SoC battery driver");