cregit-Linux how code gets into the kernel

Release 4.11 drivers/power/supply/s3c_adc_battery.c

/*
 *      iPAQ h1930/h1940/rx1950 battery controller driver
 *      Copyright (c) Vasily Khoruzhick
 *      Based on h1940_battery.c by Arnaud Patard
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive for
 * more details.
 *
 */

#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/leds.h>
#include <linux/gpio.h>
#include <linux/err.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/s3c_adc_battery.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/module.h>

#include <plat/adc.h>


#define BAT_POLL_INTERVAL		10000 
/* ms */

#define JITTER_DELAY			500 
/* ms */


struct s3c_adc_bat {
	
struct power_supply		*psy;
	
struct s3c_adc_client		*client;
	
struct s3c_adc_bat_pdata	*pdata;
	
int				volt_value;
	
int				cur_value;
	
unsigned int			timestamp;
	
int				level;
	
int				status;
	
int				cable_plugged:1;
};


static struct delayed_work bat_work;


static void s3c_adc_bat_ext_power_changed(struct power_supply *psy) { schedule_delayed_work(&bat_work, msecs_to_jiffies(JITTER_DELAY)); }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick22100.00%1100.00%
Total22100.00%1100.00%


static int gather_samples(struct s3c_adc_client *client, int num, int channel) { int value, i; /* default to 1 if nothing is set */ if (num < 1) num = 1; value = 0; for (i = 0; i < num; i++) value += s3c_adc_read(client, channel); value /= num; return value; }

Contributors

PersonTokensPropCommitsCommitProp
Heiko Stübner66100.00%1100.00%
Total66100.00%1100.00%

static enum power_supply_property s3c_adc_backup_bat_props[] = { POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_VOLTAGE_MIN, POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, };
static int s3c_adc_backup_bat_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct s3c_adc_bat *bat = power_supply_get_drvdata(psy); if (!bat) { dev_err(&psy->dev, "%s: no battery infos ?!\n", __func__); return -EINVAL; } if (bat->volt_value < 0 || jiffies_to_msecs(jiffies - bat->timestamp) > BAT_POLL_INTERVAL) { bat->volt_value = gather_samples(bat->client, bat->pdata->backup_volt_samples, bat->pdata->backup_volt_channel); bat->volt_value *= bat->pdata->backup_volt_mult; bat->timestamp = jiffies; } switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_NOW: val->intval = bat->volt_value; return 0; case POWER_SUPPLY_PROP_VOLTAGE_MIN: val->intval = bat->pdata->backup_volt_min; return 0; case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: val->intval = bat->pdata->backup_volt_max; return 0; default: return -EINVAL; } }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick16194.71%133.33%
Heiko Stübner74.12%133.33%
Krzysztof Kozlowski21.18%133.33%
Total170100.00%3100.00%

