URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [power/] [ds2760_battery.c] - Blame information for rev 79

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Driver for batteries with DS2760 chips inside.
 *
 * Copyright © 2007 Anton Vorontsov
 *             2004-2007 Matt Reimer
 *             2004 Szabolcs Gyurko
 *
 * Use consistent with the GNU GPL is permitted,
 * provided that this copyright notice is
 * preserved in its entirety in all copies and derived works.
 *
 * Author:  Anton Vorontsov <cbou@mail.ru>
 *          February 2007
 *
 *          Matt Reimer <mreimer@vpop.net>
 *          April 2004, 2005, 2007
 *
 *          Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
 *          September 2004
 */
 
#include <linux/module.h>
#include <linux/param.h>
#include <linux/jiffies.h>
#include <linux/workqueue.h>
#include <linux/pm.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
 
#include "../w1/w1.h"
#include "../w1/slaves/w1_ds2760.h"
 
struct ds2760_device_info {
        struct device *dev;
 
        /* DS2760 data, valid after calling ds2760_battery_read_status() */
        unsigned long update_time;      /* jiffies when data read */
        char raw[DS2760_DATA_SIZE];     /* raw DS2760 data */
        int voltage_raw;                /* units of 4.88 mV */
        int voltage_uV;                 /* units of µV */
        int current_raw;                /* units of 0.625 mA */
        int current_uA;                 /* units of µA */
        int accum_current_raw;          /* units of 0.25 mAh */
        int accum_current_uAh;          /* units of µAh */
        int temp_raw;                   /* units of 0.125 °C */
        int temp_C;                     /* units of 0.1 °C */
        int rated_capacity;             /* units of µAh */
        int rem_capacity;               /* percentage */
        int full_active_uAh;            /* units of µAh */
        int empty_uAh;                  /* units of µAh */
        int life_sec;                   /* units of seconds */
        int charge_status;              /* POWER_SUPPLY_STATUS_* */
 
        int full_counter;
        struct power_supply bat;
        struct device *w1_dev;
        struct workqueue_struct *monitor_wqueue;
        struct delayed_work monitor_work;
};
 
static unsigned int cache_time = 1000;
module_param(cache_time, uint, 0644);
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 
/* Some batteries have their rated capacity stored a N * 10 mAh, while
 * others use an index into this table. */
static int rated_capacities[] = {
        0,
        920,    /* Samsung */
        920,    /* BYD */
        920,    /* Lishen */
        920,    /* NEC */
        1440,   /* Samsung */
        1440,   /* BYD */
        1440,   /* Lishen */
        1440,   /* NEC */
        2880,   /* Samsung */
        2880,   /* BYD */
        2880,   /* Lishen */
        2880    /* NEC */
};
 
/* array is level at temps 0°C, 10°C, 20°C, 30°C, 40°C
 * temp is in Celsius */
static int battery_interpolate(int array[], int temp)
{
        int index, dt;
 
        if (temp <= 0)
                return array[0];
        if (temp >= 40)
                return array[4];
 
        index = temp / 10;
        dt    = temp % 10;
 
        return array[index] + (((array[index + 1] - array[index]) * dt) / 10);
}
 
