Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/power/s3c_adc_battery.c

  1 /*
  2  *      iPAQ h1930/h1940/rx1950 battery controller driver
  3  *      Copyright (c) Vasily Khoruzhick
  4  *      Based on h1940_battery.c by Arnaud Patard
  5  *
  6  * This file is subject to the terms and conditions of the GNU General Public
  7  * License.  See the file COPYING in the main directory of this archive for
  8  * more details.
  9  *
 10  */
 11 
 12 #include <linux/interrupt.h>
 13 #include <linux/platform_device.h>
 14 #include <linux/power_supply.h>
 15 #include <linux/leds.h>
 16 #include <linux/gpio.h>
 17 #include <linux/err.h>
 18 #include <linux/timer.h>
 19 #include <linux/jiffies.h>
 20 #include <linux/s3c_adc_battery.h>
 21 #include <linux/errno.h>
 22 #include <linux/init.h>
 23 #include <linux/module.h>
 24 
 25 #include <plat/adc.h>
 26 
 27 #define BAT_POLL_INTERVAL               10000 /* ms */
 28 #define JITTER_DELAY                    500 /* ms */
 29 
 30 struct s3c_adc_bat {
 31         struct power_supply             psy;
 32         struct s3c_adc_client           *client;
 33         struct s3c_adc_bat_pdata        *pdata;
 34         int                             volt_value;
 35         int                             cur_value;
 36         unsigned int                    timestamp;
 37         int                             level;
 38         int                             status;
 39         int                             cable_plugged:1;
 40 };
 41 
 42 static struct delayed_work bat_work;
 43 
 44 static void s3c_adc_bat_ext_power_changed(struct power_supply *psy)
 45 {
 46         schedule_delayed_work(&bat_work,
 47                 msecs_to_jiffies(JITTER_DELAY));
 48 }
 49 
 50 static int gather_samples(struct s3c_adc_client *client, int num, int channel)
 51 {
 52         int value, i;
 53 
 54         /* default to 1 if nothing is set */
 55         if (num < 1)
 56                 num = 1;
 57 
 58         value = 0;
 59         for (i = 0; i < num; i++)
 60                 value += s3c_adc_read(client, channel);
 61         value /= num;
 62 
 63         return value;
 64 }
 65 
 66 static enum power_supply_property s3c_adc_backup_bat_props[] = {
 67         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 68         POWER_SUPPLY_PROP_VOLTAGE_MIN,
 69         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 70 };
 71 
 72 static int s3c_adc_backup_bat_get_property(struct power_supply *psy,
 73                                 enum power_supply_property psp,
 74                                 union power_supply_propval *val)
 75 {
 76         struct s3c_adc_bat *bat = container_of(psy, struct s3c_adc_bat, psy);
 77 
 78         if (!bat) {
 79                 dev_err(psy->dev, "%s: no battery infos ?!\n", __func__);
 80                 return -EINVAL;
 81         }
 82 
 83         if (bat->volt_value < 0 ||
 84                 jiffies_to_msecs(jiffies - bat->timestamp) >
 85                         BAT_POLL_INTERVAL) {
 86                 bat->volt_value = gather_samples(bat->client,
 87                         bat->pdata->backup_volt_samples,
 88                         bat->pdata->backup_volt_channel);
 89                 bat->volt_value *= bat->pdata->backup_volt_mult;
 90                 bat->timestamp = jiffies;
 91         }
 92 
 93         switch (psp) {
 94         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 95                 val->intval = bat->volt_value;
 96                 return 0;
 97         case POWER_SUPPLY_PROP_VOLTAGE_MIN:
 98                 val->intval = bat->pdata->backup_volt_min;
 99                 return 0;
100         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
101                 val->intval = bat->pdata->backup_volt_max;
102                 return 0;
103         default:
104                 return -EINVAL;
105         }
106 }
107 
108 static struct s3c_adc_bat backup_bat = {
109         .psy = {
110                 .name           = "backup-battery",
111                 .type           = POWER_SUPPLY_TYPE_BATTERY,
112                 .properties     = s3c_adc_backup_bat_props,
113                 .num_properties = ARRAY_SIZE(s3c_adc_backup_bat_props),
114                 .get_property   = s3c_adc_backup_bat_get_property,
115                 .use_for_apm    = 1,
116         },
117 };
118 
119 static enum power_supply_property s3c_adc_main_bat_props[] = {
120         POWER_SUPPLY_PROP_STATUS,
121         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
122         POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
123         POWER_SUPPLY_PROP_CHARGE_NOW,
124         POWER_SUPPLY_PROP_VOLTAGE_NOW,
125         POWER_SUPPLY_PROP_CURRENT_NOW,
126 };
127 
128 static int calc_full_volt(int volt_val, int cur_val, int impedance)
129 {
130         return volt_val + cur_val * impedance / 1000;
131 }
132 
133 static int charge_finished(struct s3c_adc_bat *bat)
134 {
135         return bat->pdata->gpio_inverted ?
136                 !gpio_get_value(bat->pdata->gpio_charge_finished) :
137                 gpio_get_value(bat->pdata->gpio_charge_finished);
138 }
139 
140 static int s3c_adc_bat_get_property(struct power_supply *psy,
141                                     enum power_supply_property psp,
142                                     union power_supply_propval *val)
143 {
144         struct s3c_adc_bat *bat = container_of(psy, struct s3c_adc_bat, psy);
145 
146         int new_level;
147         int full_volt;
148         const struct s3c_adc_bat_thresh *lut;
149         unsigned int lut_size;
150 
151         if (!bat) {
152                 dev_err(psy->dev, "no battery infos ?!\n");
153                 return -EINVAL;
154         }
155 
156         lut = bat->pdata->lut_noac;
157         lut_size = bat->pdata->lut_noac_cnt;
158 
159         if (bat->volt_value < 0 || bat->cur_value < 0 ||
160                 jiffies_to_msecs(jiffies - bat->timestamp) >
161                         BAT_POLL_INTERVAL) {
162                 bat->volt_value = gather_samples(bat->client,
163                         bat->pdata->volt_samples,
164                         bat->pdata->volt_channel) * bat->pdata->volt_mult;
165                 bat->cur_value = gather_samples(bat->client,
166                         bat->pdata->current_samples,
167                         bat->pdata->current_channel) * bat->pdata->current_mult;
168                 bat->timestamp = jiffies;
169         }
170 
171         if (bat->cable_plugged &&
172                 ((bat->pdata->gpio_charge_finished < 0) ||
173                 !charge_finished(bat))) {
174                 lut = bat->pdata->lut_acin;
175                 lut_size = bat->pdata->lut_acin_cnt;
176         }
177 
178         new_level = 100000;
179         full_volt = calc_full_volt((bat->volt_value / 1000),
180                 (bat->cur_value / 1000), bat->pdata->internal_impedance);
181 
182         if (full_volt < calc_full_volt(lut->volt, lut->cur,
183                 bat->pdata->internal_impedance)) {
184                 lut_size--;
185                 while (lut_size--) {
186                         int lut_volt1;
187                         int lut_volt2;
188 
189                         lut_volt1 = calc_full_volt(lut[0].volt, lut[0].cur,
190                                 bat->pdata->internal_impedance);
191                         lut_volt2 = calc_full_volt(lut[1].volt, lut[1].cur,
192                                 bat->pdata->internal_impedance);
193                         if (full_volt < lut_volt1 && full_volt >= lut_volt2) {
194                                 new_level = (lut[1].level +
195                                         (lut[0].level - lut[1].level) *
196                                         (full_volt - lut_volt2) /
197                                         (lut_volt1 - lut_volt2)) * 1000;
198                                 break;
199                         }
200                         new_level = lut[1].level * 1000;
201                         lut++;
202                 }
203         }
204 
205         bat->level = new_level;
206 
207         switch (psp) {
208         case POWER_SUPPLY_PROP_STATUS:
209                 if (bat->pdata->gpio_charge_finished < 0)
210                         val->intval = bat->level == 100000 ?
211                                 POWER_SUPPLY_STATUS_FULL : bat->status;
212                 else
213                         val->intval = bat->status;
214                 return 0;
215         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
216                 val->intval = 100000;
217                 return 0;
218         case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
219                 val->intval = 0;
220                 return 0;
221         case POWER_SUPPLY_PROP_CHARGE_NOW:
222                 val->intval = bat->level;
223                 return 0;
224         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
225                 val->intval = bat->volt_value;
226                 return 0;
227         case POWER_SUPPLY_PROP_CURRENT_NOW:
228                 val->intval = bat->cur_value;
229                 return 0;
230         default:
231                 return -EINVAL;
232         }
233 }
234 
235 static struct s3c_adc_bat main_bat = {
236         .psy = {
237                 .name                   = "main-battery",
238                 .type                   = POWER_SUPPLY_TYPE_BATTERY,
239                 .properties             = s3c_adc_main_bat_props,
240                 .num_properties         = ARRAY_SIZE(s3c_adc_main_bat_props),
241                 .get_property           = s3c_adc_bat_get_property,
242                 .external_power_changed = s3c_adc_bat_ext_power_changed,
243                 .use_for_apm            = 1,
244         },
245 };
246 
247 static void s3c_adc_bat_work(struct work_struct *work)
248 {
249         struct s3c_adc_bat *bat = &main_bat;
250         int is_charged;
251         int is_plugged;
252         static int was_plugged;
253 
254         is_plugged = power_supply_am_i_supplied(&bat->psy);
255         bat->cable_plugged = is_plugged;
256         if (is_plugged != was_plugged) {
257                 was_plugged = is_plugged;
258                 if (is_plugged) {
259                         if (bat->pdata->enable_charger)
260                                 bat->pdata->enable_charger();
261                         bat->status = POWER_SUPPLY_STATUS_CHARGING;
262                 } else {
263                         if (bat->pdata->disable_charger)
264                                 bat->pdata->disable_charger();
265                         bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
266                 }
267         } else {
268                 if ((bat->pdata->gpio_charge_finished >= 0) && is_plugged) {
269                         is_charged = charge_finished(&main_bat);
270                         if (is_charged) {
271                                 if (bat->pdata->disable_charger)
272                                         bat->pdata->disable_charger();
273                                 bat->status = POWER_SUPPLY_STATUS_FULL;
274                         } else {
275                                 if (bat->pdata->enable_charger)
276                                         bat->pdata->enable_charger();
277                                 bat->status = POWER_SUPPLY_STATUS_CHARGING;
278                         }
279                 }
280         }
281 
282         power_supply_changed(&bat->psy);
283 }
284 
285 static irqreturn_t s3c_adc_bat_charged(int irq, void *dev_id)
286 {
287         schedule_delayed_work(&bat_work,
288                 msecs_to_jiffies(JITTER_DELAY));
289         return IRQ_HANDLED;
290 }
291 
292 static int s3c_adc_bat_probe(struct platform_device *pdev)
293 {
294         struct s3c_adc_client   *client;
295         struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data;
296         int ret;
297 
298         client = s3c_adc_register(pdev, NULL, NULL, 0);
299         if (IS_ERR(client)) {
300                 dev_err(&pdev->dev, "cannot register adc\n");
301                 return PTR_ERR(client);
302         }
303 
304         platform_set_drvdata(pdev, client);
305 
306         main_bat.client = client;
307         main_bat.pdata = pdata;
308         main_bat.volt_value = -1;
309         main_bat.cur_value = -1;
310         main_bat.cable_plugged = 0;
311         main_bat.status = POWER_SUPPLY_STATUS_DISCHARGING;
312 
313         ret = power_supply_register(&pdev->dev, &main_bat.psy);
314         if (ret)
315                 goto err_reg_main;
316         if (pdata->backup_volt_mult) {
317                 backup_bat.client = client;
318                 backup_bat.pdata = pdev->dev.platform_data;
319                 backup_bat.volt_value = -1;
320                 ret = power_supply_register(&pdev->dev, &backup_bat.psy);
321                 if (ret)
322                         goto err_reg_backup;
323         }
324 
325         INIT_DELAYED_WORK(&bat_work, s3c_adc_bat_work);
326 
327         if (pdata->gpio_charge_finished >= 0) {
328                 ret = gpio_request(pdata->gpio_charge_finished, "charged");
329                 if (ret)
330                         goto err_gpio;
331 
332                 ret = request_irq(gpio_to_irq(pdata->gpio_charge_finished),
333                                 s3c_adc_bat_charged,
334                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
335                                 "battery charged", NULL);
336                 if (ret)
337                         goto err_irq;
338         }
339 
340         if (pdata->init) {
341                 ret = pdata->init();
342                 if (ret)
343                         goto err_platform;
344         }
345 
346         dev_info(&pdev->dev, "successfully loaded\n");
347         device_init_wakeup(&pdev->dev, 1);
348 
349         /* Schedule timer to check current status */
350         schedule_delayed_work(&bat_work,
351                 msecs_to_jiffies(JITTER_DELAY));
352 
353         return 0;
354 
355 err_platform:
356         if (pdata->gpio_charge_finished >= 0)
357                 free_irq(gpio_to_irq(pdata->gpio_charge_finished), NULL);
358 err_irq:
359         if (pdata->gpio_charge_finished >= 0)
360                 gpio_free(pdata->gpio_charge_finished);
361 err_gpio:
362         if (pdata->backup_volt_mult)
363                 power_supply_unregister(&backup_bat.psy);
364 err_reg_backup:
365         power_supply_unregister(&main_bat.psy);
366 err_reg_main:
367         return ret;
368 }
369 
370 static int s3c_adc_bat_remove(struct platform_device *pdev)
371 {
372         struct s3c_adc_client *client = platform_get_drvdata(pdev);
373         struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data;
374 
375         power_supply_unregister(&main_bat.psy);
376         if (pdata->backup_volt_mult)
377                 power_supply_unregister(&backup_bat.psy);
378 
379         s3c_adc_release(client);
380 
381         if (pdata->gpio_charge_finished >= 0) {
382                 free_irq(gpio_to_irq(pdata->gpio_charge_finished), NULL);
383                 gpio_free(pdata->gpio_charge_finished);
384         }
385 
386         cancel_delayed_work(&bat_work);
387 
388         if (pdata->exit)
389                 pdata->exit();
390 
391         return 0;
392 }
393 
394 #ifdef CONFIG_PM
395 static int s3c_adc_bat_suspend(struct platform_device *pdev,
396         pm_message_t state)
397 {
398         struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data;
399 
400         if (pdata->gpio_charge_finished >= 0) {
401                 if (device_may_wakeup(&pdev->dev))
402                         enable_irq_wake(
403                                 gpio_to_irq(pdata->gpio_charge_finished));
404                 else {
405                         disable_irq(gpio_to_irq(pdata->gpio_charge_finished));
406                         main_bat.pdata->disable_charger();
407                 }
408         }
409 
410         return 0;
411 }
412 
413 static int s3c_adc_bat_resume(struct platform_device *pdev)
414 {
415         struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data;
416 
417         if (pdata->gpio_charge_finished >= 0) {
418                 if (device_may_wakeup(&pdev->dev))
419                         disable_irq_wake(
420                                 gpio_to_irq(pdata->gpio_charge_finished));
421                 else
422                         enable_irq(gpio_to_irq(pdata->gpio_charge_finished));
423         }
424 
425         /* Schedule timer to check current status */
426         schedule_delayed_work(&bat_work,
427                 msecs_to_jiffies(JITTER_DELAY));
428 
429         return 0;
430 }
431 #else
432 #define s3c_adc_bat_suspend NULL
433 #define s3c_adc_bat_resume NULL
434 #endif
435 
436 static struct platform_driver s3c_adc_bat_driver = {
437         .driver         = {
438                 .name   = "s3c-adc-battery",
439         },
440         .probe          = s3c_adc_bat_probe,
441         .remove         = s3c_adc_bat_remove,
442         .suspend        = s3c_adc_bat_suspend,
443         .resume         = s3c_adc_bat_resume,
444 };
445 
446 module_platform_driver(s3c_adc_bat_driver);
447 
448 MODULE_AUTHOR("Vasily Khoruzhick <anarsoul@gmail.com>");
449 MODULE_DESCRIPTION("iPAQ H1930/H1940/RX1950 battery controller driver");
450 MODULE_LICENSE("GPL");
451 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us