hsist
/
freifunkist-firmware
6
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Cleanup battery driver

Browse Source 
SVN-Revision: 19505
master
Lars-Peter Clausen 15 years ago
parent 27a0d8478d
commit 4faa1ab58b
2 changed files with 200 additions and 184 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 374
      target/linux/xburst/files-2.6.32/drivers/power/jz4740-battery.c
  2. 10
      target/linux/xburst/files-2.6.32/include/linux/power/jz4740-battery.h

374
target/linux/xburst/files-2.6.32/drivers/power/jz4740-battery.c
Unescape View File

@ -1,11 +1,13 @@
/* /*
* Battery measurement code for Ingenic JZ SOC. * Battery measurement code for Ingenic JZ SOC.
* *
* Copyright (C) 2009 Jiejing Zhang <kzjeef@gmail.com>
* Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
*
* based on tosa_battery.c * based on tosa_battery.c
* *
* Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com> * Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
* Copyright (C) 2009 Jiejing Zhang <kzjeef@gmail.com> *
*
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as * it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation. * published by the Free Software Foundation.
@ -19,50 +21,56 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/gpio.h> #include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/power/jz4740-battery.h> #include <linux/power/jz4740-battery.h>
#include <linux/jz4740-adc.h> #include <linux/jz4740-adc.h>
struct jz_battery_info { struct jz_battery {
struct power_supply bat; struct jz_battery_platform_data *pdata;
int bat_status;
struct jz_batt_info *pdata; int charge_irq;
struct mutex work_lock;
struct workqueue_struct *monitor_wqueue;
struct delayed_work bat_work;
};
#define ps_to_jz_battery(x) container_of((x), struct jz_battery_info, bat); int status;
long voltage;
/********************************************************************* struct power_supply battery;
* Battery properties struct delayed_work work;
*********************************************************************/ };
static long jz_read_bat(struct power_supply *psy) static inline struct jz_battery *psy_to_jz_battery(struct power_supply *psy)
{ {
struct jz_battery_info *bat_info = ps_to_jz_battery(psy); return container_of(psy, struct jz_battery, battery);
}
static long jz_battery_read_voltage(struct jz_battery *jz_battery)
{
struct device *adc = jz_battery->battery.dev->parent->parent;
enum jz_adc_battery_scale scale; enum jz_adc_battery_scale scale;
if (bat_info->pdata->max_voltag > 2500000) if (jz_battery->pdata->info.voltage_max_design > 2500000)
scale = JZ_ADC_BATTERY_SCALE_7V5; scale = JZ_ADC_BATTERY_SCALE_7V5;
else else
scale = JZ_ADC_BATTERY_SCALE_2V5; scale = JZ_ADC_BATTERY_SCALE_2V5;
return jz4740_adc_read_battery_voltage(psy->dev->parent->parent, scale); return jz4740_adc_read_battery_voltage(adc, scale);
} }
static int jz_bat_get_capacity(struct power_supply *psy) static int jz_battery_get_capacity(struct power_supply *psy)
{ {
struct jz_battery *jz_battery = psy_to_jz_battery(psy);
struct power_supply_info *info = &jz_battery->pdata->info;
long voltage;
int ret; int ret;
struct jz_battery_info *bat_info = ps_to_jz_battery(psy); int voltage_span;
ret = jz_read_bat(psy); voltage = jz_battery_read_voltage(jz_battery);
if (ret < 0) if (voltage < 0)
return ret; return voltage;
ret = (ret - bat_info->pdata->min_voltag) * 100 voltage_span = info->voltage_max_design - info->voltage_min_design;
/ (bat_info->pdata->max_voltag - bat_info->pdata->min_voltag); ret = ((voltage - info->voltage_min_design) * 100) / voltage_span;
if (ret > 100) if (ret > 100)
ret = 100; ret = 100;
@ -72,46 +80,41 @@ static int jz_bat_get_capacity(struct power_supply *psy)
return ret; return ret;
} }
static int jz_bat_get_property(struct power_supply *psy, static int jz_battery_get_property(struct power_supply *psy,
enum power_supply_property psp, enum power_supply_property psp,
union power_supply_propval *val) union power_supply_propval *val)
{ {
struct jz_battery_info *bat_info = ps_to_jz_battery(psy) struct jz_battery *jz_battery = psy_to_jz_battery(psy);
struct power_supply_info *info = &jz_battery->pdata->info;
long voltage;
switch (psp) { switch (psp) {
case POWER_SUPPLY_PROP_STATUS: case POWER_SUPPLY_PROP_STATUS:
val->intval = bat_info->bat_status; val->intval = jz_battery->status;
break; break;
case POWER_SUPPLY_PROP_TECHNOLOGY: case POWER_SUPPLY_PROP_TECHNOLOGY:
val->intval = bat_info->pdata->batt_tech; val->intval = jz_battery->pdata->info.technology;
break; break;
case POWER_SUPPLY_PROP_HEALTH: case POWER_SUPPLY_PROP_HEALTH:
if(jz_read_bat(psy) < bat_info->pdata->min_voltag) { voltage = jz_battery_read_voltage(jz_battery);
dev_dbg(psy->dev, "%s: battery is dead," if (voltage < info->voltage_min_design)
"voltage too low!\n", __func__);
val->intval = POWER_SUPPLY_HEALTH_DEAD; val->intval = POWER_SUPPLY_HEALTH_DEAD;
} else { else
dev_dbg(psy->dev, "%s: battery is good,"
"voltage normal.\n", __func__);
val->intval = POWER_SUPPLY_HEALTH_GOOD; val->intval = POWER_SUPPLY_HEALTH_GOOD;
}
break; break;
case POWER_SUPPLY_PROP_CAPACITY: case POWER_SUPPLY_PROP_CAPACITY:
val->intval = jz_bat_get_capacity(psy); val->intval = jz_battery_get_capacity(psy);
dev_dbg(psy->dev, "%s: battery_capacity = %d\n",
__func__, val->intval);
break; break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW: case POWER_SUPPLY_PROP_VOLTAGE_NOW:
val->intval = jz_read_bat(psy); val->intval = jz_battery_read_voltage(jz_battery);
if (val->intval < 0) if (val->intval < 0)
return val->intval; return val->intval;
break; break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
val->intval = bat_info->pdata->max_voltag; val->intval = info->voltage_max_design;
break; break;
case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
val->intval = bat_info->pdata->min_voltag; val->intval = info->voltage_min_design;
break; break;
case POWER_SUPPLY_PROP_PRESENT: case POWER_SUPPLY_PROP_PRESENT:
val->intval = 1; val->intval = 1;
@ -122,210 +125,225 @@ static int jz_bat_get_property(struct power_supply *psy,
return 0; return 0;
} }
static void jz_bat_external_power_changed(struct power_supply *psy) static void jz_battery_external_power_changed(struct power_supply *psy)
{ {
struct jz_battery_info *bat_info = ps_to_jz_battery(psy); struct jz_battery *jz_battery = psy_to_jz_battery(psy);
cancel_delayed_work(&bat_info->bat_work); cancel_delayed_work(&jz_battery->work);
queue_delayed_work(bat_info->monitor_wqueue, &bat_info->bat_work, HZ / 8); schedule_delayed_work(&jz_battery->work, 0);
} }
static char *status_text[] = { static irqreturn_t jz_battery_charge_irq(int irq, void *data)
[POWER_SUPPLY_STATUS_UNKNOWN] = "Unknown", {
[POWER_SUPPLY_STATUS_CHARGING] = "Charging", struct jz_battery *jz_battery = data;
[POWER_SUPPLY_STATUS_DISCHARGING] = "Discharging",
[POWER_SUPPLY_STATUS_NOT_CHARGING] = "Not charging",
};
static void jz_bat_update(struct power_supply *psy) cancel_delayed_work(&jz_battery->work);
schedule_delayed_work(&jz_battery->work, 0);
return IRQ_HANDLED;
}
static void jz_battery_update(struct jz_battery *jz_battery)
{ {
struct jz_battery_info *bat_info = ps_to_jz_battery(psy); int status;
long voltage;
int old_status = bat_info->bat_status; long voltage_difference;
static unsigned long old_batt_vol = 0; bool has_changed = 0;
unsigned long batt_vol = jz_read_bat(psy);
if (gpio_is_valid(jz_battery->pdata->gpio_charge)) {
mutex_lock(&bat_info->work_lock); int is_charging;
if (gpio_is_valid(bat_info->pdata->charg_stat_gpio)) { is_charging = gpio_get_value(jz_battery->pdata->gpio_charge);
if(!gpio_get_value(bat_info->pdata->charg_stat_gpio)) is_charging ^= jz_battery->pdata->gpio_charge_active_low;
bat_info->bat_status = POWER_SUPPLY_STATUS_CHARGING; if (is_charging)
status = POWER_SUPPLY_STATUS_CHARGING;
else else
bat_info->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING; status = POWER_SUPPLY_STATUS_NOT_CHARGING;
dev_dbg(psy->dev, "%s: battery status=%s\n",
__func__, status_text[bat_info->bat_status]); if (status != jz_battery->status) {
jz_battery->status = status;
if (old_status != bat_info->bat_status) { has_changed = 1;
dev_dbg(psy->dev, "%s %s -> %s\n",
psy->name,
status_text[old_status],
status_text[bat_info->bat_status]);
power_supply_changed(psy);
} }
} }
if (old_batt_vol - batt_vol > 50000) { voltage = jz_battery_read_voltage(jz_battery);
dev_dbg(psy->dev, "voltage change : %ld -> %ld\n", voltage_difference = voltage - jz_battery->voltage;
old_batt_vol, batt_vol); if (voltage_difference > 50000 || voltage_difference < 50000) {
power_supply_changed(psy); jz_battery->voltage = voltage;
old_batt_vol = batt_vol; has_changed = 1;
} }
if (has_changed)
mutex_unlock(&bat_info->work_lock); power_supply_changed(&jz_battery->battery);
} }
static enum power_supply_property jz_bat_main_props[] = { static enum power_supply_property jz_battery_properties[] = {
POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_TECHNOLOGY, POWER_SUPPLY_PROP_TECHNOLOGY,
POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_CAPACITY, /* in percents! */ POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_PRESENT,
}; };
struct power_supply bat_ps = { static void jz_battery_work(struct work_struct *work)
.name = "battery",
.type = POWER_SUPPLY_TYPE_BATTERY,
.properties = jz_bat_main_props,
.num_properties = ARRAY_SIZE(jz_bat_main_props),
.get_property = jz_bat_get_property,
.external_power_changed = jz_bat_external_power_changed,
.use_for_apm = 1,
};
static void jz_bat_work(struct work_struct *work)
{ {
/* query interval too small will increase system workload*/ /* Too small interval will increase system workload */
const int interval = HZ * 30; const int interval = HZ * 30;
struct jz_battery_info *bat_info = container_of(work,struct jz_battery_info, bat_work.work); struct jz_battery *jz_battery = container_of(work, struct jz_battery,
work.work);
jz_bat_update(&bat_info->bat);
queue_delayed_work(bat_info->monitor_wqueue,
&bat_info->bat_work, interval);
}
#ifdef CONFIG_PM
static int jz_bat_suspend(struct platform_device *pdev, pm_message_t state)
{
struct jz_battery_info *bat_info = platform_get_drvdata(pdev);
bat_info->bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
return 0;
}
static int jz_bat_resume(struct platform_device *pdev)
{
struct jz_battery_info *bat_info = platform_get_drvdata(pdev);
bat_info->bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
cancel_delayed_work(&bat_info->bat_work);
queue_delayed_work(bat_info->monitor_wqueue, &bat_info->bat_work, HZ/10);
return 0; jz_battery_update(jz_battery);
schedule_delayed_work(&jz_battery->work, interval);
} }
#else
#define jz_bat_suspend NULL
#define jz_bat_resume NULL
#endif
static int jz_bat_probe(struct platform_device *pdev) static int jz_battery_probe(struct platform_device *pdev)
{ {
int ret = 0; int ret = 0;
struct jz_battery_info *bat_info; struct jz_battery_platform_data *pdata = pdev->dev.platform_data;
struct jz_battery *jz_battery;
struct power_supply *battery;
if (!pdev->dev.platform_data) { if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "Please set battery info\n"); dev_err(&pdev->dev, "No platform data\n");
return -EINVAL; return -EINVAL;
} }
bat_info = kzalloc(sizeof(struct jz_battery_info), GFP_KERNEL); jz_battery = kzalloc(sizeof(*jz_battery), GFP_KERNEL);
if (!bat_info) { if (!jz_battery) {
dev_err(&pdev->dev, "Failed to allocate driver structure\n");
return -ENOMEM; return -ENOMEM;
} }
platform_set_drvdata(pdev, bat_info); battery = &jz_battery->battery;
bat_info->pdata = pdev->dev.platform_data; battery->name = pdata->info.name;
bat_info->bat = bat_ps; battery->type = POWER_SUPPLY_TYPE_BATTERY;
mutex_init(&bat_info->work_lock); battery->properties = jz_battery_properties;
INIT_DELAYED_WORK(&bat_info->bat_work, jz_bat_work); battery->num_properties = ARRAY_SIZE(jz_battery_properties);
battery->get_property = jz_battery_get_property;
battery->external_power_changed = jz_battery_external_power_changed;
battery->use_for_apm = 1;
jz_battery->pdata = pdata;
if (gpio_is_valid(bat_info->pdata->charg_stat_gpio)) { INIT_DELAYED_WORK(&jz_battery->work, jz_battery_work);
ret = gpio_request(bat_info->pdata->charg_stat_gpio, "CHARG STAT");
if (gpio_is_valid(pdata->gpio_charge)) {
ret = gpio_request(pdata->gpio_charge, dev_name(&pdev->dev));
if (ret) { if (ret) {
dev_err(&pdev->dev, "charger state gpio request failed.\n"); dev_err(&pdev->dev, "charger state gpio request failed.\n");
goto err_charg_gpio_request; goto err_free;
} }
ret = gpio_direction_input(bat_info->pdata->charg_stat_gpio); ret = gpio_direction_input(pdata->gpio_charge);
if (ret) { if (ret) {
dev_err(&pdev->dev, "charger state gpio set direction failed.\n"); dev_err(&pdev->dev, "charger state gpio set direction failed.\n");
goto err_charg_gpio_direction; goto err_free_gpio;
} }
ret = power_supply_register(&pdev->dev, &bat_info->bat); jz_battery->charge_irq = gpio_to_irq(pdata->gpio_charge);
if (ret) {
dev_err(&pdev->dev, "power supply battery register failed.\n"); if (jz_battery->charge_irq >= 0) {
goto err_power_register_bat; ret = request_irq(jz_battery->charge_irq,
} else { jz_battery_charge_irq,
bat_info->monitor_wqueue = create_singlethread_workqueue("jz_battery"); IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
if (!bat_info->monitor_wqueue) { dev_name(&pdev->dev), jz_battery);
return -ESRCH; if (ret) {
dev_err(&pdev->dev, "Failed to request charge irq: %d\n", ret);
goto err_free_gpio;
} }
queue_delayed_work(bat_info->monitor_wqueue, &bat_info->bat_work, HZ * 1);
} }
} else {
jz_battery->charge_irq = -1;
} }
printk(KERN_INFO "jz_bat init success.\n");
return ret;
err_power_register_bat:
err_charg_gpio_direction: ret = power_supply_register(&pdev->dev, &jz_battery->battery);
gpio_free(bat_info->pdata->charg_stat_gpio); if (ret) {
err_charg_gpio_request: dev_err(&pdev->dev, "power supply battery register failed.\n");
kfree(bat_info); goto err_free_irq;
}
platform_set_drvdata(pdev, jz_battery);
schedule_delayed_work(&jz_battery->work, 0);
return 0;
err_free_irq:
if (jz_battery->charge_irq >= 0)
free_irq(jz_battery->charge_irq, jz_battery);
err_free_gpio:
if (gpio_is_valid(pdata->gpio_charge))
gpio_free(jz_battery->pdata->gpio_charge);
err_free:
kfree(jz_battery);
return ret; return ret;
} }
static int jz_bat_remove(struct platform_device *pdev) static int jz_battery_remove(struct platform_device *pdev)
{ {
struct jz_battery_info *bat_info = platform_get_drvdata(pdev); struct jz_battery *jz_battery = platform_get_drvdata(pdev);
if (bat_info->pdata) { cancel_delayed_work_sync(&jz_battery->work);
if (gpio_is_valid(bat_info->pdata->charg_stat_gpio))
gpio_free(bat_info->pdata->charg_stat_gpio); if (gpio_is_valid(jz_battery->pdata->gpio_charge)) {
if (jz_battery->charge_irq >= 0)
free_irq(jz_battery->charge_irq, jz_battery);
gpio_free(jz_battery->pdata->gpio_charge);
} }
power_supply_unregister(&bat_ps); power_supply_unregister(&jz_battery->battery);
return 0;
}
#ifdef CONFIG_PM
static int jz_battery_suspend(struct platform_device *pdev, pm_message_t state)
{
struct jz_battery *jz_battery = platform_get_drvdata(pdev);
cancel_delayed_work_sync(&jz_battery->work);
jz_battery->status = POWER_SUPPLY_STATUS_UNKNOWN;
return 0; return 0;
} }
static struct platform_driver jz_bat_driver = { static int jz_battery_resume(struct platform_device *pdev)
.probe = jz_bat_probe, {
.remove = __devexit_p(jz_bat_remove), struct jz_battery *jz_battery = platform_get_drvdata(pdev);
.suspend = jz_bat_suspend,
.resume = jz_bat_resume, schedule_delayed_work(&jz_battery->work, 0);
return 0;
}
#else
#define jz_battery_suspend NULL
#define jz_battery_resume NULL
#endif
static struct platform_driver jz_battery_driver = {
.probe = jz_battery_probe,
.remove = __devexit_p(jz_battery_remove),
.suspend = jz_battery_suspend,
.resume = jz_battery_resume,
.driver = { .driver = {
.name = "jz4740-battery", .name = "jz4740-battery",
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
}; };
static int __init jz_bat_init(void) static int __init jz_battery_init(void)
{ {
return platform_driver_register(&jz_bat_driver); return platform_driver_register(&jz_battery_driver);
} }
module_init(jz_bat_init); module_init(jz_battery_init);
static void __exit jz_bat_exit(void) static void __exit jz_battery_exit(void)
{ {
platform_driver_unregister(&jz_bat_driver); platform_driver_unregister(&jz_battery_driver);
} }
module_exit(jz_bat_exit); module_exit(jz_battery_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jiejing Zhang <kzjeef@gmail.com>"); MODULE_AUTHOR("Jiejing Zhang <kzjeef@gmail.com>");

10
target/linux/xburst/files-2.6.32/include/linux/power/jz4740-battery.h
Unescape View File

@ -15,12 +15,10 @@
#ifndef __JZ4740_BATTERY_H #ifndef __JZ4740_BATTERY_H
#define __JZ4740_BATTERY_H #define __JZ4740_BATTERY_H
struct jz_batt_info { struct jz_battery_platform_data {
int charg_stat_gpio; /* GPIO port of Charger state */ struct power_supply_info info;
int gpio_charge; /* GPIO port of Charger state */
int min_voltag; /* Mininal battery voltage in uV */ int gpio_charge_active_low;
int max_voltag; /* Maximum battery voltage in uV */
int batt_tech; /* Battery technology */
}; };
#endif #endif

Write Preview
Loading…
Cancel
Save