static int ds2760_battery_read_status(struct ds2760_device_info *di)
{
        int ret, i, start, count, scale[5];
 
        if (di->update_time && time_before(jiffies, di->update_time +
                                           msecs_to_jiffies(cache_time)))
                return 0;
 
        /* The first time we read the entire contents of SRAM/EEPROM,
         * but after that we just read the interesting bits that change. */
        if (di->update_time == 0) {
                start = 0;
                count = DS2760_DATA_SIZE;
        } else {
                start = DS2760_VOLTAGE_MSB;
                count = DS2760_TEMP_LSB - start + 1;
        }
 
        ret = w1_ds2760_read(di->w1_dev, di->raw + start, start, count);
        if (ret != count) {
                dev_warn(di->dev, "call to w1_ds2760_read failed (0x%p)\n",
                         di->w1_dev);
                return 1;
        }
 
        di->update_time = jiffies;
 
        /* DS2760 reports voltage in units of 4.88mV, but the battery class
         * reports in units of uV, so convert by multiplying by 4880. */
        di->voltage_raw = (di->raw[DS2760_VOLTAGE_MSB] << 3) |
                          (di->raw[DS2760_VOLTAGE_LSB] >> 5);
        di->voltage_uV = di->voltage_raw * 4880;
 
        /* DS2760 reports current in signed units of 0.625mA, but the battery
         * class reports in units of µA, so convert by multiplying by 625. */
        di->current_raw =
            (((signed char)di->raw[DS2760_CURRENT_MSB]) << 5) |
                          (di->raw[DS2760_CURRENT_LSB] >> 3);
        di->current_uA = di->current_raw * 625;
 
        /* DS2760 reports accumulated current in signed units of 0.25mAh. */
        di->accum_current_raw =
            (((signed char)di->raw[DS2760_CURRENT_ACCUM_MSB]) << 8) |
                           di->raw[DS2760_CURRENT_ACCUM_LSB];
        di->accum_current_uAh = di->accum_current_raw * 250;
 
        /* DS2760 reports temperature in signed units of 0.125°C, but the
         * battery class reports in units of 1/10 °C, so we convert by
         * multiplying by .125 * 10 = 1.25. */
        di->temp_raw = (((signed char)di->raw[DS2760_TEMP_MSB]) << 3) |
                                     (di->raw[DS2760_TEMP_LSB] >> 5);
        di->temp_C = di->temp_raw + (di->temp_raw / 4);
 
        /* At least some battery monitors (e.g. HP iPAQ) store the battery's
         * maximum rated capacity. */
        if (di->raw[DS2760_RATED_CAPACITY] < ARRAY_SIZE(rated_capacities))
                di->rated_capacity = rated_capacities[
                        (unsigned int)di->raw[DS2760_RATED_CAPACITY]];
        else
                di->rated_capacity = di->raw[DS2760_RATED_CAPACITY] * 10;
 
        di->rated_capacity *= 1000; /* convert to µAh */
 
        /* Calculate the full level at the present temperature. */
        di->full_active_uAh = di->raw[DS2760_ACTIVE_FULL] << 8 |
                              di->raw[DS2760_ACTIVE_FULL + 1];
 
        scale[0] = di->raw[DS2760_ACTIVE_FULL] << 8 |
                   di->raw[DS2760_ACTIVE_FULL + 1];
        for (i = 1; i < 5; i++)
                scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 2 + i];
 
        di->full_active_uAh = battery_interpolate(scale, di->temp_C / 10);
        di->full_active_uAh *= 1000; /* convert to µAh */
 
        /* Calculate the empty level at the present temperature. */
        scale[4] = di->raw[DS2760_ACTIVE_EMPTY + 4];
        for (i = 3; i >= 0; i--)
                scale[i] = scale[i + 1] + di->raw[DS2760_ACTIVE_EMPTY + i];
 
        di->empty_uAh = battery_interpolate(scale, di->temp_C / 10);
        di->empty_uAh *= 1000; /* convert to µAh */
 
        /* From Maxim Application Note 131: remaining capacity =
         * ((ICA - Empty Value) / (Full Value - Empty Value)) x 100% */
        di->rem_capacity = ((di->accum_current_uAh - di->empty_uAh) * 100L) /
                            (di->full_active_uAh - di->empty_uAh);
 
        if (di->rem_capacity < 0)
                di->rem_capacity = 0;
        if (di->rem_capacity > 100)
                di->rem_capacity = 100;
 
        if (di->current_uA)
                di->life_sec = -((di->accum_current_uAh - di->empty_uAh) *
                                 3600L) / di->current_uA;
        else
                di->life_sec = 0;
 
        return 0;
}
 
