/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * 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.
 */
/*
 * Qualcomm PMIC PM8xxx Battery Alarm driver
 *
 */

#define pr_fmt(fmt)	"%s: " fmt, __func__

#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/mfd/pm8xxx/core.h>
#include <linux/mfd/pm8xxx/batt-alarm.h>

/* Available voltage threshold values */
#define THRESHOLD_MIN_MV		2500
#define THRESHOLD_MAX_MV		5675
#define THRESHOLD_STEP_MV		25

/* Register bit definitions */

/* Threshold register */
#define THRESHOLD_UPPER_MASK		0xF0
#define THRESHOLD_LOWER_MASK		0x0F
#define THRESHOLD_UPPER_SHIFT		4
#define THRESHOLD_LOWER_SHIFT		0

/* CTRL 1 register */
#define CTRL1_BATT_ALARM_ENABLE_MASK	0x80
#define CTRL1_BATT_ALARM_ENABLE		0x80
#define CTRL1_BATT_ALARM_DISABLE	0x00
#define CTRL1_HOLD_TIME_MASK		0x70
#define CTRL1_STATUS_UPPER_MASK		0x02
#define CTRL1_STATUS_LOWER_MASK		0x01
#define CTRL1_HOLD_TIME_SHIFT		4
#define CTRL1_HOLD_TIME_MIN		0
#define CTRL1_HOLD_TIME_MAX		7

/* CTRL 2 register */
#define CTRL2_COMP_UPPER_DISABLE_MASK	0x80
#define CTRL2_COMP_UPPER_ENABLE		0x00
#define CTRL2_COMP_UPPER_DISABLE	0x80
#define CTRL2_COMP_LOWER_DISABLE_MASK	0x40
#define CTRL2_COMP_LOWER_ENABLE		0x00
#define CTRL2_COMP_LOWER_DISABLE	0x40
#define CTRL2_FINE_STEP_UPPER_MASK	0x30
#define CTRL2_RANGE_EXT_UPPER_MASK	0x08
#define CTRL2_FINE_STEP_LOWER_MASK	0x06
#define CTRL2_RANGE_EXT_LOWER_MASK	0x01
#define CTRL2_FINE_STEP_UPPER_SHIFT	4
#define CTRL2_FINE_STEP_LOWER_SHIFT	1

/* PWM control register */
#define PWM_CTRL_ALARM_EN_MASK		0xC0
#define PWM_CTRL_ALARM_EN_NEVER		0x00
#define PWM_CTRL_ALARM_EN_TCXO		0x40
#define PWM_CTRL_ALARM_EN_PWM		0x80
#define PWM_CTRL_ALARM_EN_ALWAYS	0xC0
#define PWM_CTRL_PRE_MASK		0x38
#define PWM_CTRL_DIV_MASK		0x07
#define PWM_CTRL_PRE_SHIFT		3
#define PWM_CTRL_DIV_SHIFT		0
#define PWM_CTRL_PRE_MIN		0
#define PWM_CTRL_PRE_MAX		7
#define PWM_CTRL_DIV_MIN		1
#define PWM_CTRL_DIV_MAX		7

/* PWM control input range */
#define PWM_CTRL_PRE_INPUT_MIN		2
#define PWM_CTRL_PRE_INPUT_MAX		9
#define PWM_CTRL_DIV_INPUT_MIN		2
#define PWM_CTRL_DIV_INPUT_MAX		8

/* Available voltage threshold values */
#define THRESHOLD_BASIC_MIN_MV		2800
#define THRESHOLD_EXT_MIN_MV		4400

/*
 * Default values used during initialization:
 * Slowest PWM rate to ensure minimal status jittering when crossing thresholds.
 * Largest hold time also helps reduce status value jittering.  Comparators
 * are disabled by default and must be turned on by calling
 * pm8xxx_batt_alarm_state_set.
 */