static const struct power_supply_desc backup_bat_desc = { .name = "backup-battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = s3c_adc_backup_bat_props, .num_properties = ARRAY_SIZE(s3c_adc_backup_bat_props), .get_property = s3c_adc_backup_bat_get_property, .use_for_apm = 1, }; static struct s3c_adc_bat backup_bat; static enum power_supply_property s3c_adc_main_bat_props[] = { POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, POWER_SUPPLY_PROP_CHARGE_NOW, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CURRENT_NOW, };
static int calc_full_volt(int volt_val, int cur_val, int impedance) { return volt_val + cur_val * impedance / 1000; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick24100.00%1100.00%
Total24100.00%1100.00%


static int charge_finished(struct s3c_adc_bat *bat) { return bat->pdata->gpio_inverted ? !gpio_get_value(bat->pdata->gpio_charge_finished) : gpio_get_value(bat->pdata->gpio_charge_finished); }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick37100.00%1100.00%
Total37100.00%1100.00%


static int s3c_adc_bat_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct s3c_adc_bat *bat = power_supply_get_drvdata(psy); int new_level; int full_volt; const struct s3c_adc_bat_thresh *lut; unsigned int lut_size; if (!bat) { dev_err(&psy->dev, "no battery infos ?!\n"); return -EINVAL; } lut = bat->pdata->lut_noac; lut_size = bat->pdata->lut_noac_cnt; if (bat->volt_value < 0 || bat->cur_value < 0 || jiffies_to_msecs(jiffies - bat->timestamp) > BAT_POLL_INTERVAL) { bat->volt_value = gather_samples(bat->client, bat->pdata->volt_samples, bat->pdata->volt_channel) * bat->pdata->volt_mult; bat->cur_value = gather_samples(bat->client, bat->pdata->current_samples, bat->pdata->current_channel) * bat->pdata->current_mult; bat->timestamp = jiffies; } if (bat->cable_plugged && ((bat->pdata->gpio_charge_finished < 0) || !charge_finished(bat))) { lut = bat->pdata->lut_acin; lut_size = bat->pdata->lut_acin_cnt; } new_level = 100000; full_volt = calc_full_volt((bat->volt_value / 1000), (bat->cur_value / 1000), bat->pdata->internal_impedance); if (full_volt < calc_full_volt(lut->volt, lut->cur, bat->pdata->internal_impedance)) { lut_size--; while (lut_size--) { int lut_volt1; int lut_volt2; lut_volt1 = calc_full_volt(lut[0].volt, lut[0].cur, bat->pdata->internal_impedance); lut_volt2 = calc_full_volt(lut[1].volt, lut[1].cur, bat->pdata->internal_impedance); if (full_volt < lut_volt1 && full_volt >= lut_volt2) { new_level = (lut[1].level + (lut[0].level - lut[1].level) * (full_volt - lut_volt2) / (lut_volt1 - lut_volt2)) * 1000; break; } new_level = lut[1].level * 1000; lut++; } } bat->level = new_level; switch (psp) { case POWER_SUPPLY_PROP_STATUS: if (bat->pdata->gpio_charge_finished < 0) val->intval = bat->level == 100000 ? POWER_SUPPLY_STATUS_FULL : bat->status; else val->intval = bat->status; return 0; case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: val->intval = 100000; return 0; case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: val->intval = 0; return 0; case POWER_SUPPLY_PROP_CHARGE_NOW: val->intval = bat->level; return 0; case POWER_SUPPLY_PROP_VOLTAGE_NOW: val->intval = bat->volt_value; return 0; case POWER_SUPPLY_PROP_CURRENT_NOW: val->intval = bat->cur_value; return 0; default: return -EINVAL; } }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick49693.94%240.00%
Syam Sidhardhan163.03%120.00%
Heiko Stübner142.65%120.00%
Krzysztof Kozlowski20.38%120.00%
Total528100.00%5100.00%

static const struct power_supply_desc main_bat_desc = { .name = "main-battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = s3c_adc_main_bat_props, .num_properties = ARRAY_SIZE(s3c_adc_main_bat_props), .get_property = s3c_adc_bat_get_property, .external_power_changed = s3c_adc_bat_ext_power_changed, .use_for_apm = 1, }; static struct s3c_adc_bat main_bat;
static void s3c_adc_bat_work(struct work_struct *work) { struct s3c_adc_bat *bat = &main_bat; int is_charged; int is_plugged; static int was_plugged; is_plugged = power_supply_am_i_supplied(bat->psy); bat->cable_plugged = is_plugged; if (is_plugged != was_plugged) { was_plugged = is_plugged; if (is_plugged) { if (bat->pdata->enable_charger) bat->pdata->enable_charger(); bat->status = POWER_SUPPLY_STATUS_CHARGING; } else { if (bat->pdata->disable_charger) bat->pdata->disable_charger(); bat->status = POWER_SUPPLY_STATUS_DISCHARGING; } } else { if ((bat->pdata->gpio_charge_finished >= 0) && is_plugged) { is_charged = charge_finished(&main_bat); if (is_charged) { if (bat->pdata->disable_charger) bat->pdata->disable_charger(); bat->status = POWER_SUPPLY_STATUS_FULL; } else { if (bat->pdata->enable_charger) bat->pdata->enable_charger(); bat->status = POWER_SUPPLY_STATUS_CHARGING; } } } power_supply_changed(bat->psy); }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick192100.00%2100.00%
Total192100.00%2100.00%


static irqreturn_t s3c_adc_bat_charged(int irq, void *dev_id) { schedule_delayed_work(&bat_work, msecs_to_jiffies(JITTER_DELAY)); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick27100.00%1100.00%
Total27100.00%1100.00%


static int s3c_adc_bat_probe(struct platform_device *pdev) { struct s3c_adc_client *client; struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data; int ret; client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(client)) { dev_err(&pdev->dev, "cannot register adc\n"); return PTR_ERR(client); } platform_set_drvdata(pdev, client); main_bat.client = client; main_bat.pdata = pdata; main_bat.volt_value = -1; main_bat.cur_value = -1; main_bat.cable_plugged = 0; main_bat.status = POWER_SUPPLY_STATUS_DISCHARGING; main_bat.psy = power_supply_register(&pdev->dev, &main_bat_desc, NULL); if (IS_ERR(main_bat.psy)) { ret = PTR_ERR(main_bat.psy); goto err_reg_main; } if (pdata->backup_volt_mult) { const struct power_supply_config psy_cfg = { .drv_data = &backup_bat, }; backup_bat.client = client; backup_bat.pdata = pdev->dev.platform_data; backup_bat.volt_value = -1; backup_bat.psy = power_supply_register(&pdev->dev, &backup_bat_desc, &psy_cfg); if (IS_ERR(backup_bat.psy)) { ret = PTR_ERR(backup_bat.psy); goto err_reg_backup; } } INIT_DELAYED_WORK(&bat_work, s3c_adc_bat_work); if (pdata->gpio_charge_finished >= 0) { ret = gpio_request(pdata->gpio_charge_finished, "charged"); if (ret) goto err_gpio; ret = request_irq(gpio_to_irq(pdata->gpio_charge_finished), s3c_adc_bat_charged, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "battery charged", NULL); if (ret) goto err_irq; } if (pdata->init) { ret = pdata->init(); if (ret) goto err_platform; } dev_info(&pdev->dev, "successfully loaded\n"); device_init_wakeup(&pdev->dev, 1); /* Schedule timer to check current status */ schedule_delayed_work(&bat_work, msecs_to_jiffies(JITTER_DELAY)); return 0; err_platform: if (pdata->gpio_charge_finished >= 0) free_irq(gpio_to_irq(pdata->gpio_charge_finished), NULL); err_irq: if (pdata->gpio_charge_finished >= 0) gpio_free(pdata->gpio_charge_finished); err_gpio: if (pdata->backup_volt_mult) power_supply_unregister(backup_bat.psy); err_reg_backup: power_supply_unregister(main_bat.psy); err_reg_main: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick36885.98%133.33%
Krzysztof Kozlowski6014.02%266.67%
Total428100.00%3100.00%


static int s3c_adc_bat_remove(struct platform_device *pdev) { struct s3c_adc_client *client = platform_get_drvdata(pdev); struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data; power_supply_unregister(main_bat.psy); if (pdata->backup_volt_mult) power_supply_unregister(backup_bat.psy); s3c_adc_release(client); if (pdata->gpio_charge_finished >= 0) { free_irq(gpio_to_irq(pdata->gpio_charge_finished), NULL); gpio_free(pdata->gpio_charge_finished); } cancel_delayed_work(&bat_work); if (pdata->exit) pdata->exit(); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick106100.00%1100.00%
Total106100.00%1100.00%

#ifdef CONFIG_PM
static int s3c_adc_bat_suspend(struct platform_device *pdev, pm_message_t state) { struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data; if (pdata->gpio_charge_finished >= 0) { if (device_may_wakeup(&pdev->dev)) enable_irq_wake( gpio_to_irq(pdata->gpio_charge_finished)); else { disable_irq(gpio_to_irq(pdata->gpio_charge_finished)); main_bat.pdata->disable_charger(); } } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick78100.00%1100.00%
Total78100.00%1100.00%


static int s3c_adc_bat_resume(struct platform_device *pdev) { struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data; if (pdata->gpio_charge_finished >= 0) { if (device_may_wakeup(&pdev->dev)) disable_irq_wake( gpio_to_irq(pdata->gpio_charge_finished)); else enable_irq(gpio_to_irq(pdata->gpio_charge_finished)); } /* Schedule timer to check current status */ schedule_delayed_work(&bat_work, msecs_to_jiffies(JITTER_DELAY)); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick78100.00%1100.00%
Total78100.00%1100.00%

#else #define s3c_adc_bat_suspend NULL #define s3c_adc_bat_resume NULL #endif static struct platform_driver s3c_adc_bat_driver = { .driver = { .name = "s3c-adc-battery", }, .probe = s3c_adc_bat_probe, .remove = s3c_adc_bat_remove, .suspend = s3c_adc_bat_suspend, .resume = s3c_adc_bat_resume, }; module_platform_driver(s3c_adc_bat_driver); MODULE_AUTHOR("Vasily Khoruzhick <anarsoul@gmail.com>"); MODULE_DESCRIPTION("iPAQ H1930/H1940/RX1950 battery controller driver"); MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
Vasily Khoruzhick186690.80%330.00%
Heiko Stübner894.33%220.00%
Krzysztof Kozlowski813.94%220.00%
Syam Sidhardhan160.78%110.00%
Uwe Kleine-König20.10%110.00%
Axel Lin10.05%110.00%
Total2055100.00%10100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.