static void ds2760_battery_update_status(struct ds2760_device_info *di)
{
        int old_charge_status = di->charge_status;
 
        ds2760_battery_read_status(di);
 
        if (di->charge_status == POWER_SUPPLY_STATUS_UNKNOWN)
                di->full_counter = 0;
 
        if (power_supply_am_i_supplied(&di->bat)) {
                if (di->current_uA > 10000) {
                        di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
                        di->full_counter = 0;
                } else if (di->current_uA < -5000) {
                        if (di->charge_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
                                dev_notice(di->dev, "not enough power to "
                                           "charge\n");
                        di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
                        di->full_counter = 0;
                } else if (di->current_uA < 10000 &&
                            di->charge_status != POWER_SUPPLY_STATUS_FULL) {
 
                        /* Don't consider the battery to be full unless
                         * we've seen the current < 10 mA at least two
                         * consecutive times. */
 
                        di->full_counter++;
 
                        if (di->full_counter < 2) {
                                di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
                        } else {
                                unsigned char acr[2];
                                int acr_val;
 
                                /* acr is in units of 0.25 mAh */
                                acr_val = di->full_active_uAh * 4L / 1000;
 
                                acr[0] = acr_val >> 8;
                                acr[1] = acr_val & 0xff;
 
                                if (w1_ds2760_write(di->w1_dev, acr,
                                    DS2760_CURRENT_ACCUM_MSB, 2) < 2)
                                        dev_warn(di->dev,
                                                 "ACR reset failed\n");
 
                                di->charge_status = POWER_SUPPLY_STATUS_FULL;
                        }
                }
        } else {
                di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
                di->full_counter = 0;
        }
 
        if (di->charge_status != old_charge_status)
                power_supply_changed(&di->bat);
}
 
static void ds2760_battery_work(struct work_struct *work)
{
        struct ds2760_device_info *di = container_of(work,
                struct ds2760_device_info, monitor_work.work);
        const int interval = HZ * 60;
 
        dev_dbg(di->dev, "%s\n", __FUNCTION__);
 
        ds2760_battery_update_status(di);
        queue_delayed_work(di->monitor_wqueue, &di->monitor_work, interval);
}
 
#define to_ds2760_device_info(x) container_of((x), struct ds2760_device_info, \
                                              bat);
 
static void ds2760_battery_external_power_changed(struct power_supply *psy)
{
        struct ds2760_device_info *di = to_ds2760_device_info(psy);
 
        dev_dbg(di->dev, "%s\n", __FUNCTION__);
 
        cancel_delayed_work(&di->monitor_work);
        queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ/10);
}
 
static int ds2760_battery_get_property(struct power_supply *psy,
                                       enum power_supply_property psp,
                                       union power_supply_propval *val)
{
        struct ds2760_device_info *di = to_ds2760_device_info(psy);
 
        switch (psp) {
        case POWER_SUPPLY_PROP_STATUS:
                val->intval = di->charge_status;
                return 0;
        default:
                break;
        }
 
        ds2760_battery_read_status(di);
 
        switch (psp) {
        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
                val->intval = di->voltage_uV;
                break;
        case POWER_SUPPLY_PROP_CURRENT_NOW:
                val->intval = di->current_uA;
                break;
        case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
                val->intval = di->rated_capacity;
                break;
        case POWER_SUPPLY_PROP_CHARGE_FULL:
                val->intval = di->full_active_uAh;
                break;
        case POWER_SUPPLY_PROP_CHARGE_EMPTY:
                val->intval = di->empty_uAh;
                break;
        case POWER_SUPPLY_PROP_CHARGE_NOW:
                val->intval = di->accum_current_uAh;
                break;
        case POWER_SUPPLY_PROP_TEMP:
                val->intval = di->temp_C;
                break;
        default:
                return -EINVAL;
        }
 
        return 0;
}
 
static enum power_supply_property ds2760_battery_props[] = {
        POWER_SUPPLY_PROP_STATUS,
        POWER_SUPPLY_PROP_VOLTAGE_NOW,
        POWER_SUPPLY_PROP_CURRENT_NOW,
        POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
        POWER_SUPPLY_PROP_CHARGE_FULL,
        POWER_SUPPLY_PROP_CHARGE_EMPTY,
        POWER_SUPPLY_PROP_CHARGE_NOW,
        POWER_SUPPLY_PROP_TEMP,
};
 
static int ds2760_battery_probe(struct platform_device *pdev)
{
        int retval = 0;
        struct ds2760_device_info *di;
        struct ds2760_platform_data *pdata;
 
        di = kzalloc(sizeof(*di), GFP_KERNEL);
        if (!di) {
                retval = -ENOMEM;
                goto di_alloc_failed;
        }
 
        platform_set_drvdata(pdev, di);
 
        pdata = pdev->dev.platform_data;
        di->dev         = &pdev->dev;
        di->w1_dev           = pdev->dev.parent;
        di->bat.name       = pdev->dev.bus_id;
        di->bat.type       = POWER_SUPPLY_TYPE_BATTERY;
        di->bat.properties     = ds2760_battery_props;
        di->bat.num_properties = ARRAY_SIZE(ds2760_battery_props);
        di->bat.get_property   = ds2760_battery_get_property;
        di->bat.external_power_changed =
                                  ds2760_battery_external_power_changed;
 
        di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
 
        retval = power_supply_register(&pdev->dev, &di->bat);
        if (retval) {
                dev_err(di->dev, "failed to register battery\n");
                goto batt_failed;
        }
 
        INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
        di->monitor_wqueue = create_singlethread_workqueue(pdev->dev.bus_id);
        if (!di->monitor_wqueue) {
                retval = -ESRCH;
                goto workqueue_failed;
        }
        queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ * 1);
 
        goto success;
 
