| /* |
| * * Copyright (c) 2011, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <debug.h> |
| #include <platform/pmic_batt_alarm.h> |
| |
| static struct pm_batt_alarm_device battdev; |
| |
| /* |
| * Function to set threshold voltages for battery alarm |
| */ |
| |
| static int pm_batt_alarm_threshold_set(uint32_t lower_threshold_mV, |
| uint32_t upper_threshold_mV) |
| { |
| uint32_t step, fine_step, rc = -1; |
| uint8_t reg_threshold = 0, reg_ctrl2 = 0; |
| |
| if (lower_threshold_mV < THRESHOLD_MIN_MV |
| || lower_threshold_mV > THRESHOLD_MAX_MV) { |
| dprintf(CRITICAL, |
| "lower threshold value, %d mV, is outside of allowable " |
| "range: [%d, %d] mV\n", lower_threshold_mV, |
| THRESHOLD_MIN_MV, THRESHOLD_MAX_MV); |
| goto bail; |
| } |
| |
| if (upper_threshold_mV < THRESHOLD_MIN_MV |
| || upper_threshold_mV > THRESHOLD_MAX_MV) { |
| dprintf(CRITICAL, |
| "upper threshold value, %d mV, is outside of allowable " |
| "range: [%d, %d] mV\n", upper_threshold_mV, |
| THRESHOLD_MIN_MV, THRESHOLD_MAX_MV); |
| goto bail; |
| } |
| |
| if (upper_threshold_mV < lower_threshold_mV) { |
| dprintf(CRITICAL, |
| "lower threshold value, %d mV, must be <= upper " |
| "threshold value, %d mV\n", lower_threshold_mV, |
| upper_threshold_mV); |
| goto bail; |
| } |
| |
| /* 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; |
| |
| } 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; |
| |
| } 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); |
| reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_LOWER_SHIFT); |
| |
| /* 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; |
| |
| } 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; |
| |
| } 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); |
| reg_ctrl2 |= (fine_step << CTRL2_FINE_STEP_UPPER_SHIFT); |
| |
| rc = pm8058_mwrite(PM8058_REG_THRESHOLD, reg_threshold, |
| THRESHOLD_LOWER_MASK | THRESHOLD_UPPER_MASK, |
| &battdev.reg_threshold); |
| if (rc) { |
| dprintf(CRITICAL, "Error in pm8058_mwrite THRESHOLD\n"); |
| goto bail; |
| } |
| |
| rc = pm8058_mwrite(PM8058_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); |
| |
| if (rc) |
| dprintf(CRITICAL, "Error in pm8058_mwrite CTRL2\n"); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to set hold time (hysteresis) for battery alarm |
| */ |
| |
| static int pm_batt_alarm_hold_time_set(pm_batt_alarm_hold_time hold_time) |
| { |
| int rc = -1; |
| uint8_t reg_ctrl1 = 0; |
| |
| if (hold_time < CTRL1_HOLD_TIME_MIN || hold_time > CTRL1_HOLD_TIME_MAX) { |
| |
| dprintf(CRITICAL, |
| "hold time, %d, is outside of allowable range: " |
| "[%d, %d]\n", hold_time, CTRL1_HOLD_TIME_MIN, |
| CTRL1_HOLD_TIME_MAX); |
| goto bail; |
| } |
| |
| reg_ctrl1 = hold_time << CTRL1_HOLD_TIME_SHIFT; |
| |
| rc = pm8058_mwrite(PM8058_REG_CTRL1, reg_ctrl1, |
| CTRL1_HOLD_TIME_MASK, &battdev.reg_ctrl1); |
| |
| if (rc) |
| dprintf(CRITICAL, "Error in pm8058_mwrite CTRL1\n"); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to set PWM clock rate for battery alarm |
| */ |
| |
| static int pm_batt_alarm_pwm_rate_set(pm_batt_alarm_pwm_ctrl pwm_ctrl_select, |
| uint32_t clock_scaler, |
| uint32_t clock_divider) |
| { |
| int rc = -1; |
| uint8_t reg_pwm_ctrl = 0, mask = 0; |
| |
| if (pwm_ctrl_select == ALARM_EN_PWM) { |
| if (clock_scaler < PWM_CTRL_PRE_INPUT_MIN |
| || clock_scaler > PWM_CTRL_PRE_INPUT_MAX) { |
| dprintf(CRITICAL, |
| "PWM clock scaler, %d, is outside of allowable range: " |
| "[%d, %d]\n", clock_scaler, |
| PWM_CTRL_PRE_INPUT_MIN, PWM_CTRL_PRE_INPUT_MAX); |
| goto bail; |
| } |
| |
| if (clock_divider < PWM_CTRL_DIV_INPUT_MIN |
| || clock_divider > PWM_CTRL_DIV_INPUT_MAX) { |
| dprintf(CRITICAL, |
| "PWM clock divider, %d, is outside of allowable range: " |
| "[%d, %d]\n", clock_divider, |
| PWM_CTRL_DIV_INPUT_MIN, PWM_CTRL_DIV_INPUT_MAX); |
| goto bail; |
| } |
| |
| /* 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); |
| reg_pwm_ctrl |= (clock_divider << PWM_CTRL_DIV_SHIFT); |
| } else { |
| if (pwm_ctrl_select == ALARM_EN_ALWAYS) { |
| reg_pwm_ctrl = PWM_CTRL_ALARM_EN_ALWAYS; |
| } else if (pwm_ctrl_select == ALARM_EN_NEVER) { |
| reg_pwm_ctrl = PWM_CTRL_ALARM_EN_NEVER; |
| } |
| |
| mask = PWM_CTRL_ALARM_EN_MASK; |
| } |
| |
| rc = pm8058_mwrite(PM8058_REG_PWM_CTRL, reg_pwm_ctrl, |
| mask, &battdev.reg_pwm_ctrl); |
| |
| if (rc) |
| dprintf(CRITICAL, "Error in pm8058_mwrite PWM_CTRL\n"); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to enable/disable alarm comparators for battery alarm |
| */ |
| |
| static int pm_batt_alarm_state_set(uint8_t enable_lower_comparator, |
| uint8_t enable_upper_comparator) |
| { |
| int rc = -1; |
| uint8_t reg_ctrl1 = 0, reg_ctrl2 = 0; |
| |
| 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; |
| |
| rc = pm8058_mwrite(PM8058_REG_CTRL1, reg_ctrl1, |
| CTRL1_BATT_ALARM_EN_MASK, &battdev.reg_ctrl1); |
| if (rc) { |
| dprintf(CRITICAL, "Error in pm8058_mwrite CTRL1\n"); |
| goto bail; |
| } |
| |
| rc = pm8058_mwrite(PM8058_REG_CTRL2, reg_ctrl2, |
| CTRL2_COMP_LOWER_DISABLE_MASK | |
| CTRL2_COMP_UPPER_DISABLE_MASK, &battdev.reg_ctrl2); |
| |
| if (rc) |
| dprintf(CRITICAL, "Error in pm8058_mwrite CTRL2\n"); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to read alarm status for battery alarm |
| */ |
| |
| int pm_batt_alarm_status_read(uint8_t * status) |
| { |
| int rc = -1; |
| |
| rc = pm8058_read(PM8058_REG_CTRL1, &battdev.reg_ctrl1, 1); |
| if (rc) { |
| dprintf(CRITICAL, "Error in reading CTRL1\n"); |
| goto bail; |
| } |
| |
| *status = ((battdev.reg_ctrl1 & CTRL1_STATUS_LOWER_MASK) |
| ? PM_BATT_ALARM_STATUS_BELOW_LOWER : 0) |
| | ((battdev.reg_ctrl1 & CTRL1_STATUS_UPPER_MASK) |
| ? PM_BATT_ALARM_STATUS_ABOVE_UPPER : 0); |
| |
| /* Disabling Battery alarm below just for power savings. This can be |
| * removed if this does not matter |
| */ |
| |
| /* After reading, disabling the comparators and BATT_ALARM_EN */ |
| rc = pm_batt_alarm_state_set(LOWER_COMP_DISABLE, UPPER_COMP_DISABLE); |
| if (rc) { |
| dprintf(CRITICAL, "state_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_pwm_rate_set(ALARM_EN_NEVER, DEFAULT_PWM_SCALER, |
| DEFAULT_PWM_DIVIDER); |
| if (rc) { |
| dprintf(CRITICAL, "state_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to read and print battery alarm registers for debugging |
| */ |
| |
| int pm_batt_alarm_read_regs(struct pm_batt_alarm_device *battdev) |
| { |
| int rc = -1; |
| |
| if (battdev) { |
| rc = pm8058_read(PM8058_REG_THRESHOLD, &battdev->reg_threshold, |
| 1); |
| if (rc) |
| goto done; |
| |
| rc = pm8058_read(PM8058_REG_CTRL1, &battdev->reg_ctrl1, 1); |
| if (rc) |
| goto done; |
| |
| rc = pm8058_read(PM8058_REG_CTRL2, &battdev->reg_ctrl2, 1); |
| if (rc) |
| goto done; |
| |
| rc = pm8058_read(PM8058_REG_PWM_CTRL, &battdev->reg_pwm_ctrl, |
| 1); |
| if (rc) |
| goto done; |
| } |
| |
| done: |
| if (rc) |
| dprintf(CRITICAL, "pm_batt_alarm_read_regs read error\n"); |
| return rc; |
| } |
| |
| /* |
| * Function for battery alarm initialization |
| */ |
| |
| int pm_batt_alarm_init() |
| { |
| int rc = -1; |
| |
| rc = pm_batt_alarm_read_regs(&battdev); |
| if (rc) { |
| dprintf(CRITICAL, "read_regs failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_threshold_set(DEFAULT_THRESHOLD_LOWER, |
| DEFAULT_THRESHOLD_UPPER); |
| if (rc) { |
| dprintf(CRITICAL, "threshold_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_hold_time_set(DEFAULT_HOLD_TIME); |
| if (rc) { |
| dprintf(CRITICAL, "hold_time_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_pwm_rate_set(ALARM_EN_NEVER, DEFAULT_PWM_SCALER, |
| DEFAULT_PWM_DIVIDER); |
| if (rc) { |
| dprintf(CRITICAL, "pwm_rate_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_state_set(LOWER_COMP_DISABLE, UPPER_COMP_DISABLE); |
| if (rc) |
| dprintf(CRITICAL, "state_set failed, rc=%d\n", rc); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to configure voltages and change alarm state |
| */ |
| |
| int pm_batt_alarm_set_voltage(uint32_t lower_threshold, |
| uint32_t upper_threshold) |
| { |
| int rc = -1; |
| |
| rc = pm_batt_alarm_threshold_set(lower_threshold, upper_threshold); |
| if (rc) { |
| dprintf(CRITICAL, "threshold_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_pwm_rate_set(ALARM_EN_ALWAYS, DEFAULT_PWM_SCALER, |
| DEFAULT_PWM_DIVIDER); |
| if (rc) { |
| dprintf(CRITICAL, "pwm_rate_set failed, rc=%d\n", rc); |
| goto bail; |
| } |
| |
| rc = pm_batt_alarm_state_set(LOWER_COMP_ENABLE, UPPER_COMP_ENABLE); |
| if (rc) |
| dprintf(CRITICAL, "state_set failed, rc=%d\n", rc); |
| |
| bail: |
| return rc; |
| } |
| |
| /* |
| * Function to test battery alarms |
| */ |
| |
| void pm_ba_test(void) |
| { |
| int rc = 0; |
| uint8_t batt_status = 0; |
| |
| rc = pm_batt_alarm_init(); |
| if (rc) |
| dprintf(CRITICAL, "pm_batt_alarm_init error\n"); |
| |
| /* wait till hold time */ |
| mdelay(16); |
| |
| /* 0xe74-> 3700mV, 0x1004-> 4100mv */ |
| rc = pm_batt_alarm_set_voltage(0xe74, 0x1004); |
| if (rc) |
| dprintf(CRITICAL, "pm_batt_alarm_set_voltage error\n"); |
| |
| /* wait till hold time */ |
| mdelay(16); |
| |
| rc = pm_batt_alarm_status_read(&batt_status); |
| if (rc) |
| dprintf(CRITICAL, "pm_batt_alarm_status_read error\n"); |
| else |
| dprintf(ALWAYS, "batt status: %d\n", batt_status); |
| } |