#define DEFAULT_THRESHOLD_LOWER		3200
#define DEFAULT_THRESHOLD_UPPER		4300
#define DEFAULT_HOLD_TIME		PM8XXX_BATT_ALARM_HOLD_TIME_16_MS
#define DEFAULT_USE_PWM			1
#define DEFAULT_PWM_SCALER		9
#define DEFAULT_PWM_DIVIDER		8
#define DEFAULT_LOWER_ENABLE		0
#define DEFAULT_UPPER_ENABLE		0

struct pm8xxx_batt_alarm_chip {
	struct pm8xxx_batt_alarm_core_data	cdata;
	struct srcu_notifier_head		irq_notifier_list;
	struct work_struct			irq_work;
	struct device				*dev;
	struct mutex				lock;
	unsigned int				irq;
	int					notifier_count;
	u8					reg_threshold;
	u8					reg_ctrl1;
	u8					reg_ctrl2;
	u8					reg_pwm_ctrl;
};
static struct pm8xxx_batt_alarm_chip *the_battalarm;

static int pm8xxx_reg_write(struct pm8xxx_batt_alarm_chip *chip, u16 addr,
				u8 val, u8 mask, u8 *reg_save)
{
	int rc = 0;
	u8 reg;

	reg = (*reg_save & ~mask) | (val & mask);
	if (reg != *reg_save)
		rc = pm8xxx_writeb(chip->dev->parent, addr, reg);
	if (rc)
		pr_err("pm8xxx_writeb failed; addr=%03X, rc=%d\n", addr, rc);
	else
		*reg_save = reg;
	return rc;
}

/**
 * pm8xxx_batt_alarm_enable - enable one of the battery voltage threshold
 *			      comparators
 * @comparator:	selects which comparator to enable
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_enable(enum pm8xxx_batt_alarm_comparator comparator)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;
	u8 val_ctrl2 = 0, mask_ctrl2 = 0;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENODEV;
	}

	if (comparator < 0 || comparator > PM8XXX_BATT_ALARM_UPPER_COMPARATOR) {
		pr_err("invalid comparator ID number: %d\n", comparator);
		return -EINVAL;
	}

	if (comparator == PM8XXX_BATT_ALARM_LOWER_COMPARATOR) {
		val_ctrl2 = CTRL2_COMP_LOWER_ENABLE;
		mask_ctrl2 = CTRL2_COMP_LOWER_DISABLE_MASK;
	} else {
		val_ctrl2 = CTRL2_COMP_UPPER_ENABLE;
		mask_ctrl2 = CTRL2_COMP_UPPER_DISABLE_MASK;
	}

	mutex_lock(&chip->lock);

	/* Enable the battery alarm block. */
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl1,
				CTRL1_BATT_ALARM_ENABLE,
				CTRL1_BATT_ALARM_ENABLE_MASK, &chip->reg_ctrl1);
	if (rc)
		goto bail;

	/* Enable the individual comparators. */
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl2, val_ctrl2,
				mask_ctrl2, &chip->reg_ctrl2);

bail:
	mutex_unlock(&chip->lock);
	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_enable);