workqueue_failed:
        power_supply_unregister(&di->bat);
batt_failed:
        kfree(di);
di_alloc_failed:
success:
        return retval;
}
 
static int ds2760_battery_remove(struct platform_device *pdev)
{
        struct ds2760_device_info *di = platform_get_drvdata(pdev);
 
        cancel_rearming_delayed_workqueue(di->monitor_wqueue,
                                          &di->monitor_work);
        destroy_workqueue(di->monitor_wqueue);
        power_supply_unregister(&di->bat);
 
        return 0;
}
 
#ifdef CONFIG_PM
 
static int ds2760_battery_suspend(struct platform_device *pdev,
                                  pm_message_t state)
{
        struct ds2760_device_info *di = platform_get_drvdata(pdev);
 
        di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
 
        return 0;
}
 
static int ds2760_battery_resume(struct platform_device *pdev)
{
        struct ds2760_device_info *di = platform_get_drvdata(pdev);
 
        di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
        power_supply_changed(&di->bat);
 
        cancel_delayed_work(&di->monitor_work);
        queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ);
 
        return 0;
}
 
#else
 
#define ds2760_battery_suspend NULL
#define ds2760_battery_resume NULL
 
#endif /* CONFIG_PM */
 
static struct platform_driver ds2760_battery_driver = {
        .driver = {
                .name = "ds2760-battery",
        },
        .probe    = ds2760_battery_probe,
        .remove   = ds2760_battery_remove,
        .suspend  = ds2760_battery_suspend,
        .resume   = ds2760_battery_resume,
};
 
static int __init ds2760_battery_init(void)
{
        return platform_driver_register(&ds2760_battery_driver);
}
 
static void __exit ds2760_battery_exit(void)
{
        platform_driver_unregister(&ds2760_battery_driver);
}
 
module_init(ds2760_battery_init);
module_exit(ds2760_battery_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>, "
              "Matt Reimer <mreimer@vpop.net>, "
              "Anton Vorontsov <cbou@mail.ru>");
