mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![Krzysztof Kozlowski](/assets/img/avatar_default.png)
Change the ownership of power_supply structure from each driver implementing the class to the power supply core. The patch changes power_supply_register() function thus all drivers implementing power supply class are adjusted. Each driver provides the implementation of power supply. However it should not be the owner of power supply class instance because it is exposed by core to other subsystems with power_supply_get_by_name(). These other subsystems have no knowledge when the driver will unregister the power supply. This leads to several issues when driver is unbound - mostly because user of power supply accesses freed memory. Instead let the core own the instance of struct 'power_supply'. Other users of this power supply will still access valid memory because it will be freed when device reference count reaches 0. Currently this means "it will leak" but power_supply_put() call in next patches will solve it. This solves invalid memory references in following race condition scenario: Thread 1: charger manager Thread 2: power supply driver, used by charger manager THREAD 1 (charger manager) THREAD 2 (power supply driver) ========================== ============================== psy = power_supply_get_by_name() Driver unbind, .remove power_supply_unregister() Device fully removed psy->get_property() The 'get_property' call is executed in invalid context because the driver was unbound and struct 'power_supply' memory was freed. This could be observed easily with charger manager driver (here compiled with max17040 fuel gauge): $ cat /sys/devices/virtual/power_supply/cm-battery/capacity & $ echo "1-0036" > /sys/bus/i2c/drivers/max17040/unbind [ 55.725123] Unable to handle kernel NULL pointer dereference at virtual address 00000000 [ 55.732584] pgd = d98d4000 [ 55.734060] [00000000] *pgd=5afa2831, *pte=00000000, *ppte=00000000 [ 55.740318] Internal error: Oops: 80000007 [#1] PREEMPT SMP ARM [ 55.746210] Modules linked in: [ 55.749259] CPU: 1 PID: 2936 Comm: cat Tainted: G W 3.19.0-rc1-next-20141226-00048-gf79f475f3c44-dirty #1496 [ 55.760190] Hardware name: SAMSUNG EXYNOS (Flattened Device Tree) [ 55.766270] task: d9b76f00 ti: daf54000 task.ti: daf54000 [ 55.771647] PC is at 0x0 [ 55.774182] LR is at charger_get_property+0x2f4/0x36c [ 55.779201] pc : [<00000000>] lr : [<c034b0b4>] psr: 60000013 [ 55.779201] sp : daf55e90 ip : 00000003 fp : 00000000 [ 55.790657] r10: 00000000 r9 : c06e2878 r8 : d9b26c68 [ 55.795865] r7 : dad81610 r6 : daec7410 r5 : daf55ebc r4 : 00000000 [ 55.802367] r3 : 00000000 r2 : daf55ebc r1 : 0000002a r0 : d9b26c68 [ 55.808879] Flags: nZCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment user [ 55.815994] Control: 10c5387d Table: 598d406a DAC: 00000015 [ 55.821723] Process cat (pid: 2936, stack limit = 0xdaf54210) [ 55.827451] Stack: (0xdaf55e90 to 0xdaf56000) [ 55.831795] 5e80: 60000013 c01459c4 0000002a c06f8ef8 [ 55.839956] 5ea0: db651000 c06f8ef8 daebac00 c04cb668 daebac08 c0346864 00000000 c01459c4 [ 55.848115] 5ec0: d99eaa80 c06f8ef8 00000fff 00001000 db651000 c027f25c c027f240 d99eaa80 [ 55.856274] 5ee0: d9a06c00 c0146218 daf55f18 00001000 d99eaa80 db4c18c0 00000001 00000001 [ 55.864468] 5f00: daf55f80 c0144c78 c0144c54 c0107f90 00015000 d99eaab0 00000000 00000000 [ 55.872603] 5f20: 000051c7 00000000 db4c18c0 c04a9370 00015000 00001000 daf55f80 00001000 [ 55.880763] 5f40: daf54000 00015000 00000000 c00e53dc db4c18c0 c00e548c 0000000d 00008124 [ 55.888937] 5f60: 00000001 00000000 00000000 db4c18c0 db4c18c0 00001000 00015000 c00e5550 [ 55.897099] 5f80: 00000000 00000000 00001000 00001000 00015000 00000003 00000003 c000f364 [ 55.905239] 5fa0: 00000000 c000f1a0 00001000 00015000 00000003 00015000 00001000 0001333c [ 55.913399] 5fc0: 00001000 00015000 00000003 00000003 00000002 00000000 00000000 00000000 [ 55.921560] 5fe0: 7fffe000 be999850 0000a225 b6f3c19c 60000010 00000003 00000000 00000000 [ 55.929744] [<c034b0b4>] (charger_get_property) from [<c0346864>] (power_supply_show_property+0x48/0x20c) [ 55.939286] [<c0346864>] (power_supply_show_property) from [<c027f25c>] (dev_attr_show+0x1c/0x48) [ 55.948130] [<c027f25c>] (dev_attr_show) from [<c0146218>] (sysfs_kf_seq_show+0x84/0x104) [ 55.956298] [<c0146218>] (sysfs_kf_seq_show) from [<c0144c78>] (kernfs_seq_show+0x24/0x28) [ 55.964536] [<c0144c78>] (kernfs_seq_show) from [<c0107f90>] (seq_read+0x1b0/0x484) [ 55.972172] [<c0107f90>] (seq_read) from [<c00e53dc>] (__vfs_read+0x18/0x4c) [ 55.979188] [<c00e53dc>] (__vfs_read) from [<c00e548c>] (vfs_read+0x7c/0x100) [ 55.986304] [<c00e548c>] (vfs_read) from [<c00e5550>] (SyS_read+0x40/0x8c) [ 55.993164] [<c00e5550>] (SyS_read) from [<c000f1a0>] (ret_fast_syscall+0x0/0x48) [ 56.000626] Code: bad PC value [ 56.011652] ---[ end trace 7b64343fbdae8ef1 ]--- Signed-off-by: Krzysztof Kozlowski <k.kozlowski@samsung.com> Reviewed-by: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com> [for the nvec part] Reviewed-by: Marc Dietrich <marvin24@gmx.de> [for compal-laptop.c] Acked-by: Darren Hart <dvhart@linux.intel.com> [for the mfd part] Acked-by: Lee Jones <lee.jones@linaro.org> [for the hid part] Acked-by: Jiri Kosina <jkosina@suse.cz> [for the acpi part] Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Signed-off-by: Sebastian Reichel <sre@kernel.org>
796 lines
21 KiB
C
796 lines
21 KiB
C
/*
|
|
* intel_mid_battery.c - Intel MID PMIC Battery Driver
|
|
*
|
|
* Copyright (C) 2009 Intel Corporation
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
* Author: Nithish Mahalingam <nithish.mahalingam@intel.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/err.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/param.h>
|
|
#include <linux/device.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/power_supply.h>
|
|
|
|
#include <asm/intel_scu_ipc.h>
|
|
|
|
#define DRIVER_NAME "pmic_battery"
|
|
|
|
/*********************************************************************
|
|
* Generic defines
|
|
*********************************************************************/
|
|
|
|
static int debug;
|
|
module_param(debug, int, 0444);
|
|
MODULE_PARM_DESC(debug, "Flag to enable PMIC Battery debug messages.");
|
|
|
|
#define PMIC_BATT_DRV_INFO_UPDATED 1
|
|
#define PMIC_BATT_PRESENT 1
|
|
#define PMIC_BATT_NOT_PRESENT 0
|
|
#define PMIC_USB_PRESENT PMIC_BATT_PRESENT
|
|
#define PMIC_USB_NOT_PRESENT PMIC_BATT_NOT_PRESENT
|
|
|
|
/* pmic battery register related */
|
|
#define PMIC_BATT_CHR_SCHRGINT_ADDR 0xD2
|
|
#define PMIC_BATT_CHR_SBATOVP_MASK (1 << 1)
|
|
#define PMIC_BATT_CHR_STEMP_MASK (1 << 2)
|
|
#define PMIC_BATT_CHR_SCOMP_MASK (1 << 3)
|
|
#define PMIC_BATT_CHR_SUSBDET_MASK (1 << 4)
|
|
#define PMIC_BATT_CHR_SBATDET_MASK (1 << 5)
|
|
#define PMIC_BATT_CHR_SDCLMT_MASK (1 << 6)
|
|
#define PMIC_BATT_CHR_SUSBOVP_MASK (1 << 7)
|
|
#define PMIC_BATT_CHR_EXCPT_MASK 0x86
|
|
|
|
#define PMIC_BATT_ADC_ACCCHRG_MASK (1 << 31)
|
|
#define PMIC_BATT_ADC_ACCCHRGVAL_MASK 0x7FFFFFFF
|
|
|
|
/* pmic ipc related */
|
|
#define PMIC_BATT_CHR_IPC_FCHRG_SUBID 0x4
|
|
#define PMIC_BATT_CHR_IPC_TCHRG_SUBID 0x6
|
|
|
|
/* types of battery charging */
|
|
enum batt_charge_type {
|
|
BATT_USBOTG_500MA_CHARGE,
|
|
BATT_USBOTG_TRICKLE_CHARGE,
|
|
};
|
|
|
|
/* valid battery events */
|
|
enum batt_event {
|
|
BATT_EVENT_BATOVP_EXCPT,
|
|
BATT_EVENT_USBOVP_EXCPT,
|
|
BATT_EVENT_TEMP_EXCPT,
|
|
BATT_EVENT_DCLMT_EXCPT,
|
|
BATT_EVENT_EXCPT
|
|
};
|
|
|
|
|
|
/*********************************************************************
|
|
* Battery properties
|
|
*********************************************************************/
|
|
|
|
/*
|
|
* pmic battery info
|
|
*/
|
|
struct pmic_power_module_info {
|
|
bool is_dev_info_updated;
|
|
struct device *dev;
|
|
/* pmic battery data */
|
|
unsigned long update_time; /* jiffies when data read */
|
|
unsigned int usb_is_present;
|
|
unsigned int batt_is_present;
|
|
unsigned int batt_health;
|
|
unsigned int usb_health;
|
|
unsigned int batt_status;
|
|
unsigned int batt_charge_now; /* in mAS */
|
|
unsigned int batt_prev_charge_full; /* in mAS */
|
|
unsigned int batt_charge_rate; /* in units per second */
|
|
|
|
struct power_supply *usb;
|
|
struct power_supply *batt;
|
|
int irq; /* GPE_ID or IRQ# */
|
|
struct workqueue_struct *monitor_wqueue;
|
|
struct delayed_work monitor_battery;
|
|
struct work_struct handler;
|
|
};
|
|
|
|
static unsigned int delay_time = 2000; /* in ms */
|
|
|
|
/*
|
|
* pmic ac properties
|
|
*/
|
|
static enum power_supply_property pmic_usb_props[] = {
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
POWER_SUPPLY_PROP_HEALTH,
|
|
};
|
|
|
|
/*
|
|
* pmic battery properties
|
|
*/
|
|
static enum power_supply_property pmic_battery_props[] = {
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
POWER_SUPPLY_PROP_HEALTH,
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
POWER_SUPPLY_PROP_CHARGE_NOW,
|
|
POWER_SUPPLY_PROP_CHARGE_FULL,
|
|
};
|
|
|
|
|
|
/*
|
|
* Glue functions for talking to the IPC
|
|
*/
|
|
|
|
struct battery_property {
|
|
u32 capacity; /* Charger capacity */
|
|
u8 crnt; /* Quick charge current value*/
|
|
u8 volt; /* Fine adjustment of constant charge voltage */
|
|
u8 prot; /* CHRGPROT register value */
|
|
u8 prot2; /* CHRGPROT1 register value */
|
|
u8 timer; /* Charging timer */
|
|
};
|
|
|
|
#define IPCMSG_BATTERY 0xEF
|
|
|
|
/* Battery coulomb counter accumulator commands */
|
|
#define IPC_CMD_CC_WR 0 /* Update coulomb counter value */
|
|
#define IPC_CMD_CC_RD 1 /* Read coulomb counter value */
|
|
#define IPC_CMD_BATTERY_PROPERTY 2 /* Read Battery property */
|
|
|
|
/**
|
|
* pmic_scu_ipc_battery_cc_read - read battery cc
|
|
* @value: battery coulomb counter read
|
|
*
|
|
* Reads the battery couloumb counter value, returns 0 on success, or
|
|
* an error code
|
|
*
|
|
* This function may sleep. Locking for SCU accesses is handled for
|
|
* the caller.
|
|
*/
|
|
static int pmic_scu_ipc_battery_cc_read(u32 *value)
|
|
{
|
|
return intel_scu_ipc_command(IPCMSG_BATTERY, IPC_CMD_CC_RD,
|
|
NULL, 0, value, 1);
|
|
}
|
|
|
|
/**
|
|
* pmic_scu_ipc_battery_property_get - fetch properties
|
|
* @prop: battery properties
|
|
*
|
|
* Retrieve the battery properties from the power management
|
|
*
|
|
* This function may sleep. Locking for SCU accesses is handled for
|
|
* the caller.
|
|
*/
|
|
static int pmic_scu_ipc_battery_property_get(struct battery_property *prop)
|
|
{
|
|
u32 data[3];
|
|
u8 *p = (u8 *)&data[1];
|
|
int err = intel_scu_ipc_command(IPCMSG_BATTERY,
|
|
IPC_CMD_BATTERY_PROPERTY, NULL, 0, data, 3);
|
|
|
|
prop->capacity = data[0];
|
|
prop->crnt = *p++;
|
|
prop->volt = *p++;
|
|
prop->prot = *p++;
|
|
prop->prot2 = *p++;
|
|
prop->timer = *p++;
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* pmic_scu_ipc_set_charger - set charger
|
|
* @charger: charger to select
|
|
*
|
|
* Switch the charging mode for the SCU
|
|
*/
|
|
|
|
static int pmic_scu_ipc_set_charger(int charger)
|
|
{
|
|
return intel_scu_ipc_simple_command(IPCMSG_BATTERY, charger);
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_log_event - log battery events
|
|
* @event: battery event to be logged
|
|
* Context: can sleep
|
|
*
|
|
* There are multiple battery events which may be of interest to users;
|
|
* this battery function logs the different battery events onto the
|
|
* kernel log messages.
|
|
*/
|
|
static void pmic_battery_log_event(enum batt_event event)
|
|
{
|
|
printk(KERN_WARNING "pmic-battery: ");
|
|
switch (event) {
|
|
case BATT_EVENT_BATOVP_EXCPT:
|
|
printk(KERN_CONT "battery overvoltage condition\n");
|
|
break;
|
|
case BATT_EVENT_USBOVP_EXCPT:
|
|
printk(KERN_CONT "usb charger overvoltage condition\n");
|
|
break;
|
|
case BATT_EVENT_TEMP_EXCPT:
|
|
printk(KERN_CONT "high battery temperature condition\n");
|
|
break;
|
|
case BATT_EVENT_DCLMT_EXCPT:
|
|
printk(KERN_CONT "over battery charge current condition\n");
|
|
break;
|
|
default:
|
|
printk(KERN_CONT "charger/battery exception %d\n", event);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_read_status - read battery status information
|
|
* @pbi: device info structure to update the read information
|
|
* Context: can sleep
|
|
*
|
|
* PMIC power source information need to be updated based on the data read
|
|
* from the PMIC battery registers.
|
|
*
|
|
*/
|
|
static void pmic_battery_read_status(struct pmic_power_module_info *pbi)
|
|
{
|
|
unsigned int update_time_intrvl;
|
|
unsigned int chrg_val;
|
|
u32 ccval;
|
|
u8 r8;
|
|
struct battery_property batt_prop;
|
|
int batt_present = 0;
|
|
int usb_present = 0;
|
|
int batt_exception = 0;
|
|
|
|
/* make sure the last batt_status read happened delay_time before */
|
|
if (pbi->update_time && time_before(jiffies, pbi->update_time +
|
|
msecs_to_jiffies(delay_time)))
|
|
return;
|
|
|
|
update_time_intrvl = jiffies_to_msecs(jiffies - pbi->update_time);
|
|
pbi->update_time = jiffies;
|
|
|
|
/* read coulomb counter registers and schrgint register */
|
|
if (pmic_scu_ipc_battery_cc_read(&ccval)) {
|
|
dev_warn(pbi->dev, "%s(): ipc config cmd failed\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
|
|
if (intel_scu_ipc_ioread8(PMIC_BATT_CHR_SCHRGINT_ADDR, &r8)) {
|
|
dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* set pmic_power_module_info members based on pmic register values
|
|
* read.
|
|
*/
|
|
|
|
/* set batt_is_present */
|
|
if (r8 & PMIC_BATT_CHR_SBATDET_MASK) {
|
|
pbi->batt_is_present = PMIC_BATT_PRESENT;
|
|
batt_present = 1;
|
|
} else {
|
|
pbi->batt_is_present = PMIC_BATT_NOT_PRESENT;
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_UNKNOWN;
|
|
}
|
|
|
|
/* set batt_health */
|
|
if (batt_present) {
|
|
if (r8 & PMIC_BATT_CHR_SBATOVP_MASK) {
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
pmic_battery_log_event(BATT_EVENT_BATOVP_EXCPT);
|
|
batt_exception = 1;
|
|
} else if (r8 & PMIC_BATT_CHR_STEMP_MASK) {
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_OVERHEAT;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
pmic_battery_log_event(BATT_EVENT_TEMP_EXCPT);
|
|
batt_exception = 1;
|
|
} else {
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_GOOD;
|
|
if (r8 & PMIC_BATT_CHR_SDCLMT_MASK) {
|
|
/* PMIC will change charging current automatically */
|
|
pmic_battery_log_event(BATT_EVENT_DCLMT_EXCPT);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set usb_is_present */
|
|
if (r8 & PMIC_BATT_CHR_SUSBDET_MASK) {
|
|
pbi->usb_is_present = PMIC_USB_PRESENT;
|
|
usb_present = 1;
|
|
} else {
|
|
pbi->usb_is_present = PMIC_USB_NOT_PRESENT;
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
}
|
|
|
|
if (usb_present) {
|
|
if (r8 & PMIC_BATT_CHR_SUSBOVP_MASK) {
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
|
|
pmic_battery_log_event(BATT_EVENT_USBOVP_EXCPT);
|
|
} else {
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_GOOD;
|
|
}
|
|
}
|
|
|
|
chrg_val = ccval & PMIC_BATT_ADC_ACCCHRGVAL_MASK;
|
|
|
|
/* set batt_prev_charge_full to battery capacity the first time */
|
|
if (!pbi->is_dev_info_updated) {
|
|
if (pmic_scu_ipc_battery_property_get(&batt_prop)) {
|
|
dev_warn(pbi->dev, "%s(): ipc config cmd failed\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
pbi->batt_prev_charge_full = batt_prop.capacity;
|
|
}
|
|
|
|
/* set batt_status */
|
|
if (batt_present && !batt_exception) {
|
|
if (r8 & PMIC_BATT_CHR_SCOMP_MASK) {
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_FULL;
|
|
pbi->batt_prev_charge_full = chrg_val;
|
|
} else if (ccval & PMIC_BATT_ADC_ACCCHRG_MASK) {
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_DISCHARGING;
|
|
} else {
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_CHARGING;
|
|
}
|
|
}
|
|
|
|
/* set batt_charge_rate */
|
|
if (pbi->is_dev_info_updated && batt_present && !batt_exception) {
|
|
if (pbi->batt_status == POWER_SUPPLY_STATUS_DISCHARGING) {
|
|
if (pbi->batt_charge_now - chrg_val) {
|
|
pbi->batt_charge_rate = ((pbi->batt_charge_now -
|
|
chrg_val) * 1000 * 60) /
|
|
update_time_intrvl;
|
|
}
|
|
} else if (pbi->batt_status == POWER_SUPPLY_STATUS_CHARGING) {
|
|
if (chrg_val - pbi->batt_charge_now) {
|
|
pbi->batt_charge_rate = ((chrg_val -
|
|
pbi->batt_charge_now) * 1000 * 60) /
|
|
update_time_intrvl;
|
|
}
|
|
} else
|
|
pbi->batt_charge_rate = 0;
|
|
} else {
|
|
pbi->batt_charge_rate = -1;
|
|
}
|
|
|
|
/* batt_charge_now */
|
|
if (batt_present && !batt_exception)
|
|
pbi->batt_charge_now = chrg_val;
|
|
else
|
|
pbi->batt_charge_now = -1;
|
|
|
|
pbi->is_dev_info_updated = PMIC_BATT_DRV_INFO_UPDATED;
|
|
}
|
|
|
|
/**
|
|
* pmic_usb_get_property - usb power source get property
|
|
* @psy: usb power supply context
|
|
* @psp: usb power source property
|
|
* @val: usb power source property value
|
|
* Context: can sleep
|
|
*
|
|
* PMIC usb power source property needs to be provided to power_supply
|
|
* subsytem for it to provide the information to users.
|
|
*/
|
|
static int pmic_usb_get_property(struct power_supply *psy,
|
|
enum power_supply_property psp,
|
|
union power_supply_propval *val)
|
|
{
|
|
struct pmic_power_module_info *pbi = power_supply_get_drvdata(psy);
|
|
|
|
/* update pmic_power_module_info members */
|
|
pmic_battery_read_status(pbi);
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
val->intval = pbi->usb_is_present;
|
|
break;
|
|
case POWER_SUPPLY_PROP_HEALTH:
|
|
val->intval = pbi->usb_health;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline unsigned long mAStouAh(unsigned long v)
|
|
{
|
|
/* seconds to hours, mA to µA */
|
|
return (v * 1000) / 3600;
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_get_property - battery power source get property
|
|
* @psy: battery power supply context
|
|
* @psp: battery power source property
|
|
* @val: battery power source property value
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery power source property needs to be provided to power_supply
|
|
* subsytem for it to provide the information to users.
|
|
*/
|
|
static int pmic_battery_get_property(struct power_supply *psy,
|
|
enum power_supply_property psp,
|
|
union power_supply_propval *val)
|
|
{
|
|
struct pmic_power_module_info *pbi = power_supply_get_drvdata(psy);
|
|
|
|
/* update pmic_power_module_info members */
|
|
pmic_battery_read_status(pbi);
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_STATUS:
|
|
val->intval = pbi->batt_status;
|
|
break;
|
|
case POWER_SUPPLY_PROP_HEALTH:
|
|
val->intval = pbi->batt_health;
|
|
break;
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
val->intval = pbi->batt_is_present;
|
|
break;
|
|
case POWER_SUPPLY_PROP_CHARGE_NOW:
|
|
val->intval = mAStouAh(pbi->batt_charge_now);
|
|
break;
|
|
case POWER_SUPPLY_PROP_CHARGE_FULL:
|
|
val->intval = mAStouAh(pbi->batt_prev_charge_full);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_monitor - monitor battery status
|
|
* @work: work structure
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery status needs to be monitored for any change
|
|
* and information needs to be frequently updated.
|
|
*/
|
|
static void pmic_battery_monitor(struct work_struct *work)
|
|
{
|
|
struct pmic_power_module_info *pbi = container_of(work,
|
|
struct pmic_power_module_info, monitor_battery.work);
|
|
|
|
/* update pmic_power_module_info members */
|
|
pmic_battery_read_status(pbi);
|
|
queue_delayed_work(pbi->monitor_wqueue, &pbi->monitor_battery, HZ * 10);
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_set_charger - set battery charger
|
|
* @pbi: device info structure
|
|
* @chrg: charge mode to set battery charger in
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery charger needs to be enabled based on the usb charge
|
|
* capabilities connected to the platform.
|
|
*/
|
|
static int pmic_battery_set_charger(struct pmic_power_module_info *pbi,
|
|
enum batt_charge_type chrg)
|
|
{
|
|
int retval;
|
|
|
|
/* set usblmt bits and chrgcntl register bits appropriately */
|
|
switch (chrg) {
|
|
case BATT_USBOTG_500MA_CHARGE:
|
|
retval = pmic_scu_ipc_set_charger(PMIC_BATT_CHR_IPC_FCHRG_SUBID);
|
|
break;
|
|
case BATT_USBOTG_TRICKLE_CHARGE:
|
|
retval = pmic_scu_ipc_set_charger(PMIC_BATT_CHR_IPC_TCHRG_SUBID);
|
|
break;
|
|
default:
|
|
dev_warn(pbi->dev, "%s(): out of range usb charger "
|
|
"charge detected\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (retval) {
|
|
dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",
|
|
__func__);
|
|
return retval;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_interrupt_handler - pmic battery interrupt handler
|
|
* Context: interrupt context
|
|
*
|
|
* PMIC battery interrupt handler which will be called with either
|
|
* battery full condition occurs or usb otg & battery connect
|
|
* condition occurs.
|
|
*/
|
|
static irqreturn_t pmic_battery_interrupt_handler(int id, void *dev)
|
|
{
|
|
struct pmic_power_module_info *pbi = dev;
|
|
|
|
schedule_work(&pbi->handler);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_handle_intrpt - pmic battery service interrupt
|
|
* @work: work structure
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery needs to either update the battery status as full
|
|
* if it detects battery full condition caused the interrupt or needs
|
|
* to enable battery charger if it detects usb and battery detect
|
|
* caused the source of interrupt.
|
|
*/
|
|
static void pmic_battery_handle_intrpt(struct work_struct *work)
|
|
{
|
|
struct pmic_power_module_info *pbi = container_of(work,
|
|
struct pmic_power_module_info, handler);
|
|
enum batt_charge_type chrg;
|
|
u8 r8;
|
|
|
|
if (intel_scu_ipc_ioread8(PMIC_BATT_CHR_SCHRGINT_ADDR, &r8)) {
|
|
dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
/* find the cause of the interrupt */
|
|
if (r8 & PMIC_BATT_CHR_SBATDET_MASK) {
|
|
pbi->batt_is_present = PMIC_BATT_PRESENT;
|
|
} else {
|
|
pbi->batt_is_present = PMIC_BATT_NOT_PRESENT;
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_UNKNOWN;
|
|
return;
|
|
}
|
|
|
|
if (r8 & PMIC_BATT_CHR_EXCPT_MASK) {
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
pmic_battery_log_event(BATT_EVENT_EXCPT);
|
|
return;
|
|
} else {
|
|
pbi->batt_health = POWER_SUPPLY_HEALTH_GOOD;
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_GOOD;
|
|
}
|
|
|
|
if (r8 & PMIC_BATT_CHR_SCOMP_MASK) {
|
|
u32 ccval;
|
|
pbi->batt_status = POWER_SUPPLY_STATUS_FULL;
|
|
|
|
if (pmic_scu_ipc_battery_cc_read(&ccval)) {
|
|
dev_warn(pbi->dev, "%s(): ipc config cmd "
|
|
"failed\n", __func__);
|
|
return;
|
|
}
|
|
pbi->batt_prev_charge_full = ccval &
|
|
PMIC_BATT_ADC_ACCCHRGVAL_MASK;
|
|
return;
|
|
}
|
|
|
|
if (r8 & PMIC_BATT_CHR_SUSBDET_MASK) {
|
|
pbi->usb_is_present = PMIC_USB_PRESENT;
|
|
} else {
|
|
pbi->usb_is_present = PMIC_USB_NOT_PRESENT;
|
|
pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;
|
|
return;
|
|
}
|
|
|
|
/* setup battery charging */
|
|
|
|
#if 0
|
|
/* check usb otg power capability and set charger accordingly */
|
|
retval = langwell_udc_maxpower(&power);
|
|
if (retval) {
|
|
dev_warn(pbi->dev,
|
|
"%s(): usb otg power query failed with error code %d\n",
|
|
__func__, retval);
|
|
return;
|
|
}
|
|
|
|
if (power >= 500)
|
|
chrg = BATT_USBOTG_500MA_CHARGE;
|
|
else
|
|
#endif
|
|
chrg = BATT_USBOTG_TRICKLE_CHARGE;
|
|
|
|
/* enable battery charging */
|
|
if (pmic_battery_set_charger(pbi, chrg)) {
|
|
dev_warn(pbi->dev,
|
|
"%s(): failed to set up battery charging\n", __func__);
|
|
return;
|
|
}
|
|
|
|
dev_dbg(pbi->dev,
|
|
"pmic-battery: %s() - setting up battery charger successful\n",
|
|
__func__);
|
|
}
|
|
|
|
/*
|
|
* Description of power supplies
|
|
*/
|
|
static const struct power_supply_desc pmic_usb_desc = {
|
|
.name = "pmic-usb",
|
|
.type = POWER_SUPPLY_TYPE_USB,
|
|
.properties = pmic_usb_props,
|
|
.num_properties = ARRAY_SIZE(pmic_usb_props),
|
|
.get_property = pmic_usb_get_property,
|
|
};
|
|
|
|
static const struct power_supply_desc pmic_batt_desc = {
|
|
.name = "pmic-batt",
|
|
.type = POWER_SUPPLY_TYPE_BATTERY,
|
|
.properties = pmic_battery_props,
|
|
.num_properties = ARRAY_SIZE(pmic_battery_props),
|
|
.get_property = pmic_battery_get_property,
|
|
};
|
|
|
|
/**
|
|
* pmic_battery_probe - pmic battery initialize
|
|
* @irq: pmic battery device irq
|
|
* @dev: pmic battery device structure
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery initializes its internal data structue and other
|
|
* infrastructure components for it to work as expected.
|
|
*/
|
|
static int probe(int irq, struct device *dev)
|
|
{
|
|
int retval = 0;
|
|
struct pmic_power_module_info *pbi;
|
|
struct power_supply_config psy_cfg = {};
|
|
|
|
dev_dbg(dev, "pmic-battery: found pmic battery device\n");
|
|
|
|
pbi = kzalloc(sizeof(*pbi), GFP_KERNEL);
|
|
if (!pbi) {
|
|
dev_err(dev, "%s(): memory allocation failed\n",
|
|
__func__);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
pbi->dev = dev;
|
|
pbi->irq = irq;
|
|
dev_set_drvdata(dev, pbi);
|
|
psy_cfg.drv_data = pbi;
|
|
|
|
/* initialize all required framework before enabling interrupts */
|
|
INIT_WORK(&pbi->handler, pmic_battery_handle_intrpt);
|
|
INIT_DELAYED_WORK(&pbi->monitor_battery, pmic_battery_monitor);
|
|
pbi->monitor_wqueue =
|
|
create_singlethread_workqueue(dev_name(dev));
|
|
if (!pbi->monitor_wqueue) {
|
|
dev_err(dev, "%s(): wqueue init failed\n", __func__);
|
|
retval = -ESRCH;
|
|
goto wqueue_failed;
|
|
}
|
|
|
|
/* register interrupt */
|
|
retval = request_irq(pbi->irq, pmic_battery_interrupt_handler,
|
|
0, DRIVER_NAME, pbi);
|
|
if (retval) {
|
|
dev_err(dev, "%s(): cannot get IRQ\n", __func__);
|
|
goto requestirq_failed;
|
|
}
|
|
|
|
/* register pmic-batt with power supply subsystem */
|
|
pbi->batt = power_supply_register(dev, &pmic_usb_desc, &psy_cfg);
|
|
if (IS_ERR(pbi->batt)) {
|
|
dev_err(dev,
|
|
"%s(): failed to register pmic battery device with power supply subsystem\n",
|
|
__func__);
|
|
retval = PTR_ERR(pbi->batt);
|
|
goto power_reg_failed;
|
|
}
|
|
|
|
dev_dbg(dev, "pmic-battery: %s() - pmic battery device "
|
|
"registration with power supply subsystem successful\n",
|
|
__func__);
|
|
|
|
queue_delayed_work(pbi->monitor_wqueue, &pbi->monitor_battery, HZ * 1);
|
|
|
|
/* register pmic-usb with power supply subsystem */
|
|
pbi->usb = power_supply_register(dev, &pmic_batt_desc, &psy_cfg);
|
|
if (IS_ERR(pbi->usb)) {
|
|
dev_err(dev,
|
|
"%s(): failed to register pmic usb device with power supply subsystem\n",
|
|
__func__);
|
|
retval = PTR_ERR(pbi->usb);
|
|
goto power_reg_failed_1;
|
|
}
|
|
|
|
if (debug)
|
|
printk(KERN_INFO "pmic-battery: %s() - pmic usb device "
|
|
"registration with power supply subsystem successful\n",
|
|
__func__);
|
|
|
|
return retval;
|
|
|
|
power_reg_failed_1:
|
|
power_supply_unregister(pbi->batt);
|
|
power_reg_failed:
|
|
cancel_delayed_work_sync(&pbi->monitor_battery);
|
|
requestirq_failed:
|
|
destroy_workqueue(pbi->monitor_wqueue);
|
|
wqueue_failed:
|
|
kfree(pbi);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int platform_pmic_battery_probe(struct platform_device *pdev)
|
|
{
|
|
return probe(pdev->id, &pdev->dev);
|
|
}
|
|
|
|
/**
|
|
* pmic_battery_remove - pmic battery finalize
|
|
* @dev: pmic battery device structure
|
|
* Context: can sleep
|
|
*
|
|
* PMIC battery finalizes its internal data structue and other
|
|
* infrastructure components that it initialized in
|
|
* pmic_battery_probe.
|
|
*/
|
|
|
|
static int platform_pmic_battery_remove(struct platform_device *pdev)
|
|
{
|
|
struct pmic_power_module_info *pbi = platform_get_drvdata(pdev);
|
|
|
|
free_irq(pbi->irq, pbi);
|
|
cancel_delayed_work_sync(&pbi->monitor_battery);
|
|
destroy_workqueue(pbi->monitor_wqueue);
|
|
|
|
power_supply_unregister(pbi->usb);
|
|
power_supply_unregister(pbi->batt);
|
|
|
|
cancel_work_sync(&pbi->handler);
|
|
kfree(pbi);
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver platform_pmic_battery_driver = {
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
},
|
|
.probe = platform_pmic_battery_probe,
|
|
.remove = platform_pmic_battery_remove,
|
|
};
|
|
|
|
module_platform_driver(platform_pmic_battery_driver);
|
|
|
|
MODULE_AUTHOR("Nithish Mahalingam <nithish.mahalingam@intel.com>");
|
|
MODULE_DESCRIPTION("Intel Moorestown PMIC Battery Driver");
|
|
MODULE_LICENSE("GPL");
|