/**
 * pm8xxx_batt_alarm_disable - disable one of the battery voltage threshold
 *			       comparators
 * @comparator:	selects which comparator to disable
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_disable(enum pm8xxx_batt_alarm_comparator comparator)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;
	u8 val_ctrl1 = 0, val_ctrl2 = 0, mask_ctrl2 = 0;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENODEV;
	}

	if (comparator < 0 || comparator > PM8XXX_BATT_ALARM_UPPER_COMPARATOR) {
		pr_err("invalid comparator ID number: %d\n", comparator);
		return -EINVAL;
	}

	if (comparator == PM8XXX_BATT_ALARM_LOWER_COMPARATOR) {
		val_ctrl2 = CTRL2_COMP_LOWER_DISABLE;
		mask_ctrl2 = CTRL2_COMP_LOWER_DISABLE_MASK;
	} else {
		val_ctrl2 = CTRL2_COMP_UPPER_DISABLE;
		mask_ctrl2 = CTRL2_COMP_UPPER_DISABLE_MASK;
	}

	mutex_lock(&chip->lock);

	/* Disable the specified comparator. */
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl2, val_ctrl2,
				mask_ctrl2, &chip->reg_ctrl2);
	if (rc)
		goto bail;

	/* Disable the battery alarm block if both comparators are disabled. */
	val_ctrl2 = chip->reg_ctrl2
	      & (CTRL2_COMP_LOWER_DISABLE_MASK | CTRL2_COMP_UPPER_DISABLE_MASK);
	if (val_ctrl2 == (CTRL2_COMP_LOWER_DISABLE | CTRL2_COMP_UPPER_DISABLE))
		val_ctrl1 = CTRL1_BATT_ALARM_DISABLE;
	else
		val_ctrl1 = CTRL1_BATT_ALARM_ENABLE;

	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl1, val_ctrl1,
				CTRL1_BATT_ALARM_ENABLE_MASK, &chip->reg_ctrl1);

bail:
	mutex_unlock(&chip->lock);
	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_disable);

/**
 * pm8xxx_batt_alarm_threshold_set - set the lower and upper alarm thresholds
 * @comparator:		selects which comparator to set the threshold of
 * @threshold_mV:	battery voltage threshold in millivolts
 *			set points = 2500-5675 mV in 25 mV steps
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_threshold_set(
	enum pm8xxx_batt_alarm_comparator comparator, int threshold_mV)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int step, fine_step, rc;
	u8 val_threshold = 0, val_ctrl2 = 0;
	int threshold_mask, threshold_shift, range_ext_mask, fine_step_mask;
	int fine_step_shift;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	if (comparator < 0 || comparator > PM8XXX_BATT_ALARM_UPPER_COMPARATOR) {
		pr_err("invalid comparator ID number: %d\n", comparator);
		return -EINVAL;
	}

	if (threshold_mV < THRESHOLD_MIN_MV
	    || threshold_mV > THRESHOLD_MAX_MV) {
		pr_err("threshold value, %d mV, is outside of allowable "
			"range: [%d, %d] mV\n", threshold_mV,
			THRESHOLD_MIN_MV, THRESHOLD_MAX_MV);
		return -EINVAL;
	}

	if (comparator == PM8XXX_BATT_ALARM_LOWER_COMPARATOR) {
		threshold_mask = THRESHOLD_LOWER_MASK;
		threshold_shift = THRESHOLD_LOWER_SHIFT;
		range_ext_mask = CTRL2_RANGE_EXT_LOWER_MASK;
		fine_step_mask = CTRL2_FINE_STEP_LOWER_MASK;
		fine_step_shift = CTRL2_FINE_STEP_LOWER_SHIFT;
	} else {
		threshold_mask = THRESHOLD_UPPER_MASK;
		threshold_shift = THRESHOLD_UPPER_SHIFT;
		range_ext_mask = CTRL2_RANGE_EXT_UPPER_MASK;
		fine_step_mask = CTRL2_FINE_STEP_UPPER_MASK;
		fine_step_shift = CTRL2_FINE_STEP_UPPER_SHIFT;
	}

	/* Determine register settings to achieve the threshold. */
	if (threshold_mV < THRESHOLD_BASIC_MIN_MV) {
		/* Extended low range */
		val_ctrl2 |= range_ext_mask;

		step = (threshold_mV - THRESHOLD_MIN_MV) / THRESHOLD_STEP_MV;

		fine_step = step & 0x3;
		/* Extended low range is for steps 0 to 2 */
		step >>= 2;
	} else if (threshold_mV >= THRESHOLD_EXT_MIN_MV) {
		/* Extended high range */
		val_ctrl2 |= range_ext_mask;

		step = (threshold_mV - THRESHOLD_EXT_MIN_MV)
			/ THRESHOLD_STEP_MV;

		fine_step = step & 0x3;
		/* Extended high range is for steps 3 to 15 */
		step = (step >> 2) + 3;
	} else {
		/* Basic range */
		step = (threshold_mV - THRESHOLD_BASIC_MIN_MV)
			/ THRESHOLD_STEP_MV;

		fine_step = step & 0x3;
		step >>= 2;
	}
	val_threshold |= step << threshold_shift;
	val_ctrl2 |= (fine_step << fine_step_shift) & fine_step_mask;

	mutex_lock(&chip->lock);
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_threshold,
			val_threshold, threshold_mask, &chip->reg_threshold);
	if (rc)
		goto bail;

	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl2, val_ctrl2,
			range_ext_mask | fine_step_mask, &chip->reg_ctrl2);