MODULE_DESCRIPTION("ds2760 battery driver");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [power/] [ds2760_battery.c] - Blame information for rev 79

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Driver for batteries with DS2760 chips inside.`
3			`*`
4			`* Copyright © 2007 Anton Vorontsov`
5			`* 2004-2007 Matt Reimer`
6			`* 2004 Szabolcs Gyurko`
7			`*`
8			`* Use consistent with the GNU GPL is permitted,`
9			`* provided that this copyright notice is`
10			`* preserved in its entirety in all copies and derived works.`
11			`*`
12			`* Author: Anton Vorontsov <cbou@mail.ru>`
13			`* February 2007`
14			`*`
15			`* Matt Reimer <mreimer@vpop.net>`
16			`* April 2004, 2005, 2007`
17			`*`
18			`* Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>`
19			`* September 2004`
20			`*/`
21
22			`#include <linux/module.h>`
23			`#include <linux/param.h>`
24			`#include <linux/jiffies.h>`
25			`#include <linux/workqueue.h>`
26			`#include <linux/pm.h>`
27			`#include <linux/platform_device.h>`
28			`#include <linux/power_supply.h>`
29
30			`#include "../w1/w1.h"`
31			`#include "../w1/slaves/w1_ds2760.h"`
32
33			`struct ds2760_device_info {`
34			`struct device *dev;`
35
36			`/* DS2760 data, valid after calling ds2760_battery_read_status() */`
37			`unsigned long update_time; /* jiffies when data read */`
38			`char raw[DS2760_DATA_SIZE]; /* raw DS2760 data */`
39			`int voltage_raw; /* units of 4.88 mV */`
40			`int voltage_uV; /* units of µV */`
41			`int current_raw; /* units of 0.625 mA */`
42			`int current_uA; /* units of µA */`
43			`int accum_current_raw; /* units of 0.25 mAh */`
44			`int accum_current_uAh; /* units of µAh */`
45			`int temp_raw; /* units of 0.125 °C */`
46			`int temp_C; /* units of 0.1 °C */`
47			`int rated_capacity; /* units of µAh */`
48			`int rem_capacity; /* percentage */`
49			`int full_active_uAh; /* units of µAh */`
50			`int empty_uAh; /* units of µAh */`
51			`int life_sec; /* units of seconds */`
52			`int charge_status; /* POWER_SUPPLY_STATUS_* */`
53
54			`int full_counter;`
55			`struct power_supply bat;`
56			`struct device *w1_dev;`
57			`struct workqueue_struct *monitor_wqueue;`
58			`struct delayed_work monitor_work;`
59			`};`
60
61			`static unsigned int cache_time = 1000;`
62			`module_param(cache_time, uint, 0644);`
63			`MODULE_PARM_DESC(cache_time, "cache time in milliseconds");`
64
65			`/* Some batteries have their rated capacity stored a N * 10 mAh, while`
66			`* others use an index into this table. */`
67			`static int rated_capacities[] = {`
68			`0,`
69			`920, /* Samsung */`
70			`920, /* BYD */`
71			`920, /* Lishen */`
72			`920, /* NEC */`
73			`1440, /* Samsung */`
74			`1440, /* BYD */`
75			`1440, /* Lishen */`
76			`1440, /* NEC */`
77			`2880, /* Samsung */`
78			`2880, /* BYD */`
79			`2880, /* Lishen */`
80			`2880 /* NEC */`
81			`};`
82
83			`/* array is level at temps 0°C, 10°C, 20°C, 30°C, 40°C`
84			`* temp is in Celsius */`
85			`static int battery_interpolate(int array[], int temp)`
86			`{`
87			`int index, dt;`
88
89			`if (temp <= 0)`
90			`return array[0];`
91			`if (temp >= 40)`
92			`return array[4];`
93
94			`index = temp / 10;`
95			`dt = temp % 10;`
96
97			`return array[index] + (((array[index + 1] - array[index]) * dt) / 10);`
98			`}`
99
100			`static int ds2760_battery_read_status(struct ds2760_device_info *di)`
101			`{`
102			`int ret, i, start, count, scale[5];`
103
104			`if (di->update_time && time_before(jiffies, di->update_time +`
105			`msecs_to_jiffies(cache_time)))`
106			`return 0;`
107
108			`/* The first time we read the entire contents of SRAM/EEPROM,`
109			`* but after that we just read the interesting bits that change. */`
110			`if (di->update_time == 0) {`
111			`start = 0;`
112			`count = DS2760_DATA_SIZE;`
113			`} else {`
114			`start = DS2760_VOLTAGE_MSB;`
115			`count = DS2760_TEMP_LSB - start + 1;`
116			`}`
117
118			`ret = w1_ds2760_read(di->w1_dev, di->raw + start, start, count);`
119			`if (ret != count) {`
120			`dev_warn(di->dev, "call to w1_ds2760_read failed (0x%p)\n",`
121			`di->w1_dev);`
122			`return 1;`
123			`}`
124
125			`di->update_time = jiffies;`
126
127			`/* DS2760 reports voltage in units of 4.88mV, but the battery class`
128			`* reports in units of uV, so convert by multiplying by 4880. */`
129			`di->voltage_raw = (di->raw[DS2760_VOLTAGE_MSB] << 3) \|`
130			`(di->raw[DS2760_VOLTAGE_LSB] >> 5);`
131			`di->voltage_uV = di->voltage_raw * 4880;`
132
133			`/* DS2760 reports current in signed units of 0.625mA, but the battery`
134			`* class reports in units of µA, so convert by multiplying by 625. */`
135			`di->current_raw =`
136			`(((signed char)di->raw[DS2760_CURRENT_MSB]) << 5) \|`
137			`(di->raw[DS2760_CURRENT_LSB] >> 3);`
138			`di->current_uA = di->current_raw * 625;`
139
140			`/* DS2760 reports accumulated current in signed units of 0.25mAh. */`
141			`di->accum_current_raw =`
142			`(((signed char)di->raw[DS2760_CURRENT_ACCUM_MSB]) << 8) \|`
143			`di->raw[DS2760_CURRENT_ACCUM_LSB];`
144			`di->accum_current_uAh = di->accum_current_raw * 250;`
145
146			`/* DS2760 reports temperature in signed units of 0.125°C, but the`
147			`* battery class reports in units of 1/10 °C, so we convert by`
148			`* multiplying by .125 * 10 = 1.25. */`
149			`di->temp_raw = (((signed char)di->raw[DS2760_TEMP_MSB]) << 3) \|`
150			`(di->raw[DS2760_TEMP_LSB] >> 5);`
151			`di->temp_C = di->temp_raw + (di->temp_raw / 4);`
152
153			`/* At least some battery monitors (e.g. HP iPAQ) store the battery's`
154			`* maximum rated capacity. */`
155			`if (di->raw[DS2760_RATED_CAPACITY] < ARRAY_SIZE(rated_capacities))`
156			`di->rated_capacity = rated_capacities[`
157			`(unsigned int)di->raw[DS2760_RATED_CAPACITY]];`
158			`else`
159			`di->rated_capacity = di->raw[DS2760_RATED_CAPACITY] * 10;`
160
161			`di->rated_capacity = 1000; / convert to µAh */`
162
163			`/* Calculate the full level at the present temperature. */`
164			`di->full_active_uAh = di->raw[DS2760_ACTIVE_FULL] << 8 \|`
165			`di->raw[DS2760_ACTIVE_FULL + 1];`
166
167			`scale[0] = di->raw[DS2760_ACTIVE_FULL] << 8 \|`
168			`di->raw[DS2760_ACTIVE_FULL + 1];`
169			`for (i = 1; i < 5; i++)`
170			`scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 2 + i];`
171
172			`di->full_active_uAh = battery_interpolate(scale, di->temp_C / 10);`
173			`di->full_active_uAh = 1000; / convert to µAh */`
174
175			`/* Calculate the empty level at the present temperature. */`
176			`scale[4] = di->raw[DS2760_ACTIVE_EMPTY + 4];`
177			`for (i = 3; i >= 0; i--)`
178			`scale[i] = scale[i + 1] + di->raw[DS2760_ACTIVE_EMPTY + i];`
179
180			`di->empty_uAh = battery_interpolate(scale, di->temp_C / 10);`
181			`di->empty_uAh = 1000; / convert to µAh */`
182
183			`/* From Maxim Application Note 131: remaining capacity =`
184			`* ((ICA - Empty Value) / (Full Value - Empty Value)) x 100% */`
185			`di->rem_capacity = ((di->accum_current_uAh - di->empty_uAh) * 100L) /`
186			`(di->full_active_uAh - di->empty_uAh);`
187
188			`if (di->rem_capacity < 0)`
189			`di->rem_capacity = 0;`
190			`if (di->rem_capacity > 100)`
191			`di->rem_capacity = 100;`
192
193			`if (di->current_uA)`
194			`di->life_sec = -((di->accum_current_uAh - di->empty_uAh) *`
195			`3600L) / di->current_uA;`
196			`else`
197			`di->life_sec = 0;`
198
199			`return 0;`
200			`}`
201
202			`static void ds2760_battery_update_status(struct ds2760_device_info *di)`
203			`{`
204			`int old_charge_status = di->charge_status;`
205
206			`ds2760_battery_read_status(di);`
207
208			`if (di->charge_status == POWER_SUPPLY_STATUS_UNKNOWN)`
209			`di->full_counter = 0;`
210
211			`if (power_supply_am_i_supplied(&di->bat)) {`
212			`if (di->current_uA > 10000) {`
213			`di->charge_status = POWER_SUPPLY_STATUS_CHARGING;`
214			`di->full_counter = 0;`
215			`} else if (di->current_uA < -5000) {`
216			`if (di->charge_status != POWER_SUPPLY_STATUS_NOT_CHARGING)`
217			`dev_notice(di->dev, "not enough power to "`
218			`"charge\n");`
219			`di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;`
220			`di->full_counter = 0;`
221			`} else if (di->current_uA < 10000 &&`
222			`di->charge_status != POWER_SUPPLY_STATUS_FULL) {`
223
224			`/* Don't consider the battery to be full unless`
225			`* we've seen the current < 10 mA at least two`
226			`* consecutive times. */`
227
228			`di->full_counter++;`
229
230			`if (di->full_counter < 2) {`
231			`di->charge_status = POWER_SUPPLY_STATUS_CHARGING;`
232			`} else {`
233			`unsigned char acr[2];`
234			`int acr_val;`
235
236			`/* acr is in units of 0.25 mAh */`
237			`acr_val = di->full_active_uAh * 4L / 1000;`
238
239			`acr[0] = acr_val >> 8;`
240			`acr[1] = acr_val & 0xff;`
241
242			`if (w1_ds2760_write(di->w1_dev, acr,`
243			`DS2760_CURRENT_ACCUM_MSB, 2) < 2)`
244			`dev_warn(di->dev,`
245			`"ACR reset failed\n");`
246
247			`di->charge_status = POWER_SUPPLY_STATUS_FULL;`
248			`}`
249			`}`
250			`} else {`
251			`di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;`
252			`di->full_counter = 0;`
253			`}`
254
255			`if (di->charge_status != old_charge_status)`
256			`power_supply_changed(&di->bat);`
257			`}`
258
259			`static void ds2760_battery_work(struct work_struct *work)`
260			`{`
261			`struct ds2760_device_info *di = container_of(work,`
262			`struct ds2760_device_info, monitor_work.work);`
263			`const int interval = HZ * 60;`
264
265			`dev_dbg(di->dev, "%s\n", __FUNCTION__);`
266
267			`ds2760_battery_update_status(di);`
268			`queue_delayed_work(di->monitor_wqueue, &di->monitor_work, interval);`
269			`}`
270
271			`#define to_ds2760_device_info(x) container_of((x), struct ds2760_device_info, \`
272			`bat);`
273
274			`static void ds2760_battery_external_power_changed(struct power_supply *psy)`
275			`{`
276			`struct ds2760_device_info *di = to_ds2760_device_info(psy);`
277
278			`dev_dbg(di->dev, "%s\n", __FUNCTION__);`
279
280			`cancel_delayed_work(&di->monitor_work);`
281			`queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ/10);`
282			`}`
283
284			`static int ds2760_battery_get_property(struct power_supply *psy,`
285			`enum power_supply_property psp,`
286			`union power_supply_propval *val)`
287			`{`
288			`struct ds2760_device_info *di = to_ds2760_device_info(psy);`
289
290			`switch (psp) {`
291			`case POWER_SUPPLY_PROP_STATUS:`
292			`val->intval = di->charge_status;`
293			`return 0;`
294			`default:`
295			`break;`
296			`}`
297
298			`ds2760_battery_read_status(di);`
299
300			`switch (psp) {`
301			`case POWER_SUPPLY_PROP_VOLTAGE_NOW:`
302			`val->intval = di->voltage_uV;`
303			`break;`
304			`case POWER_SUPPLY_PROP_CURRENT_NOW:`
305			`val->intval = di->current_uA;`
306			`break;`
307			`case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:`
308			`val->intval = di->rated_capacity;`
309			`break;`
310			`case POWER_SUPPLY_PROP_CHARGE_FULL:`
311			`val->intval = di->full_active_uAh;`
312			`break;`
313			`case POWER_SUPPLY_PROP_CHARGE_EMPTY:`
314			`val->intval = di->empty_uAh;`
315			`break;`
316			`case POWER_SUPPLY_PROP_CHARGE_NOW:`
317			`val->intval = di->accum_current_uAh;`
318			`break;`
319			`case POWER_SUPPLY_PROP_TEMP:`
320			`val->intval = di->temp_C;`
321			`break;`
322			`default:`
323			`return -EINVAL;`
324			`}`
325
326			`return 0;`
327			`}`
328
329			`static enum power_supply_property ds2760_battery_props[] = {`
330			`POWER_SUPPLY_PROP_STATUS,`
331			`POWER_SUPPLY_PROP_VOLTAGE_NOW,`
332			`POWER_SUPPLY_PROP_CURRENT_NOW,`
333			`POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,`
334			`POWER_SUPPLY_PROP_CHARGE_FULL,`
335			`POWER_SUPPLY_PROP_CHARGE_EMPTY,`
336			`POWER_SUPPLY_PROP_CHARGE_NOW,`
337			`POWER_SUPPLY_PROP_TEMP,`
338			`};`
339
340			`static int ds2760_battery_probe(struct platform_device *pdev)`
341			`{`
342			`int retval = 0;`
343			`struct ds2760_device_info *di;`
344			`struct ds2760_platform_data *pdata;`
345
346			`di = kzalloc(sizeof(*di), GFP_KERNEL);`
347			`if (!di) {`
348			`retval = -ENOMEM;`
349			`goto di_alloc_failed;`
350			`}`
351
352			`platform_set_drvdata(pdev, di);`
353
354			`pdata = pdev->dev.platform_data;`
355			`di->dev = &pdev->dev;`
356			`di->w1_dev = pdev->dev.parent;`
357			`di->bat.name = pdev->dev.bus_id;`
358			`di->bat.type = POWER_SUPPLY_TYPE_BATTERY;`
359			`di->bat.properties = ds2760_battery_props;`
360			`di->bat.num_properties = ARRAY_SIZE(ds2760_battery_props);`
361			`di->bat.get_property = ds2760_battery_get_property;`
362			`di->bat.external_power_changed =`
363			`ds2760_battery_external_power_changed;`
364
365			`di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;`
366
367			`retval = power_supply_register(&pdev->dev, &di->bat);`
368			`if (retval) {`
369			`dev_err(di->dev, "failed to register battery\n");`
370			`goto batt_failed;`
371			`}`
372
373			`INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);`
374			`di->monitor_wqueue = create_singlethread_workqueue(pdev->dev.bus_id);`
375			`if (!di->monitor_wqueue) {`
376			`retval = -ESRCH;`
377			`goto workqueue_failed;`
378			`}`
379			`queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ * 1);`
380
381			`goto success;`
382
383			`workqueue_failed:`
384			`power_supply_unregister(&di->bat);`
385			`batt_failed:`
386			`kfree(di);`
387			`di_alloc_failed:`
388			`success:`
389			`return retval;`
390			`}`
391
392			`static int ds2760_battery_remove(struct platform_device *pdev)`
393			`{`
394			`struct ds2760_device_info *di = platform_get_drvdata(pdev);`
395
396			`cancel_rearming_delayed_workqueue(di->monitor_wqueue,`
397			`&di->monitor_work);`
398			`destroy_workqueue(di->monitor_wqueue);`
399			`power_supply_unregister(&di->bat);`
400
401			`return 0;`
402			`}`
403
404			`#ifdef CONFIG_PM`
405
406			`static int ds2760_battery_suspend(struct platform_device *pdev,`
407			`pm_message_t state)`
408			`{`
409			`struct ds2760_device_info *di = platform_get_drvdata(pdev);`
410
411			`di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;`
412
413			`return 0;`
414			`}`
415
416			`static int ds2760_battery_resume(struct platform_device *pdev)`
417			`{`
418			`struct ds2760_device_info *di = platform_get_drvdata(pdev);`
419
420			`di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;`
421			`power_supply_changed(&di->bat);`
422
423			`cancel_delayed_work(&di->monitor_work);`
424			`queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ);`
425
426			`return 0;`
427			`}`
428
429			`#else`
430
431			`#define ds2760_battery_suspend NULL`
432			`#define ds2760_battery_resume NULL`
433
434			`#endif /* CONFIG_PM */`
435
436			`static struct platform_driver ds2760_battery_driver = {`
437			`.driver = {`
438			`.name = "ds2760-battery",`
439			`},`
440			`.probe = ds2760_battery_probe,`
441			`.remove = ds2760_battery_remove,`
442			`.suspend = ds2760_battery_suspend,`
443			`.resume = ds2760_battery_resume,`
444			`};`
445
446			`static int __init ds2760_battery_init(void)`
447			`{`
448			`return platform_driver_register(&ds2760_battery_driver);`
449			`}`
450
451			`static void __exit ds2760_battery_exit(void)`
452			`{`
453			`platform_driver_unregister(&ds2760_battery_driver);`
454			`}`
455
456			`module_init(ds2760_battery_init);`
457			`module_exit(ds2760_battery_exit);`
458
459			`MODULE_LICENSE("GPL");`
460			`MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>, "`
461			`"Matt Reimer <mreimer@vpop.net>, "`
462			`"Anton Vorontsov <cbou@mail.ru>");`
463			`MODULE_DESCRIPTION("ds2760 battery driver");`