cregit-Linux how code gets into the kernel

Release 4.7 drivers/power/intel_mid_battery.c

Directory: drivers/power
/*
 * 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);
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam2492.31%150.00%


arjan van de venarjan van de ven27.69%150.00%


Total26100.00%2100.00%



/**
 *      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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam9998.02%150.00%


shuduo sangshuduo sang21.98%150.00%


Total101100.00%2100.00%



/**
 *      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);
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam1588.24%150.00%


shuduo sangshuduo sang211.76%150.00%


Total17100.00%2100.00%



/**
 * 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;
	}
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam72100.00%1100.00%


Total72100.00%1100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam55497.54%150.00%


major leemajor lee142.46%150.00%


Total568100.00%2100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam7398.65%150.00%


krzysztof kozlowskikrzysztof kozlowski11.35%150.00%


Total74100.00%2100.00%






static inline unsigned long mAStouAh(unsigned long v)
{
	/* seconds to hours, mA to µA */
	return (v * 1000) / 3600;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam1881.82%150.00%


alan coxalan cox418.18%150.00%


Total22100.00%2100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam11599.14%150.00%


krzysztof kozlowskikrzysztof kozlowski10.86%150.00%


Total116100.00%2100.00%



/**
 * 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);
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam50100.00%1100.00%


Total50100.00%1100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam87100.00%1100.00%


Total87100.00%1100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam31100.00%1100.00%


Total31100.00%1100.00%



/**
 * 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__);
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam267100.00%1100.00%


Total267100.00%1100.00%



/*
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam31586.07%125.00%


krzysztof kozlowskikrzysztof kozlowski5013.66%250.00%


tejun heotejun heo10.27%125.00%


Total366100.00%4100.00%






static int platform_pmic_battery_probe(struct platform_device *pdev)
{
	return probe(pdev->id, &pdev->dev);
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam24100.00%1100.00%


Total24100.00%1100.00%



/**
 * 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;
}


Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam6688.00%125.00%


tejun heotejun heo810.67%250.00%


jingoo hanjingoo han11.33%125.00%


Total75100.00%4100.00%




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");

Overall Contributors
PersonTokensPropCommitsCommitProp
nithish mahalingamnithish mahalingam219893.06%19.09%


krzysztof kozlowskikrzysztof kozlowski1275.38%218.18%


major leemajor lee150.64%19.09%


tejun heotejun heo90.38%218.18%


alan coxalan cox40.17%19.09%


shuduo sangshuduo sang40.17%19.09%


axel linaxel lin20.08%19.09%


arjan van de venarjan van de ven20.08%19.09%


jingoo hanjingoo han10.04%19.09%


Total2362100.00%11100.00%

  
Directory: drivers/power



Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}