bail:
	mutex_unlock(&chip->lock);
	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_threshold_set);

/**
 * pm8xxx_batt_alarm_status_read - get status of both threshold comparators
 *
 * RETURNS:	< 0	   = error
 *		  0	   = battery voltage ok
 *		BIT(0) set = battery voltage below lower threshold
 *		BIT(1) set = battery voltage above upper threshold
 */
int pm8xxx_batt_alarm_status_read(void)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int status, rc;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	mutex_lock(&chip->lock);
	rc = pm8xxx_readb(chip->dev->parent, chip->cdata.reg_addr_ctrl1,
			  &chip->reg_ctrl1);

	status = ((chip->reg_ctrl1 & CTRL1_STATUS_LOWER_MASK)
			? PM8XXX_BATT_ALARM_STATUS_BELOW_LOWER : 0)
		| ((chip->reg_ctrl1 & CTRL1_STATUS_UPPER_MASK)
			? PM8XXX_BATT_ALARM_STATUS_ABOVE_UPPER : 0);
	mutex_unlock(&chip->lock);

	if (rc) {
		pr_err("pm8xxx_readb failed, rc=%d\n", rc);
		return rc;
	}

	return status;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_status_read);

/**
 * pm8xxx_batt_alarm_hold_time_set - set hold time of interrupt output *
 * @hold_time:	amount of time that battery voltage must remain outside of the
 *		threshold range before the battery alarm interrupt triggers
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_hold_time_set(enum pm8xxx_batt_alarm_hold_time hold_time)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;
	u8 reg_ctrl1 = 0;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	if (hold_time < CTRL1_HOLD_TIME_MIN
	    || hold_time > CTRL1_HOLD_TIME_MAX) {

		pr_err("hold time, %d, is outside of allowable range: "
			"[%d, %d]\n", hold_time, CTRL1_HOLD_TIME_MIN,
			CTRL1_HOLD_TIME_MAX);
		return -EINVAL;
	}

	reg_ctrl1 = hold_time << CTRL1_HOLD_TIME_SHIFT;

	mutex_lock(&chip->lock);
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_ctrl1, reg_ctrl1,
			      CTRL1_HOLD_TIME_MASK, &chip->reg_ctrl1);
	mutex_unlock(&chip->lock);

	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_hold_time_set);

/**
 * pm8xxx_batt_alarm_pwm_rate_set - set battery alarm update rate *
 * @use_pwm:		1 = use PWM update rate, 0 = comparators always active
 * @clock_scaler:	PWM clock scaler = 2 to 9
 * @clock_divider:	PWM clock divider = 2 to 8
 *
 * This function sets the rate at which the battery alarm module enables
 * the threshold comparators.  The rate is determined by the following equation:
 *
 * f_update = (1024 Hz) / (clock_divider * (2 ^ clock_scaler))
 *
 * Thus, the update rate can range from 0.25 Hz to 128 Hz.
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_pwm_rate_set(int use_pwm, int clock_scaler,
				   int clock_divider)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;
	u8 reg_pwm_ctrl = 0, mask = 0;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	if (use_pwm && (clock_scaler < PWM_CTRL_PRE_INPUT_MIN
	    || clock_scaler > PWM_CTRL_PRE_INPUT_MAX)) {
		pr_err("PWM clock scaler, %d, is outside of allowable range: "
			"[%d, %d]\n", clock_scaler, PWM_CTRL_PRE_INPUT_MIN,
			PWM_CTRL_PRE_INPUT_MAX);
		return -EINVAL;
	}

	if (use_pwm && (clock_divider < PWM_CTRL_DIV_INPUT_MIN
	    || clock_divider > PWM_CTRL_DIV_INPUT_MAX)) {
		pr_err("PWM clock divider, %d, is outside of allowable range: "
			"[%d, %d]\n", clock_divider, PWM_CTRL_DIV_INPUT_MIN,
			PWM_CTRL_DIV_INPUT_MAX);
		return -EINVAL;
	}

	if (!use_pwm) {
		/* Turn off PWM control and always enable. */
		reg_pwm_ctrl = PWM_CTRL_ALARM_EN_ALWAYS;
		mask = PWM_CTRL_ALARM_EN_MASK;
	} else {
		/* Use PWM control. */
		reg_pwm_ctrl = PWM_CTRL_ALARM_EN_PWM;
		mask = PWM_CTRL_ALARM_EN_MASK | PWM_CTRL_PRE_MASK
			| PWM_CTRL_DIV_MASK;

		clock_scaler -= PWM_CTRL_PRE_INPUT_MIN - PWM_CTRL_PRE_MIN;
		clock_divider -= PWM_CTRL_DIV_INPUT_MIN - PWM_CTRL_DIV_MIN;

		reg_pwm_ctrl |= (clock_scaler << PWM_CTRL_PRE_SHIFT)
				& PWM_CTRL_PRE_MASK;
		reg_pwm_ctrl |= (clock_divider << PWM_CTRL_DIV_SHIFT)
				& PWM_CTRL_DIV_MASK;
	}

	mutex_lock(&chip->lock);
	rc = pm8xxx_reg_write(chip, chip->cdata.reg_addr_pwm_ctrl, reg_pwm_ctrl,
			      mask, &chip->reg_pwm_ctrl);
	mutex_unlock(&chip->lock);

	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_pwm_rate_set);

