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/err.h>
26 #include <linux/gpio.h>
27 #include <linux/mfd/core.h>
28 #include <linux/power_supply.h>
30 #include <linux/power/jz4740-battery.h>
31 #include <linux/jz4740-adc.h>
34 struct jz_battery_platform_data
*pdata
;
35 struct platform_device
*pdev
;
42 const struct mfd_cell
*cell
;
47 struct completion read_completion
;
49 struct power_supply
*battery
;
50 struct power_supply_desc battery_desc
;
51 struct delayed_work work
;
56 static inline struct jz_battery
*psy_to_jz_battery(struct power_supply
*psy
)
58 return power_supply_get_drvdata(psy
);
61 static irqreturn_t
jz_battery_irq_handler(int irq
, void *devid
)
63 struct jz_battery
*battery
= devid
;
65 complete(&battery
->read_completion
);
69 static long jz_battery_read_voltage(struct jz_battery
*battery
)
75 mutex_lock(&battery
->lock
);
77 reinit_completion(&battery
->read_completion
);
79 enable_irq(battery
->irq
);
80 battery
->cell
->enable(battery
->pdev
);
82 t
= wait_for_completion_interruptible_timeout(&battery
->read_completion
,
86 val
= readw(battery
->base
) & 0xfff;
88 if (battery
->pdata
->info
.voltage_max_design
<= 2500000)
89 val
= (val
* 78125UL) >> 7UL;
91 val
= ((val
* 924375UL) >> 9UL) + 33000;
94 voltage
= t
? t
: -ETIMEDOUT
;
97 battery
->cell
->disable(battery
->pdev
);
98 disable_irq(battery
->irq
);
100 mutex_unlock(&battery
->lock
);
105 static int jz_battery_get_capacity(struct power_supply
*psy
)
107 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
108 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
113 voltage
= jz_battery_read_voltage(jz_battery
);
118 voltage_span
= info
->voltage_max_design
- info
->voltage_min_design
;
119 ret
= ((voltage
- info
->voltage_min_design
) * 100) / voltage_span
;
129 static int jz_battery_get_property(struct power_supply
*psy
,
130 enum power_supply_property psp
, union power_supply_propval
*val
)
132 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
133 struct power_supply_info
*info
= &jz_battery
->pdata
->info
;
137 case POWER_SUPPLY_PROP_STATUS
:
138 val
->intval
= jz_battery
->status
;
140 case POWER_SUPPLY_PROP_TECHNOLOGY
:
141 val
->intval
= jz_battery
->pdata
->info
.technology
;
143 case POWER_SUPPLY_PROP_HEALTH
:
144 voltage
= jz_battery_read_voltage(jz_battery
);
145 if (voltage
< info
->voltage_min_design
)
146 val
->intval
= POWER_SUPPLY_HEALTH_DEAD
;
148 val
->intval
= POWER_SUPPLY_HEALTH_GOOD
;
150 case POWER_SUPPLY_PROP_CAPACITY
:
151 val
->intval
= jz_battery_get_capacity(psy
);
153 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
154 val
->intval
= jz_battery_read_voltage(jz_battery
);
158 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
159 val
->intval
= info
->voltage_max_design
;
161 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
162 val
->intval
= info
->voltage_min_design
;
164 case POWER_SUPPLY_PROP_PRESENT
:
173 static void jz_battery_external_power_changed(struct power_supply
*psy
)
175 struct jz_battery
*jz_battery
= psy_to_jz_battery(psy
);
177 mod_delayed_work(system_wq
, &jz_battery
->work
, 0);
180 static irqreturn_t
jz_battery_charge_irq(int irq
, void *data
)
182 struct jz_battery
*jz_battery
= data
;
184 mod_delayed_work(system_wq
, &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 jz_battery_probe(struct platform_device
*pdev
)
245 struct jz_battery_platform_data
*pdata
= pdev
->dev
.parent
->platform_data
;
246 struct power_supply_config psy_cfg
= {};
247 struct jz_battery
*jz_battery
;
248 struct power_supply_desc
*battery_desc
;
249 struct resource
*mem
;
252 dev_err(&pdev
->dev
, "No platform_data supplied\n");
256 jz_battery
= devm_kzalloc(&pdev
->dev
, sizeof(*jz_battery
), GFP_KERNEL
);
258 dev_err(&pdev
->dev
, "Failed to allocate driver structure\n");
262 jz_battery
->cell
= mfd_get_cell(pdev
);
264 jz_battery
->irq
= platform_get_irq(pdev
, 0);
265 if (jz_battery
->irq
< 0) {
266 dev_err(&pdev
->dev
, "Failed to get platform irq: %d\n", ret
);
267 return jz_battery
->irq
;
270 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
272 jz_battery
->base
= devm_ioremap_resource(&pdev
->dev
, mem
);
273 if (IS_ERR(jz_battery
->base
))
274 return PTR_ERR(jz_battery
->base
);
276 battery_desc
= &jz_battery
->battery_desc
;
277 battery_desc
->name
= pdata
->info
.name
;
278 battery_desc
->type
= POWER_SUPPLY_TYPE_BATTERY
;
279 battery_desc
->properties
= jz_battery_properties
;
280 battery_desc
->num_properties
= ARRAY_SIZE(jz_battery_properties
);
281 battery_desc
->get_property
= jz_battery_get_property
;
282 battery_desc
->external_power_changed
=
283 jz_battery_external_power_changed
;
284 battery_desc
->use_for_apm
= 1;
286 psy_cfg
.drv_data
= jz_battery
;
288 jz_battery
->pdata
= pdata
;
289 jz_battery
->pdev
= pdev
;
291 init_completion(&jz_battery
->read_completion
);
292 mutex_init(&jz_battery
->lock
);
294 INIT_DELAYED_WORK(&jz_battery
->work
, jz_battery_work
);
296 ret
= request_irq(jz_battery
->irq
, jz_battery_irq_handler
, 0, pdev
->name
,
299 dev_err(&pdev
->dev
, "Failed to request irq %d\n", ret
);
302 disable_irq(jz_battery
->irq
);
304 if (gpio_is_valid(pdata
->gpio_charge
)) {
305 ret
= gpio_request(pdata
->gpio_charge
, dev_name(&pdev
->dev
));
307 dev_err(&pdev
->dev
, "charger state gpio request failed.\n");
310 ret
= gpio_direction_input(pdata
->gpio_charge
);
312 dev_err(&pdev
->dev
, "charger state gpio set direction failed.\n");
316 jz_battery
->charge_irq
= gpio_to_irq(pdata
->gpio_charge
);
318 if (jz_battery
->charge_irq
>= 0) {
319 ret
= request_irq(jz_battery
->charge_irq
,
320 jz_battery_charge_irq
,
321 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
322 dev_name(&pdev
->dev
), jz_battery
);
324 dev_err(&pdev
->dev
, "Failed to request charge irq: %d\n", ret
);
329 jz_battery
->charge_irq
= -1;
332 if (jz_battery
->pdata
->info
.voltage_max_design
<= 2500000)
333 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
,
334 JZ_ADC_CONFIG_BAT_MB
);
336 jz4740_adc_set_config(pdev
->dev
.parent
, JZ_ADC_CONFIG_BAT_MB
, 0);
338 jz_battery
->battery
= power_supply_register(&pdev
->dev
, battery_desc
,
340 if (IS_ERR(jz_battery
->battery
)) {
341 dev_err(&pdev
->dev
, "power supply battery register failed.\n");
342 ret
= PTR_ERR(jz_battery
->battery
);
343 goto err_free_charge_irq
;
346 platform_set_drvdata(pdev
, jz_battery
);
347 schedule_delayed_work(&jz_battery
->work
, 0);
352 if (jz_battery
->charge_irq
>= 0)
353 free_irq(jz_battery
->charge_irq
, jz_battery
);
355 if (gpio_is_valid(pdata
->gpio_charge
))
356 gpio_free(jz_battery
->pdata
->gpio_charge
);
358 free_irq(jz_battery
->irq
, jz_battery
);
362 static int jz_battery_remove(struct platform_device
*pdev
)
364 struct jz_battery
*jz_battery
= platform_get_drvdata(pdev
);
366 cancel_delayed_work_sync(&jz_battery
->work
);
368 if (gpio_is_valid(jz_battery
->pdata
->gpio_charge
)) {
369 if (jz_battery
->charge_irq
>= 0)
370 free_irq(jz_battery
->charge_irq
, jz_battery
);
371 gpio_free(jz_battery
->pdata
->gpio_charge
);
374 power_supply_unregister(jz_battery
->battery
);
376 free_irq(jz_battery
->irq
, jz_battery
);
382 static int jz_battery_suspend(struct device
*dev
)
384 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
386 cancel_delayed_work_sync(&jz_battery
->work
);
387 jz_battery
->status
= POWER_SUPPLY_STATUS_UNKNOWN
;
392 static int jz_battery_resume(struct device
*dev
)
394 struct jz_battery
*jz_battery
= dev_get_drvdata(dev
);
396 schedule_delayed_work(&jz_battery
->work
, 0);
401 static const struct dev_pm_ops jz_battery_pm_ops
= {
402 .suspend
= jz_battery_suspend
,
403 .resume
= jz_battery_resume
,
406 #define JZ_BATTERY_PM_OPS (&jz_battery_pm_ops)
408 #define JZ_BATTERY_PM_OPS NULL
411 static struct platform_driver jz_battery_driver
= {
412 .probe
= jz_battery_probe
,
413 .remove
= jz_battery_remove
,
415 .name
= "jz4740-battery",
416 .pm
= JZ_BATTERY_PM_OPS
,
420 module_platform_driver(jz_battery_driver
);
422 MODULE_ALIAS("platform:jz4740-battery");
423 MODULE_LICENSE("GPL");
424 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
425 MODULE_DESCRIPTION("JZ4740 SoC battery driver");