drivers/misc/pmic8058-batt-alarm.c - fp2-dev/kernel/msm - Gitiles

 /* 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 8058 Battery Alarm Device 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/pmic8058-batt-alarm.h>
 #include <linux/mfd/pmic8058.h>

 /* PMIC 8058 Battery Alarm SSBI registers */
 #define	REG_THRESHOLD			0x023
 #define	REG_CTRL1			0x024
 #define	REG_CTRL2			0x0AA
 #define	REG_PWM_CTRL			0x0A3

 /* 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_EN_MASK	0x80
 #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_LOWER_DISABLE_MASK	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
  * pm8058_batt_alarm_state_set.
  */
 #define DEFAULT_THRESHOLD_LOWER		3200
 #define DEFAULT_THRESHOLD_UPPER		4300
 #define DEFAULT_HOLD_TIME		PM8058_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 pm8058_batt_alarm_device {
 	struct srcu_notifier_head		irq_notifier_list;
 	struct pm8058_chip			*pm_chip;
 	struct mutex				batt_mutex;
 	unsigned int				irq;
 	int					notifier_count;
 	u8					reg_threshold;
 	u8					reg_ctrl1;
 	u8					reg_ctrl2;
 	u8					reg_pwm_ctrl;
 };
 static struct pm8058_batt_alarm_device *the_battalarm;

 static int pm8058_reg_write(struct pm8058_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 = pm8058_write(chip, addr, &reg, 1);
 	if (rc)
 		pr_err("pm8058_write failed; addr=%03X, rc=%d\n", addr, rc);
 	else
 		*reg_save = reg;
 	return rc;
 }

 /**
  * pm8058_batt_alarm_state_set - enable or disable the threshold comparators
  * @enable_lower_comparator: 1 = enable comparator, 0 = disable comparator
  * @enable_upper_comparator: 1 = enable comparator, 0 = disable comparator
  *
  * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
  */
 int pm8058_batt_alarm_state_set(int enable_lower_comparator,
 				int enable_upper_comparator)
 {
 	struct pm8058_batt_alarm_device *battdev = the_battalarm;
 	int rc;
 	u8 reg_ctrl1 = 0, reg_ctrl2 = 0;

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

 	if (!enable_lower_comparator)
 		reg_ctrl2 |= CTRL2_COMP_LOWER_DISABLE_MASK;
 	if (!enable_upper_comparator)
 		reg_ctrl2 |= CTRL2_COMP_UPPER_DISABLE_MASK;

 	if (enable_lower_comparator || enable_upper_comparator)
 		reg_ctrl1 = CTRL1_BATT_ALARM_EN_MASK;

 	mutex_lock(&battdev->batt_mutex);
 	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL1, reg_ctrl1,
 				CTRL1_BATT_ALARM_EN_MASK, &battdev->reg_ctrl1);
 	if (rc)
 		goto bail;

 	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL2, reg_ctrl2,
 		CTRL2_COMP_LOWER_DISABLE_MASK | CTRL2_COMP_UPPER_DISABLE_MASK,
 		&battdev->reg_ctrl2);

 bail:
 	mutex_unlock(&battdev->batt_mutex);
 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_state_set);

 /**
  * pm8058_batt_alarm_threshold_set - set the lower and upper alarm thresholds
  * @lower_threshold_mV: battery undervoltage threshold in millivolts
  * @upper_threshold_mV: battery overvoltage threshold in millivolts
  *
  * RETURNS: an appropriate -ERRNO error value on error, or zero for success.
  */
 int pm8058_batt_alarm_threshold_set(int lower_threshold_mV,
 				    int upper_threshold_mV)
 {
 	struct pm8058_batt_alarm_device *battdev = the_battalarm;
 	int step, fine_step, rc;
 	u8 reg_threshold = 0, reg_ctrl2 = 0;

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

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

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

 	if (upper_threshold_mV < lower_threshold_mV) {
 		pr_err("lower threshold value, %d mV, must be <= upper "
 			"threshold value, %d mV\n", lower_threshold_mV,
 			upper_threshold_mV);
 		return -EINVAL;
 	}

 	/* Determine register settings for lower threshold. */
 	if (lower_threshold_mV < THRESHOLD_BASIC_MIN_MV) {
 		/* Extended low range */
 		reg_ctrl2 |= CTRL2_RANGE_EXT_LOWER_MASK;

 		step = (lower_threshold_mV - THRESHOLD_MIN_MV)
 			/ THRESHOLD_STEP_MV;

 		fine_step = step & 0x3;
 		/* Extended low range is for steps 0 to 2 */
 		step >>= 2;

 		reg_threshold |= (step << THRESHOLD_LOWER_SHIFT)
 				 & THRESHOLD_LOWER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
 			     & CTRL2_FINE_STEP_LOWER_MASK;
 	} else if (lower_threshold_mV >= THRESHOLD_EXT_MIN_MV) {
 		/* Extended high range */
 		reg_ctrl2 |= CTRL2_RANGE_EXT_LOWER_MASK;

 		step = (lower_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;

 		reg_threshold |= (step << THRESHOLD_LOWER_SHIFT)
 				 & THRESHOLD_LOWER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
 			     & CTRL2_FINE_STEP_LOWER_MASK;
 	} else {
 		/* Basic range */
 		step = (lower_threshold_mV - THRESHOLD_BASIC_MIN_MV)
 			/ THRESHOLD_STEP_MV;

 		fine_step = step & 0x3;
 		step >>= 2;

 		reg_threshold |= (step << THRESHOLD_LOWER_SHIFT)
 				 & THRESHOLD_LOWER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
 			     & CTRL2_FINE_STEP_LOWER_MASK;
 	}

 	/* Determine register settings for upper threshold. */
 	if (upper_threshold_mV < THRESHOLD_BASIC_MIN_MV) {
 		/* Extended low range */
 		reg_ctrl2 |= CTRL2_RANGE_EXT_UPPER_MASK;

 		step = (upper_threshold_mV - THRESHOLD_MIN_MV)
 			/ THRESHOLD_STEP_MV;

 		fine_step = step & 0x3;
 		/* Extended low range is for steps 0 to 2 */
 		step >>= 2;

 		reg_threshold |= (step << THRESHOLD_UPPER_SHIFT)
 				 & THRESHOLD_UPPER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
 			     & CTRL2_FINE_STEP_UPPER_MASK;
 	} else if (upper_threshold_mV >= THRESHOLD_EXT_MIN_MV) {
 		/* Extended high range */
 		reg_ctrl2 |= CTRL2_RANGE_EXT_UPPER_MASK;

 		step = (upper_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;

 		reg_threshold |= (step << THRESHOLD_UPPER_SHIFT)
 				 & THRESHOLD_UPPER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
 			     & CTRL2_FINE_STEP_UPPER_MASK;
 	} else {
 		/* Basic range */
 		step = (upper_threshold_mV - THRESHOLD_BASIC_MIN_MV)
 			/ THRESHOLD_STEP_MV;

 		fine_step = step & 0x3;
 		step >>= 2;

 		reg_threshold |= (step << THRESHOLD_UPPER_SHIFT)
 				 & THRESHOLD_UPPER_MASK;
 		reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
 			     & CTRL2_FINE_STEP_UPPER_MASK;
 	}

 	mutex_lock(&battdev->batt_mutex);
 	rc = pm8058_reg_write(battdev->pm_chip, REG_THRESHOLD, reg_threshold,
 				THRESHOLD_LOWER_MASK | THRESHOLD_UPPER_MASK,
 				&battdev->reg_threshold);
 	if (rc)
 		goto bail;

 	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL2, reg_ctrl2,
 		CTRL2_FINE_STEP_LOWER_MASK | CTRL2_FINE_STEP_UPPER_MASK
 		  | CTRL2_RANGE_EXT_LOWER_MASK | CTRL2_RANGE_EXT_UPPER_MASK,
 		&battdev->reg_ctrl2);

 bail:
 	mutex_unlock(&battdev->batt_mutex);
 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_threshold_set);

 /**
  * pm8058_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 pm8058_batt_alarm_status_read(void)
 {
 	struct pm8058_batt_alarm_device *battdev = the_battalarm;
 	int status, rc;

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

 	mutex_lock(&battdev->batt_mutex);
 	rc = pm8058_read(battdev->pm_chip, REG_CTRL1, &battdev->reg_ctrl1, 1);

 	status = ((battdev->reg_ctrl1 & CTRL1_STATUS_LOWER_MASK)
 			? PM8058_BATT_ALARM_STATUS_BELOW_LOWER : 0)
 		| ((battdev->reg_ctrl1 & CTRL1_STATUS_UPPER_MASK)
 			? PM8058_BATT_ALARM_STATUS_ABOVE_UPPER : 0);
 	mutex_unlock(&battdev->batt_mutex);

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

 	return status;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_status_read);

 /**
  * pm8058_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 pm8058_batt_alarm_hold_time_set(enum pm8058_batt_alarm_hold_time hold_time)
 {
 	struct pm8058_batt_alarm_device *battdev = the_battalarm;
 	int rc;
 	u8 reg_ctrl1 = 0;

 	if (!battdev) {
 		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(&battdev->batt_mutex);
 	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL1, reg_ctrl1,
 			      CTRL1_HOLD_TIME_MASK, &battdev->reg_ctrl1);
 	mutex_unlock(&battdev->batt_mutex);

 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_hold_time_set);

 /**
  * pm8058_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 pm8058_batt_alarm_pwm_rate_set(int use_pwm, int clock_scaler,
 				   int clock_divider)
 {
 	struct pm8058_batt_alarm_device *battdev = the_battalarm;
 	int rc;
 	u8 reg_pwm_ctrl = 0, mask = 0;

 	if (!battdev) {
 		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(&battdev->batt_mutex);
 	rc = pm8058_reg_write(battdev->pm_chip, REG_PWM_CTRL, reg_pwm_ctrl,
 			      mask, &battdev->reg_pwm_ctrl);
 	mutex_unlock(&battdev->batt_mutex);

 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_pwm_rate_set);

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

 	if (battdev) {
 		status = pm8058_batt_alarm_status_read();

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

 	return IRQ_HANDLED;
 }

 /**
  * pm8058_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 pm8058_batt_alarm_register_notifier(struct notifier_block *nb)
 {
 	int rc;

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

 	rc = srcu_notifier_chain_register(&the_battalarm->irq_notifier_list,
 					  nb);
 	mutex_lock(&the_battalarm->batt_mutex);
 	if (rc == 0) {
 		if (the_battalarm->notifier_count == 0) {
 			/* request the irq */
 			rc = request_threaded_irq(the_battalarm->irq, NULL,
 				pm8058_batt_alarm_isr,
 				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 				"pm8058-batt_alarm-irq", the_battalarm);
 			if (rc < 0) {
 				pr_err("request_irq(%d) failed, rc=%d\n",
 					the_battalarm->irq, rc);
 				goto done;
 			}

 			rc = irq_set_irq_wake(the_battalarm->irq, 1);
 			if (rc < 0) {
 				pr_err("irq_set_irq_wake(%d,1) failed, rc=%d\n",
 					the_battalarm->irq, rc);
 				goto done;
 			}
 		}

 		the_battalarm->notifier_count++;
 	}
 done:
 	mutex_unlock(&the_battalarm->batt_mutex);
 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_register_notifier);

 /**
  * pm8058_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 pm8058_batt_alarm_unregister_notifier(struct notifier_block *nb)
 {
 	int rc;

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

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

 		the_battalarm->notifier_count--;

 		if (the_battalarm->notifier_count == 0)
 			free_irq(the_battalarm->irq, the_battalarm);

 		WARN_ON(the_battalarm->notifier_count < 0);

 		mutex_unlock(&the_battalarm->batt_mutex);
 	}


 	return rc;
 }
 EXPORT_SYMBOL_GPL(pm8058_batt_alarm_unregister_notifier);

 static int pm8058_batt_alarm_reg_init(struct pm8058_batt_alarm_device *battdev)
 {
 	int rc = 0;

 	/* save the current register states */
 	rc = pm8058_read(battdev->pm_chip, REG_THRESHOLD,
 			 &battdev->reg_threshold, 1);
 	if (rc)
 		goto bail;

 	rc = pm8058_read(battdev->pm_chip, REG_CTRL1,
 			 &battdev->reg_ctrl1, 1);
 	if (rc)
 		goto bail;

 	rc = pm8058_read(battdev->pm_chip, REG_CTRL2,
 			 &battdev->reg_ctrl2, 1);
 	if (rc)
 		goto bail;

 	rc = pm8058_read(battdev->pm_chip, REG_PWM_CTRL,
 			 &battdev->reg_pwm_ctrl, 1);
 	if (rc)
 		goto bail;

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

 static int pm8058_batt_alarm_config(void)
 {
 	int rc = 0;

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

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

 	rc = pm8058_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 = pm8058_batt_alarm_state_set(DEFAULT_LOWER_ENABLE,
 			DEFAULT_UPPER_ENABLE);
 	if (rc) {
 		pr_err("state_set failed, rc=%d\n", rc);
 		goto done;
 	}

 done:
 	return rc;
 }

 static int __devinit pm8058_batt_alarm_probe(struct platform_device *pdev)
 {
 	struct pm8058_batt_alarm_device *battdev;
 	struct pm8058_chip *pm_chip;
 	unsigned int irq;
 	int rc;

 	pm_chip = dev_get_drvdata(pdev->dev.parent);
 	if (pm_chip == NULL) {
 		pr_err("no driver data passed in.\n");
 		rc = -EFAULT;
 		goto exit_input;
 	}

 	irq = platform_get_irq(pdev, 0);
 	if (!irq) {
 		pr_err("no IRQ passed in.\n");
 		rc = -EFAULT;
 		goto exit_input;
 	}

 	battdev = kzalloc(sizeof *battdev, GFP_KERNEL);
 	if (battdev == NULL) {
 		pr_err("kzalloc() failed.\n");
 		rc = -ENOMEM;
 		goto exit_input;
 	}

 	battdev->pm_chip = pm_chip;
 	platform_set_drvdata(pdev, battdev);

 	srcu_init_notifier_head(&battdev->irq_notifier_list);

 	battdev->irq = irq;
 	battdev->notifier_count = 0;
 	mutex_init(&battdev->batt_mutex);

 	rc = pm8058_batt_alarm_reg_init(battdev);
 	if (rc)
 		goto exit_free_dev;

 	the_battalarm = battdev;

 	rc = pm8058_batt_alarm_config();
 	if (rc)
 		goto exit_free_dev;

 	pr_notice("OK\n");
 	return 0;

 exit_free_dev:
 	mutex_destroy(&battdev->batt_mutex);
 	srcu_cleanup_notifier_head(&battdev->irq_notifier_list);
 	platform_set_drvdata(pdev, battdev->pm_chip);
 	kfree(battdev);
 exit_input:
 	return rc;
 }

 static int __devexit pm8058_batt_alarm_remove(struct platform_device *pdev)
 {
 	struct pm8058_batt_alarm_device *battdev = platform_get_drvdata(pdev);

 	mutex_destroy(&battdev->batt_mutex);
 	srcu_cleanup_notifier_head(&battdev->irq_notifier_list);
 	platform_set_drvdata(pdev, battdev->pm_chip);
 	free_irq(battdev->irq, battdev);
 	kfree(battdev);

 	the_battalarm = NULL;

 	return 0;
 }

 static struct platform_driver pm8058_batt_alarm_driver = {
 	.probe	= pm8058_batt_alarm_probe,
 	.remove	= __devexit_p(pm8058_batt_alarm_remove),
 	.driver	= {
 		.name = "pm8058-batt-alarm",
 		.owner = THIS_MODULE,
 	},
 };

 static int __init pm8058_batt_alarm_init(void)
 {
 	return platform_driver_register(&pm8058_batt_alarm_driver);
 }

 static void __exit pm8058_batt_alarm_exit(void)
 {
 	platform_driver_unregister(&pm8058_batt_alarm_driver);
 }

 module_init(pm8058_batt_alarm_init);
 module_exit(pm8058_batt_alarm_exit);

 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("PMIC8058 Battery Alarm Device driver");
 MODULE_VERSION("1.0");
 MODULE_ALIAS("platform:pm8058-batt-alarm");
	/* 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 8058 Battery Alarm Device 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/pmic8058-batt-alarm.h>
	#include <linux/mfd/pmic8058.h>

	/* PMIC 8058 Battery Alarm SSBI registers */
	#define REG_THRESHOLD 0x023
	#define REG_CTRL1 0x024
	#define REG_CTRL2 0x0AA
	#define REG_PWM_CTRL 0x0A3

	/* 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_EN_MASK 0x80
	#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_LOWER_DISABLE_MASK 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
	* pm8058_batt_alarm_state_set.
	*/
	#define DEFAULT_THRESHOLD_LOWER 3200
	#define DEFAULT_THRESHOLD_UPPER 4300
	#define DEFAULT_HOLD_TIME PM8058_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 pm8058_batt_alarm_device {
	struct srcu_notifier_head irq_notifier_list;
	struct pm8058_chip *pm_chip;
	struct mutex batt_mutex;
	unsigned int irq;
	int notifier_count;
	u8 reg_threshold;
	u8 reg_ctrl1;
	u8 reg_ctrl2;
	u8 reg_pwm_ctrl;
	};
	static struct pm8058_batt_alarm_device *the_battalarm;

	static int pm8058_reg_write(struct pm8058_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 = pm8058_write(chip, addr, &reg, 1);
	if (rc)
	pr_err("pm8058_write failed; addr=%03X, rc=%d\n", addr, rc);
	else
	*reg_save = reg;
	return rc;
	}

	/**
	* pm8058_batt_alarm_state_set - enable or disable the threshold comparators
	* @enable_lower_comparator: 1 = enable comparator, 0 = disable comparator
	* @enable_upper_comparator: 1 = enable comparator, 0 = disable comparator
	*
	* RETURNS: an appropriate -ERRNO error value on error, or zero for success.
	*/
	int pm8058_batt_alarm_state_set(int enable_lower_comparator,
	int enable_upper_comparator)
	{
	struct pm8058_batt_alarm_device *battdev = the_battalarm;
	int rc;
	u8 reg_ctrl1 = 0, reg_ctrl2 = 0;

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

	if (!enable_lower_comparator)
	reg_ctrl2 \|= CTRL2_COMP_LOWER_DISABLE_MASK;
	if (!enable_upper_comparator)
	reg_ctrl2 \|= CTRL2_COMP_UPPER_DISABLE_MASK;

	if (enable_lower_comparator \|\| enable_upper_comparator)
	reg_ctrl1 = CTRL1_BATT_ALARM_EN_MASK;

	mutex_lock(&battdev->batt_mutex);
	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL1, reg_ctrl1,
	CTRL1_BATT_ALARM_EN_MASK, &battdev->reg_ctrl1);
	if (rc)
	goto bail;

	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL2, reg_ctrl2,
	CTRL2_COMP_LOWER_DISABLE_MASK \| CTRL2_COMP_UPPER_DISABLE_MASK,
	&battdev->reg_ctrl2);

	bail:
	mutex_unlock(&battdev->batt_mutex);
	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_state_set);

	/**
	* pm8058_batt_alarm_threshold_set - set the lower and upper alarm thresholds
	* @lower_threshold_mV: battery undervoltage threshold in millivolts
	* @upper_threshold_mV: battery overvoltage threshold in millivolts
	*
	* RETURNS: an appropriate -ERRNO error value on error, or zero for success.
	*/
	int pm8058_batt_alarm_threshold_set(int lower_threshold_mV,
	int upper_threshold_mV)
	{
	struct pm8058_batt_alarm_device *battdev = the_battalarm;
	int step, fine_step, rc;
	u8 reg_threshold = 0, reg_ctrl2 = 0;

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

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

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

	if (upper_threshold_mV < lower_threshold_mV) {
	pr_err("lower threshold value, %d mV, must be <= upper "
	"threshold value, %d mV\n", lower_threshold_mV,
	upper_threshold_mV);
	return -EINVAL;
	}

	/* Determine register settings for lower threshold. */
	if (lower_threshold_mV < THRESHOLD_BASIC_MIN_MV) {
	/* Extended low range */
	reg_ctrl2 \|= CTRL2_RANGE_EXT_LOWER_MASK;

	step = (lower_threshold_mV - THRESHOLD_MIN_MV)
	/ THRESHOLD_STEP_MV;

	fine_step = step & 0x3;
	/* Extended low range is for steps 0 to 2 */
	step >>= 2;

	reg_threshold \|= (step << THRESHOLD_LOWER_SHIFT)
	& THRESHOLD_LOWER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
	& CTRL2_FINE_STEP_LOWER_MASK;
	} else if (lower_threshold_mV >= THRESHOLD_EXT_MIN_MV) {
	/* Extended high range */
	reg_ctrl2 \|= CTRL2_RANGE_EXT_LOWER_MASK;

	step = (lower_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;

	reg_threshold \|= (step << THRESHOLD_LOWER_SHIFT)
	& THRESHOLD_LOWER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
	& CTRL2_FINE_STEP_LOWER_MASK;
	} else {
	/* Basic range */
	step = (lower_threshold_mV - THRESHOLD_BASIC_MIN_MV)
	/ THRESHOLD_STEP_MV;

	fine_step = step & 0x3;
	step >>= 2;

	reg_threshold \|= (step << THRESHOLD_LOWER_SHIFT)
	& THRESHOLD_LOWER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT)
	& CTRL2_FINE_STEP_LOWER_MASK;
	}

	/* Determine register settings for upper threshold. */
	if (upper_threshold_mV < THRESHOLD_BASIC_MIN_MV) {
	/* Extended low range */
	reg_ctrl2 \|= CTRL2_RANGE_EXT_UPPER_MASK;

	step = (upper_threshold_mV - THRESHOLD_MIN_MV)
	/ THRESHOLD_STEP_MV;

	fine_step = step & 0x3;
	/* Extended low range is for steps 0 to 2 */
	step >>= 2;

	reg_threshold \|= (step << THRESHOLD_UPPER_SHIFT)
	& THRESHOLD_UPPER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
	& CTRL2_FINE_STEP_UPPER_MASK;
	} else if (upper_threshold_mV >= THRESHOLD_EXT_MIN_MV) {
	/* Extended high range */
	reg_ctrl2 \|= CTRL2_RANGE_EXT_UPPER_MASK;

	step = (upper_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;

	reg_threshold \|= (step << THRESHOLD_UPPER_SHIFT)
	& THRESHOLD_UPPER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
	& CTRL2_FINE_STEP_UPPER_MASK;
	} else {
	/* Basic range */
	step = (upper_threshold_mV - THRESHOLD_BASIC_MIN_MV)
	/ THRESHOLD_STEP_MV;

	fine_step = step & 0x3;
	step >>= 2;

	reg_threshold \|= (step << THRESHOLD_UPPER_SHIFT)
	& THRESHOLD_UPPER_MASK;
	reg_ctrl2 \|= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT)
	& CTRL2_FINE_STEP_UPPER_MASK;
	}

	mutex_lock(&battdev->batt_mutex);
	rc = pm8058_reg_write(battdev->pm_chip, REG_THRESHOLD, reg_threshold,
	THRESHOLD_LOWER_MASK \| THRESHOLD_UPPER_MASK,
	&battdev->reg_threshold);
	if (rc)
	goto bail;

	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL2, reg_ctrl2,
	CTRL2_FINE_STEP_LOWER_MASK \| CTRL2_FINE_STEP_UPPER_MASK
	\| CTRL2_RANGE_EXT_LOWER_MASK \| CTRL2_RANGE_EXT_UPPER_MASK,
	&battdev->reg_ctrl2);

	bail:
	mutex_unlock(&battdev->batt_mutex);
	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_threshold_set);

	/**
	* pm8058_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 pm8058_batt_alarm_status_read(void)
	{
	struct pm8058_batt_alarm_device *battdev = the_battalarm;
	int status, rc;

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

	mutex_lock(&battdev->batt_mutex);
	rc = pm8058_read(battdev->pm_chip, REG_CTRL1, &battdev->reg_ctrl1, 1);

	status = ((battdev->reg_ctrl1 & CTRL1_STATUS_LOWER_MASK)
	? PM8058_BATT_ALARM_STATUS_BELOW_LOWER : 0)
	\| ((battdev->reg_ctrl1 & CTRL1_STATUS_UPPER_MASK)
	? PM8058_BATT_ALARM_STATUS_ABOVE_UPPER : 0);
	mutex_unlock(&battdev->batt_mutex);

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

	return status;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_status_read);

	/**
	* pm8058_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 pm8058_batt_alarm_hold_time_set(enum pm8058_batt_alarm_hold_time hold_time)
	{
	struct pm8058_batt_alarm_device *battdev = the_battalarm;
	int rc;
	u8 reg_ctrl1 = 0;

	if (!battdev) {
	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(&battdev->batt_mutex);
	rc = pm8058_reg_write(battdev->pm_chip, REG_CTRL1, reg_ctrl1,
	CTRL1_HOLD_TIME_MASK, &battdev->reg_ctrl1);
	mutex_unlock(&battdev->batt_mutex);

	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_hold_time_set);

	/**
	* pm8058_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 pm8058_batt_alarm_pwm_rate_set(int use_pwm, int clock_scaler,
	int clock_divider)
	{
	struct pm8058_batt_alarm_device *battdev = the_battalarm;
	int rc;
	u8 reg_pwm_ctrl = 0, mask = 0;

	if (!battdev) {
	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(&battdev->batt_mutex);
	rc = pm8058_reg_write(battdev->pm_chip, REG_PWM_CTRL, reg_pwm_ctrl,
	mask, &battdev->reg_pwm_ctrl);
	mutex_unlock(&battdev->batt_mutex);

	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_pwm_rate_set);

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

	if (battdev) {
	status = pm8058_batt_alarm_status_read();

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

	return IRQ_HANDLED;
	}

	/**
	* pm8058_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 pm8058_batt_alarm_register_notifier(struct notifier_block *nb)
	{
	int rc;

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

	rc = srcu_notifier_chain_register(&the_battalarm->irq_notifier_list,
	nb);
	mutex_lock(&the_battalarm->batt_mutex);
	if (rc == 0) {
	if (the_battalarm->notifier_count == 0) {
	/* request the irq */
	rc = request_threaded_irq(the_battalarm->irq, NULL,
	pm8058_batt_alarm_isr,
	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	"pm8058-batt_alarm-irq", the_battalarm);
	if (rc < 0) {
	pr_err("request_irq(%d) failed, rc=%d\n",
	the_battalarm->irq, rc);
	goto done;
	}

	rc = irq_set_irq_wake(the_battalarm->irq, 1);
	if (rc < 0) {
	pr_err("irq_set_irq_wake(%d,1) failed, rc=%d\n",
	the_battalarm->irq, rc);
	goto done;
	}
	}

	the_battalarm->notifier_count++;
	}
	done:
	mutex_unlock(&the_battalarm->batt_mutex);
	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_register_notifier);

	/**
	* pm8058_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 pm8058_batt_alarm_unregister_notifier(struct notifier_block *nb)
	{
	int rc;

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

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

	the_battalarm->notifier_count--;

	if (the_battalarm->notifier_count == 0)
	free_irq(the_battalarm->irq, the_battalarm);

	WARN_ON(the_battalarm->notifier_count < 0);

	mutex_unlock(&the_battalarm->batt_mutex);
	}



	return rc;
	}
	EXPORT_SYMBOL_GPL(pm8058_batt_alarm_unregister_notifier);

	static int pm8058_batt_alarm_reg_init(struct pm8058_batt_alarm_device *battdev)
	{
	int rc = 0;

	/* save the current register states */
	rc = pm8058_read(battdev->pm_chip, REG_THRESHOLD,
	&battdev->reg_threshold, 1);
	if (rc)
	goto bail;

	rc = pm8058_read(battdev->pm_chip, REG_CTRL1,
	&battdev->reg_ctrl1, 1);
	if (rc)
	goto bail;

	rc = pm8058_read(battdev->pm_chip, REG_CTRL2,
	&battdev->reg_ctrl2, 1);
	if (rc)
	goto bail;

	rc = pm8058_read(battdev->pm_chip, REG_PWM_CTRL,
	&battdev->reg_pwm_ctrl, 1);
	if (rc)
	goto bail;

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

	static int pm8058_batt_alarm_config(void)
	{
	int rc = 0;

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

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

	rc = pm8058_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 = pm8058_batt_alarm_state_set(DEFAULT_LOWER_ENABLE,
	DEFAULT_UPPER_ENABLE);
	if (rc) {
	pr_err("state_set failed, rc=%d\n", rc);
	goto done;
	}

	done:
	return rc;
	}

	static int __devinit pm8058_batt_alarm_probe(struct platform_device *pdev)
	{
	struct pm8058_batt_alarm_device *battdev;
	struct pm8058_chip *pm_chip;
	unsigned int irq;
	int rc;

	pm_chip = dev_get_drvdata(pdev->dev.parent);
	if (pm_chip == NULL) {
	pr_err("no driver data passed in.\n");
	rc = -EFAULT;
	goto exit_input;
	}

	irq = platform_get_irq(pdev, 0);
	if (!irq) {
	pr_err("no IRQ passed in.\n");
	rc = -EFAULT;
	goto exit_input;
	}

	battdev = kzalloc(sizeof *battdev, GFP_KERNEL);
	if (battdev == NULL) {
	pr_err("kzalloc() failed.\n");
	rc = -ENOMEM;
	goto exit_input;
	}

	battdev->pm_chip = pm_chip;
	platform_set_drvdata(pdev, battdev);

	srcu_init_notifier_head(&battdev->irq_notifier_list);

	battdev->irq = irq;
	battdev->notifier_count = 0;
	mutex_init(&battdev->batt_mutex);

	rc = pm8058_batt_alarm_reg_init(battdev);
	if (rc)
	goto exit_free_dev;

	the_battalarm = battdev;

	rc = pm8058_batt_alarm_config();
	if (rc)
	goto exit_free_dev;

	pr_notice("OK\n");
	return 0;

	exit_free_dev:
	mutex_destroy(&battdev->batt_mutex);
	srcu_cleanup_notifier_head(&battdev->irq_notifier_list);
	platform_set_drvdata(pdev, battdev->pm_chip);
	kfree(battdev);
	exit_input:
	return rc;
	}

	static int __devexit pm8058_batt_alarm_remove(struct platform_device *pdev)
	{
	struct pm8058_batt_alarm_device *battdev = platform_get_drvdata(pdev);

	mutex_destroy(&battdev->batt_mutex);
	srcu_cleanup_notifier_head(&battdev->irq_notifier_list);
	platform_set_drvdata(pdev, battdev->pm_chip);
	free_irq(battdev->irq, battdev);
	kfree(battdev);

	the_battalarm = NULL;

	return 0;
	}

	static struct platform_driver pm8058_batt_alarm_driver = {
	.probe = pm8058_batt_alarm_probe,
	.remove = __devexit_p(pm8058_batt_alarm_remove),
	.driver = {
	.name = "pm8058-batt-alarm",
	.owner = THIS_MODULE,
	},
	};

	static int __init pm8058_batt_alarm_init(void)
	{
	return platform_driver_register(&pm8058_batt_alarm_driver);
	}

	static void __exit pm8058_batt_alarm_exit(void)
	{
	platform_driver_unregister(&pm8058_batt_alarm_driver);
	}

	module_init(pm8058_batt_alarm_init);
	module_exit(pm8058_batt_alarm_exit);

	MODULE_LICENSE("GPL v2");
	MODULE_DESCRIPTION("PMIC8058 Battery Alarm Device driver");
	MODULE_VERSION("1.0");
	MODULE_ALIAS("platform:pm8058-batt-alarm");