/*
 * Handle the BATT_ALARM interrupt:
 * Battery voltage is above or below threshold range.
 */
static irqreturn_t pm8xxx_batt_alarm_isr(int irq, void *data)
{
	struct pm8xxx_batt_alarm_chip *chip = data;

	disable_irq_nosync(chip->irq);
	schedule_work(&chip->irq_work);

	return IRQ_HANDLED;
}

static void pm8xxx_batt_alarm_isr_work(struct work_struct *work)
{
	struct pm8xxx_batt_alarm_chip *chip
		= container_of(work, struct pm8xxx_batt_alarm_chip, irq_work);
	int status;

	if (!chip)
		return;

	status = pm8xxx_batt_alarm_status_read();

	if (status < 0)
		pr_err("failed to read status, rc=%d\n", status);
	else
		srcu_notifier_call_chain(&chip->irq_notifier_list,
						status, NULL);

	enable_irq(chip->irq);
}

/**
 * pm8xxx_batt_alarm_register_notifier - register a notifier to run when a
 *	battery voltage change interrupt fires
 * @nb:	notifier block containing callback function to register
 *
 * nb->notifier_call must point to a function of this form -
 * int (*notifier_call)(struct notifier_block *nb, unsigned long status,
 *			void *unused);
 * "status" will receive the battery alarm status; "unused" will be NULL.
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_register_notifier(struct notifier_block *nb)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	rc = srcu_notifier_chain_register(&chip->irq_notifier_list, nb);
	mutex_lock(&chip->lock);
	if (rc == 0) {
		if (chip->notifier_count == 0) {
			enable_irq(chip->irq);
			rc = irq_set_irq_wake(chip->irq, 1);
		}

		chip->notifier_count++;
	}

	mutex_unlock(&chip->lock);
	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_register_notifier);

/**
 * pm8xxx_batt_alarm_unregister_notifier - unregister a notifier that is run
 *	when a battery voltage change interrupt fires
 * @nb:	notifier block containing callback function to unregister
 *
 * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
 */
int pm8xxx_batt_alarm_unregister_notifier(struct notifier_block *nb)
{
	struct pm8xxx_batt_alarm_chip *chip = the_battalarm;
	int rc;

	if (!chip) {
		pr_err("no battery alarm device found.\n");
		return -ENXIO;
	}

	rc = srcu_notifier_chain_unregister(&chip->irq_notifier_list, nb);
	if (rc == 0) {
		mutex_lock(&chip->lock);

		chip->notifier_count--;

		if (chip->notifier_count == 0) {
			rc = irq_set_irq_wake(chip->irq, 0);
			disable_irq(chip->irq);
		}

		WARN_ON(chip->notifier_count < 0);

		mutex_unlock(&chip->lock);
	}

	return rc;
}
EXPORT_SYMBOL(pm8xxx_batt_alarm_unregister_notifier);

static int pm8xxx_batt_alarm_reg_init(struct pm8xxx_batt_alarm_chip *chip)
{
	int rc = 0;

	/* save the current register states */
	rc = pm8xxx_readb(chip->dev->parent, chip->cdata.reg_addr_threshold,
			  &chip->reg_threshold);
	if (rc)
		goto bail;

	rc = pm8xxx_readb(chip->dev->parent, chip->cdata.reg_addr_ctrl1,
			  &chip->reg_ctrl1);
	if (rc)
		goto bail;

	rc = pm8xxx_readb(chip->dev->parent, chip->cdata.reg_addr_ctrl2,
			  &chip->reg_ctrl2);
	if (rc)
		goto bail;

	rc = pm8xxx_readb(chip->dev->parent, chip->cdata.reg_addr_pwm_ctrl,
			  &chip->reg_pwm_ctrl);
	if (rc)
		goto bail;

bail:
	if (rc)
		pr_err("pm8xxx_readb failed; initial register states "
			"unknown, rc=%d\n", rc);
	return rc;
}

/* TODO: should this default setting function be removed? */
static int pm8xxx_batt_alarm_config_defaults(void)
{
	int rc = 0;

	/* Use default values when no platform data is provided. */
	rc = pm8xxx_batt_alarm_threshold_set(PM8XXX_BATT_ALARM_LOWER_COMPARATOR,
		DEFAULT_THRESHOLD_LOWER);
	if (rc) {
		pr_err("threshold_set failed, rc=%d\n", rc);
		goto done;
	}

	rc = pm8xxx_batt_alarm_threshold_set(PM8XXX_BATT_ALARM_UPPER_COMPARATOR,
		DEFAULT_THRESHOLD_UPPER);
	if (rc) {
		pr_err("threshold_set failed, rc=%d\n", rc);
		goto done;
	}

	rc = pm8xxx_batt_alarm_hold_time_set(DEFAULT_HOLD_TIME);
	if (rc) {
		pr_err("hold_time_set failed, rc=%d\n", rc);
		goto done;
	}

	rc = pm8xxx_batt_alarm_pwm_rate_set(DEFAULT_USE_PWM,
			DEFAULT_PWM_SCALER, DEFAULT_PWM_DIVIDER);
	if (rc) {
		pr_err("pwm_rate_set failed, rc=%d\n", rc);
		goto done;
	}

	rc = pm8xxx_batt_alarm_disable(PM8XXX_BATT_ALARM_LOWER_COMPARATOR);
	if (rc) {
		pr_err("disable lower failed, rc=%d\n", rc);
		goto done;
	}

	rc = pm8xxx_batt_alarm_disable(PM8XXX_BATT_ALARM_UPPER_COMPARATOR);
	if (rc) {
		pr_err("disable upper failed, rc=%d\n", rc);
		goto done;
	}

done:
	return rc;
}

static int __devinit pm8xxx_batt_alarm_probe(struct platform_device *pdev)
{
	const struct pm8xxx_batt_alarm_core_data *cdata
			= pdev->dev.platform_data;
	struct pm8xxx_batt_alarm_chip *chip;
	struct resource *res;
	int rc;

	if (the_battalarm) {
		pr_err("A PMIC battery alarm device has already probed.\n");
		return -ENODEV;
	}

	if (!cdata) {
		pr_err("missing core data\n");
		return -EINVAL;
	}

	if (!cdata->irq_name) {
		pr_err("missing IRQ name\n");
		return -EINVAL;
	}

	chip = kzalloc(sizeof(struct pm8xxx_batt_alarm_chip), GFP_KERNEL);
	if (chip == NULL) {
		pr_err("kzalloc() failed.\n");
		return -ENOMEM;
	}

	res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
		cdata->irq_name);
	if (res) {
		chip->irq = res->start;
	} else {
		pr_err("Battery alarm IRQ not specified\n");
		rc = -EINVAL;
		goto err_free_chip;
	}

	chip->dev = &pdev->dev;
	memcpy(&(chip->cdata), cdata,
		sizeof(struct pm8xxx_batt_alarm_core_data));

	srcu_init_notifier_head(&chip->irq_notifier_list);

	chip->notifier_count = 0;
	mutex_init(&chip->lock);

	the_battalarm = chip;

	rc = pm8xxx_batt_alarm_reg_init(chip);
	if (rc)
		goto err_free_mutex;

	rc = pm8xxx_batt_alarm_config_defaults();
	if (rc)
		goto err_free_mutex;

	INIT_WORK(&chip->irq_work, pm8xxx_batt_alarm_isr_work);

/* TODO: Is it best to trigger on both edges? Should this be configurable? */
	rc = request_irq(chip->irq, pm8xxx_batt_alarm_isr,
		IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, cdata->irq_name,
		chip);
	if (rc < 0) {
		pr_err("request_irq(%d) failed, rc=%d\n", chip->irq, rc);
		goto err_cancel_work;
	}

	/* Disable the IRQ until a notifier is registered. */
	disable_irq(chip->irq);

	platform_set_drvdata(pdev, chip);

	return 0;

err_cancel_work:
	cancel_work_sync(&chip->irq_work);
err_free_mutex:
	mutex_destroy(&chip->lock);
	srcu_cleanup_notifier_head(&chip->irq_notifier_list);
err_free_chip:
	kfree(chip);
	the_battalarm = NULL;

	return rc;
}

static int __devexit pm8xxx_batt_alarm_remove(struct platform_device *pdev)
{
	struct pm8xxx_batt_alarm_chip *chip = platform_get_drvdata(pdev);

	if (chip) {
		platform_set_drvdata(pdev, NULL);
		irq_set_irq_wake(chip->irq, 0);
		free_irq(chip->irq, chip);
		cancel_work_sync(&chip->irq_work);
		srcu_cleanup_notifier_head(&chip->irq_notifier_list);
		mutex_destroy(&chip->lock);
		kfree(chip);
		the_battalarm = NULL;
	}

	return 0;
}

static struct platform_driver pm8xxx_batt_alarm_driver = {
	.probe	= pm8xxx_batt_alarm_probe,
	.remove	= __devexit_p(pm8xxx_batt_alarm_remove),
	.driver	= {
		.name = PM8XXX_BATT_ALARM_DEV_NAME,
		.owner = THIS_MODULE,
	},
};

static int __init pm8xxx_batt_alarm_init(void)
{
	return platform_driver_register(&pm8xxx_batt_alarm_driver);
}

static void __exit pm8xxx_batt_alarm_exit(void)
{
	platform_driver_unregister(&pm8xxx_batt_alarm_driver);
}

module_init(pm8xxx_batt_alarm_init);
module_exit(pm8xxx_batt_alarm_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("PMIC PM8xxx Battery Alarm");
MODULE_VERSION("1.0");
MODULE_ALIAS("platform:" PM8XXX_BATT_ALARM_DEV_NAME);