Abhijeet Dharmapurikar | 728bc4d | 2012-01-03 11:08:33 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved. |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2 | * |
| 3 | * This program is free software; you can redistribute it and/or modify |
| 4 | * it under the terms of the GNU General Public License version 2 and |
| 5 | * only version 2 as published by the Free Software Foundation. |
| 6 | * |
| 7 | * This program is distributed in the hope that it will be useful, |
| 8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 10 | * GNU General Public License for more details. |
| 11 | * |
| 12 | */ |
| 13 | #define pr_fmt(fmt) "%s: " fmt, __func__ |
| 14 | |
| 15 | #include <linux/module.h> |
| 16 | #include <linux/moduleparam.h> |
| 17 | #include <linux/platform_device.h> |
| 18 | #include <linux/errno.h> |
| 19 | #include <linux/mfd/pm8xxx/pm8921-charger.h> |
| 20 | #include <linux/mfd/pm8xxx/pm8921-bms.h> |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 21 | #include <linux/mfd/pm8xxx/pm8xxx-adc.h> |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 22 | #include <linux/mfd/pm8xxx/ccadc.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 23 | #include <linux/mfd/pm8xxx/core.h> |
| 24 | #include <linux/interrupt.h> |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 25 | #include <linux/delay.h> |
| 26 | #include <linux/bitops.h> |
| 27 | #include <linux/workqueue.h> |
| 28 | #include <linux/debugfs.h> |
| 29 | #include <linux/slab.h> |
| 30 | |
| 31 | #include <mach/msm_xo.h> |
| 32 | #include <mach/msm_hsusb.h> |
| 33 | |
| 34 | #define CHG_BUCK_CLOCK_CTRL 0x14 |
| 35 | |
| 36 | #define PBL_ACCESS1 0x04 |
| 37 | #define PBL_ACCESS2 0x05 |
| 38 | #define SYS_CONFIG_1 0x06 |
| 39 | #define SYS_CONFIG_2 0x07 |
| 40 | #define CHG_CNTRL 0x204 |
| 41 | #define CHG_IBAT_MAX 0x205 |
| 42 | #define CHG_TEST 0x206 |
| 43 | #define CHG_BUCK_CTRL_TEST1 0x207 |
| 44 | #define CHG_BUCK_CTRL_TEST2 0x208 |
| 45 | #define CHG_BUCK_CTRL_TEST3 0x209 |
| 46 | #define COMPARATOR_OVERRIDE 0x20A |
| 47 | #define PSI_TXRX_SAMPLE_DATA_0 0x20B |
| 48 | #define PSI_TXRX_SAMPLE_DATA_1 0x20C |
| 49 | #define PSI_TXRX_SAMPLE_DATA_2 0x20D |
| 50 | #define PSI_TXRX_SAMPLE_DATA_3 0x20E |
| 51 | #define PSI_CONFIG_STATUS 0x20F |
| 52 | #define CHG_IBAT_SAFE 0x210 |
| 53 | #define CHG_ITRICKLE 0x211 |
| 54 | #define CHG_CNTRL_2 0x212 |
| 55 | #define CHG_VBAT_DET 0x213 |
| 56 | #define CHG_VTRICKLE 0x214 |
| 57 | #define CHG_ITERM 0x215 |
| 58 | #define CHG_CNTRL_3 0x216 |
| 59 | #define CHG_VIN_MIN 0x217 |
| 60 | #define CHG_TWDOG 0x218 |
| 61 | #define CHG_TTRKL_MAX 0x219 |
| 62 | #define CHG_TEMP_THRESH 0x21A |
| 63 | #define CHG_TCHG_MAX 0x21B |
| 64 | #define USB_OVP_CONTROL 0x21C |
| 65 | #define DC_OVP_CONTROL 0x21D |
| 66 | #define USB_OVP_TEST 0x21E |
| 67 | #define DC_OVP_TEST 0x21F |
| 68 | #define CHG_VDD_MAX 0x220 |
| 69 | #define CHG_VDD_SAFE 0x221 |
| 70 | #define CHG_VBAT_BOOT_THRESH 0x222 |
| 71 | #define USB_OVP_TRIM 0x355 |
| 72 | #define BUCK_CONTROL_TRIM1 0x356 |
| 73 | #define BUCK_CONTROL_TRIM2 0x357 |
| 74 | #define BUCK_CONTROL_TRIM3 0x358 |
| 75 | #define BUCK_CONTROL_TRIM4 0x359 |
| 76 | #define CHG_DEFAULTS_TRIM 0x35A |
| 77 | #define CHG_ITRIM 0x35B |
| 78 | #define CHG_TTRIM 0x35C |
| 79 | #define CHG_COMP_OVR 0x20A |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 80 | #define IUSB_FINE_RES 0x2B6 |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 81 | #define OVP_USB_UVD 0x2B7 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 82 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 83 | /* check EOC every 10 seconds */ |
| 84 | #define EOC_CHECK_PERIOD_MS 10000 |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 85 | /* check for USB unplug every 200 msecs */ |
| 86 | #define UNPLUG_CHECK_WAIT_PERIOD_MS 200 |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 87 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 88 | enum chg_fsm_state { |
| 89 | FSM_STATE_OFF_0 = 0, |
| 90 | FSM_STATE_BATFETDET_START_12 = 12, |
| 91 | FSM_STATE_BATFETDET_END_16 = 16, |
| 92 | FSM_STATE_ON_CHG_HIGHI_1 = 1, |
| 93 | FSM_STATE_ATC_2A = 2, |
| 94 | FSM_STATE_ATC_2B = 18, |
| 95 | FSM_STATE_ON_BAT_3 = 3, |
| 96 | FSM_STATE_ATC_FAIL_4 = 4 , |
| 97 | FSM_STATE_DELAY_5 = 5, |
| 98 | FSM_STATE_ON_CHG_AND_BAT_6 = 6, |
| 99 | FSM_STATE_FAST_CHG_7 = 7, |
| 100 | FSM_STATE_TRKL_CHG_8 = 8, |
| 101 | FSM_STATE_CHG_FAIL_9 = 9, |
| 102 | FSM_STATE_EOC_10 = 10, |
| 103 | FSM_STATE_ON_CHG_VREGOK_11 = 11, |
| 104 | FSM_STATE_ATC_PAUSE_13 = 13, |
| 105 | FSM_STATE_FAST_CHG_PAUSE_14 = 14, |
| 106 | FSM_STATE_TRKL_CHG_PAUSE_15 = 15, |
| 107 | FSM_STATE_START_BOOT = 20, |
| 108 | FSM_STATE_FLCB_VREGOK = 21, |
| 109 | FSM_STATE_FLCB = 22, |
| 110 | }; |
| 111 | |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 112 | struct fsm_state_to_batt_status { |
| 113 | enum chg_fsm_state fsm_state; |
| 114 | int batt_state; |
| 115 | }; |
| 116 | |
| 117 | static struct fsm_state_to_batt_status map[] = { |
| 118 | {FSM_STATE_OFF_0, POWER_SUPPLY_STATUS_UNKNOWN}, |
| 119 | {FSM_STATE_BATFETDET_START_12, POWER_SUPPLY_STATUS_UNKNOWN}, |
| 120 | {FSM_STATE_BATFETDET_END_16, POWER_SUPPLY_STATUS_UNKNOWN}, |
| 121 | /* |
| 122 | * for CHG_HIGHI_1 report NOT_CHARGING if battery missing, |
| 123 | * too hot/cold, charger too hot |
| 124 | */ |
| 125 | {FSM_STATE_ON_CHG_HIGHI_1, POWER_SUPPLY_STATUS_FULL}, |
| 126 | {FSM_STATE_ATC_2A, POWER_SUPPLY_STATUS_CHARGING}, |
| 127 | {FSM_STATE_ATC_2B, POWER_SUPPLY_STATUS_CHARGING}, |
| 128 | {FSM_STATE_ON_BAT_3, POWER_SUPPLY_STATUS_DISCHARGING}, |
| 129 | {FSM_STATE_ATC_FAIL_4, POWER_SUPPLY_STATUS_DISCHARGING}, |
| 130 | {FSM_STATE_DELAY_5, POWER_SUPPLY_STATUS_UNKNOWN }, |
| 131 | {FSM_STATE_ON_CHG_AND_BAT_6, POWER_SUPPLY_STATUS_CHARGING}, |
| 132 | {FSM_STATE_FAST_CHG_7, POWER_SUPPLY_STATUS_CHARGING}, |
| 133 | {FSM_STATE_TRKL_CHG_8, POWER_SUPPLY_STATUS_CHARGING}, |
| 134 | {FSM_STATE_CHG_FAIL_9, POWER_SUPPLY_STATUS_DISCHARGING}, |
| 135 | {FSM_STATE_EOC_10, POWER_SUPPLY_STATUS_FULL}, |
| 136 | {FSM_STATE_ON_CHG_VREGOK_11, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 137 | {FSM_STATE_ATC_PAUSE_13, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 138 | {FSM_STATE_FAST_CHG_PAUSE_14, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 139 | {FSM_STATE_TRKL_CHG_PAUSE_15, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 140 | {FSM_STATE_START_BOOT, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 141 | {FSM_STATE_FLCB_VREGOK, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 142 | {FSM_STATE_FLCB, POWER_SUPPLY_STATUS_NOT_CHARGING}, |
| 143 | }; |
| 144 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 145 | enum chg_regulation_loop { |
| 146 | VDD_LOOP = BIT(3), |
| 147 | BAT_CURRENT_LOOP = BIT(2), |
| 148 | INPUT_CURRENT_LOOP = BIT(1), |
| 149 | INPUT_VOLTAGE_LOOP = BIT(0), |
| 150 | CHG_ALL_LOOPS = VDD_LOOP | BAT_CURRENT_LOOP |
| 151 | | INPUT_CURRENT_LOOP | INPUT_VOLTAGE_LOOP, |
| 152 | }; |
| 153 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 154 | enum pmic_chg_interrupts { |
| 155 | USBIN_VALID_IRQ = 0, |
| 156 | USBIN_OV_IRQ, |
| 157 | BATT_INSERTED_IRQ, |
| 158 | VBATDET_LOW_IRQ, |
| 159 | USBIN_UV_IRQ, |
| 160 | VBAT_OV_IRQ, |
| 161 | CHGWDOG_IRQ, |
| 162 | VCP_IRQ, |
| 163 | ATCDONE_IRQ, |
| 164 | ATCFAIL_IRQ, |
| 165 | CHGDONE_IRQ, |
| 166 | CHGFAIL_IRQ, |
| 167 | CHGSTATE_IRQ, |
| 168 | LOOP_CHANGE_IRQ, |
| 169 | FASTCHG_IRQ, |
| 170 | TRKLCHG_IRQ, |
| 171 | BATT_REMOVED_IRQ, |
| 172 | BATTTEMP_HOT_IRQ, |
| 173 | CHGHOT_IRQ, |
| 174 | BATTTEMP_COLD_IRQ, |
| 175 | CHG_GONE_IRQ, |
| 176 | BAT_TEMP_OK_IRQ, |
| 177 | COARSE_DET_LOW_IRQ, |
| 178 | VDD_LOOP_IRQ, |
| 179 | VREG_OV_IRQ, |
| 180 | VBATDET_IRQ, |
| 181 | BATFET_IRQ, |
| 182 | PSI_IRQ, |
| 183 | DCIN_VALID_IRQ, |
| 184 | DCIN_OV_IRQ, |
| 185 | DCIN_UV_IRQ, |
| 186 | PM_CHG_MAX_INTS, |
| 187 | }; |
| 188 | |
| 189 | struct bms_notify { |
Abhijeet Dharmapurikar | fad7235 | 2011-09-25 23:06:05 -0700 | [diff] [blame] | 190 | int is_battery_full; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 191 | int is_charging; |
| 192 | struct work_struct work; |
| 193 | }; |
| 194 | |
| 195 | /** |
| 196 | * struct pm8921_chg_chip -device information |
| 197 | * @dev: device pointer to access the parent |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 198 | * @usb_present: present status of usb |
| 199 | * @dc_present: present status of dc |
| 200 | * @usb_charger_current: usb current to charge the battery with used when |
| 201 | * the usb path is enabled or charging is resumed |
| 202 | * @safety_time: max time for which charging will happen |
| 203 | * @update_time: how frequently the userland needs to be updated |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 204 | * @max_voltage_mv: the max volts the batt should be charged up to |
| 205 | * @min_voltage_mv: the min battery voltage before turning the FETon |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 206 | * @uvd_voltage_mv: (PM8917 only) the falling UVD threshold voltage |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 207 | * @cool_temp_dc: the cool temp threshold in deciCelcius |
| 208 | * @warm_temp_dc: the warm temp threshold in deciCelcius |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 209 | * @resume_voltage_delta: the voltage delta from vdd max at which the |
| 210 | * battery should resume charging |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 211 | * @term_current: The charging based term current |
| 212 | * |
| 213 | */ |
| 214 | struct pm8921_chg_chip { |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 215 | struct device *dev; |
| 216 | unsigned int usb_present; |
| 217 | unsigned int dc_present; |
| 218 | unsigned int usb_charger_current; |
| 219 | unsigned int max_bat_chg_current; |
| 220 | unsigned int pmic_chg_irq[PM_CHG_MAX_INTS]; |
| 221 | unsigned int safety_time; |
| 222 | unsigned int ttrkl_time; |
| 223 | unsigned int update_time; |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 224 | unsigned int max_voltage_mv; |
| 225 | unsigned int min_voltage_mv; |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 226 | unsigned int uvd_voltage_mv; |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 227 | int cool_temp_dc; |
| 228 | int warm_temp_dc; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 229 | unsigned int temp_check_period; |
| 230 | unsigned int cool_bat_chg_current; |
| 231 | unsigned int warm_bat_chg_current; |
| 232 | unsigned int cool_bat_voltage; |
| 233 | unsigned int warm_bat_voltage; |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 234 | unsigned int is_bat_cool; |
| 235 | unsigned int is_bat_warm; |
| 236 | unsigned int resume_voltage_delta; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 237 | unsigned int term_current; |
| 238 | unsigned int vbat_channel; |
| 239 | unsigned int batt_temp_channel; |
| 240 | unsigned int batt_id_channel; |
| 241 | struct power_supply usb_psy; |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 242 | struct power_supply dc_psy; |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 243 | struct power_supply *ext_psy; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 244 | struct power_supply batt_psy; |
| 245 | struct dentry *dent; |
| 246 | struct bms_notify bms_notify; |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 247 | bool keep_btm_on_suspend; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 248 | bool ext_charging; |
| 249 | bool ext_charge_done; |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 250 | bool iusb_fine_res; |
David Keitel | 5bed4f1 | 2012-05-25 18:04:14 -0700 | [diff] [blame] | 251 | bool dc_unplug_check; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 252 | DECLARE_BITMAP(enabled_irqs, PM_CHG_MAX_INTS); |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 253 | struct work_struct battery_id_valid_work; |
| 254 | int64_t batt_id_min; |
| 255 | int64_t batt_id_max; |
| 256 | int trkl_voltage; |
| 257 | int weak_voltage; |
| 258 | int trkl_current; |
| 259 | int weak_current; |
| 260 | int vin_min; |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 261 | unsigned int *thermal_mitigation; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 262 | int thermal_levels; |
| 263 | struct delayed_work update_heartbeat_work; |
| 264 | struct delayed_work eoc_work; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 265 | struct delayed_work unplug_check_work; |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 266 | struct delayed_work vin_collapse_check_work; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 267 | struct wake_lock eoc_wake_lock; |
| 268 | enum pm8921_chg_cold_thr cold_thr; |
| 269 | enum pm8921_chg_hot_thr hot_thr; |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 270 | int rconn_mohm; |
Jay Chokshi | d674a51 | 2012-03-15 14:06:04 -0700 | [diff] [blame] | 271 | enum pm8921_chg_led_src_config led_src_config; |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 272 | bool host_mode; |
David Keitel | a3cf943 | 2012-08-24 15:11:23 -0700 | [diff] [blame] | 273 | bool has_dc_supply; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 274 | u8 active_path; |
Abhijeet Dharmapurikar | de9c7e7 | 2012-07-15 16:29:51 -0700 | [diff] [blame] | 275 | int recent_reported_soc; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 276 | }; |
| 277 | |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 278 | /* user space parameter to limit usb current */ |
| 279 | static unsigned int usb_max_current; |
| 280 | /* |
| 281 | * usb_target_ma is used for wall charger |
| 282 | * adaptive input current limiting only. Use |
| 283 | * pm_iusbmax_get() to get current maximum usb current setting. |
| 284 | */ |
| 285 | static int usb_target_ma; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 286 | static int charging_disabled; |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 287 | static int thermal_mitigation; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 288 | |
| 289 | static struct pm8921_chg_chip *the_chip; |
| 290 | |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 291 | static struct pm8xxx_adc_arb_btm_param btm_config; |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 292 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 293 | static int pm_chg_masked_write(struct pm8921_chg_chip *chip, u16 addr, |
| 294 | u8 mask, u8 val) |
| 295 | { |
| 296 | int rc; |
| 297 | u8 reg; |
| 298 | |
| 299 | rc = pm8xxx_readb(chip->dev->parent, addr, ®); |
| 300 | if (rc) { |
| 301 | pr_err("pm8xxx_readb failed: addr=%03X, rc=%d\n", addr, rc); |
| 302 | return rc; |
| 303 | } |
| 304 | reg &= ~mask; |
| 305 | reg |= val & mask; |
| 306 | rc = pm8xxx_writeb(chip->dev->parent, addr, reg); |
| 307 | if (rc) { |
| 308 | pr_err("pm8xxx_writeb failed: addr=%03X, rc=%d\n", addr, rc); |
| 309 | return rc; |
| 310 | } |
| 311 | return 0; |
| 312 | } |
| 313 | |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 314 | static int pm_chg_get_rt_status(struct pm8921_chg_chip *chip, int irq_id) |
| 315 | { |
| 316 | return pm8xxx_read_irq_stat(chip->dev->parent, |
| 317 | chip->pmic_chg_irq[irq_id]); |
| 318 | } |
| 319 | |
| 320 | /* Treat OverVoltage/UnderVoltage as source missing */ |
| 321 | static int is_usb_chg_plugged_in(struct pm8921_chg_chip *chip) |
| 322 | { |
| 323 | return pm_chg_get_rt_status(chip, USBIN_VALID_IRQ); |
| 324 | } |
| 325 | |
| 326 | /* Treat OverVoltage/UnderVoltage as source missing */ |
| 327 | static int is_dc_chg_plugged_in(struct pm8921_chg_chip *chip) |
| 328 | { |
| 329 | return pm_chg_get_rt_status(chip, DCIN_VALID_IRQ); |
| 330 | } |
| 331 | |
Abhijeet Dharmapurikar | b268013 | 2012-05-15 16:32:51 -0700 | [diff] [blame] | 332 | static int is_batfet_closed(struct pm8921_chg_chip *chip) |
| 333 | { |
| 334 | return pm_chg_get_rt_status(chip, BATFET_IRQ); |
| 335 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 336 | #define CAPTURE_FSM_STATE_CMD 0xC2 |
| 337 | #define READ_BANK_7 0x70 |
| 338 | #define READ_BANK_4 0x40 |
| 339 | static int pm_chg_get_fsm_state(struct pm8921_chg_chip *chip) |
| 340 | { |
| 341 | u8 temp; |
| 342 | int err, ret = 0; |
| 343 | |
| 344 | temp = CAPTURE_FSM_STATE_CMD; |
| 345 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 346 | if (err) { |
| 347 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 348 | return err; |
| 349 | } |
| 350 | |
| 351 | temp = READ_BANK_7; |
| 352 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 353 | if (err) { |
| 354 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 355 | return err; |
| 356 | } |
| 357 | |
| 358 | err = pm8xxx_readb(chip->dev->parent, CHG_TEST, &temp); |
| 359 | if (err) { |
| 360 | pr_err("pm8xxx_readb fail: addr=%03X, rc=%d\n", CHG_TEST, err); |
| 361 | return err; |
| 362 | } |
| 363 | /* get the lower 4 bits */ |
| 364 | ret = temp & 0xF; |
| 365 | |
| 366 | temp = READ_BANK_4; |
| 367 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 368 | if (err) { |
| 369 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 370 | return err; |
| 371 | } |
| 372 | |
| 373 | err = pm8xxx_readb(chip->dev->parent, CHG_TEST, &temp); |
| 374 | if (err) { |
| 375 | pr_err("pm8xxx_readb fail: addr=%03X, rc=%d\n", CHG_TEST, err); |
| 376 | return err; |
| 377 | } |
| 378 | /* get the upper 1 bit */ |
| 379 | ret |= (temp & 0x1) << 4; |
| 380 | return ret; |
| 381 | } |
| 382 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 383 | #define READ_BANK_6 0x60 |
| 384 | static int pm_chg_get_regulation_loop(struct pm8921_chg_chip *chip) |
| 385 | { |
| 386 | u8 temp; |
| 387 | int err; |
| 388 | |
| 389 | temp = READ_BANK_6; |
| 390 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 391 | if (err) { |
| 392 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 393 | return err; |
| 394 | } |
| 395 | |
| 396 | err = pm8xxx_readb(chip->dev->parent, CHG_TEST, &temp); |
| 397 | if (err) { |
| 398 | pr_err("pm8xxx_readb fail: addr=%03X, rc=%d\n", CHG_TEST, err); |
| 399 | return err; |
| 400 | } |
| 401 | |
| 402 | /* return the lower 4 bits */ |
| 403 | return temp & CHG_ALL_LOOPS; |
| 404 | } |
| 405 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 406 | #define CHG_USB_SUSPEND_BIT BIT(2) |
| 407 | static int pm_chg_usb_suspend_enable(struct pm8921_chg_chip *chip, int enable) |
| 408 | { |
| 409 | return pm_chg_masked_write(chip, CHG_CNTRL_3, CHG_USB_SUSPEND_BIT, |
| 410 | enable ? CHG_USB_SUSPEND_BIT : 0); |
| 411 | } |
| 412 | |
| 413 | #define CHG_EN_BIT BIT(7) |
| 414 | static int pm_chg_auto_enable(struct pm8921_chg_chip *chip, int enable) |
| 415 | { |
| 416 | return pm_chg_masked_write(chip, CHG_CNTRL_3, CHG_EN_BIT, |
| 417 | enable ? CHG_EN_BIT : 0); |
| 418 | } |
| 419 | |
David Keitel | 753ec8d | 2011-11-02 10:56:37 -0700 | [diff] [blame] | 420 | #define CHG_FAILED_CLEAR BIT(0) |
| 421 | #define ATC_FAILED_CLEAR BIT(1) |
| 422 | static int pm_chg_failed_clear(struct pm8921_chg_chip *chip, int clear) |
| 423 | { |
| 424 | int rc; |
| 425 | |
| 426 | rc = pm_chg_masked_write(chip, CHG_CNTRL_3, ATC_FAILED_CLEAR, |
| 427 | clear ? ATC_FAILED_CLEAR : 0); |
| 428 | rc |= pm_chg_masked_write(chip, CHG_CNTRL_3, CHG_FAILED_CLEAR, |
| 429 | clear ? CHG_FAILED_CLEAR : 0); |
| 430 | return rc; |
| 431 | } |
| 432 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 433 | #define CHG_CHARGE_DIS_BIT BIT(1) |
| 434 | static int pm_chg_charge_dis(struct pm8921_chg_chip *chip, int disable) |
| 435 | { |
| 436 | return pm_chg_masked_write(chip, CHG_CNTRL, CHG_CHARGE_DIS_BIT, |
| 437 | disable ? CHG_CHARGE_DIS_BIT : 0); |
| 438 | } |
| 439 | |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 440 | static int pm_is_chg_charge_dis(struct pm8921_chg_chip *chip) |
| 441 | { |
| 442 | u8 temp; |
| 443 | |
| 444 | pm8xxx_readb(chip->dev->parent, CHG_CNTRL, &temp); |
| 445 | return temp & CHG_CHARGE_DIS_BIT; |
| 446 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 447 | #define PM8921_CHG_V_MIN_MV 3240 |
| 448 | #define PM8921_CHG_V_STEP_MV 20 |
Abhijeet Dharmapurikar | 08e7e0a | 2012-02-22 19:34:20 -0800 | [diff] [blame] | 449 | #define PM8921_CHG_V_STEP_10MV_OFFSET_BIT BIT(7) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 450 | #define PM8921_CHG_VDDMAX_MAX 4500 |
| 451 | #define PM8921_CHG_VDDMAX_MIN 3400 |
| 452 | #define PM8921_CHG_V_MASK 0x7F |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 453 | static int __pm_chg_vddmax_set(struct pm8921_chg_chip *chip, int voltage) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 454 | { |
Abhijeet Dharmapurikar | 08e7e0a | 2012-02-22 19:34:20 -0800 | [diff] [blame] | 455 | int remainder; |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 456 | u8 temp = 0; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 457 | |
Abhijeet Dharmapurikar | 08e7e0a | 2012-02-22 19:34:20 -0800 | [diff] [blame] | 458 | if (voltage < PM8921_CHG_VDDMAX_MIN |
| 459 | || voltage > PM8921_CHG_VDDMAX_MAX) { |
| 460 | pr_err("bad mV=%d asked to set\n", voltage); |
| 461 | return -EINVAL; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 462 | } |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 463 | |
Abhijeet Dharmapurikar | 08e7e0a | 2012-02-22 19:34:20 -0800 | [diff] [blame] | 464 | temp = (voltage - PM8921_CHG_V_MIN_MV) / PM8921_CHG_V_STEP_MV; |
| 465 | |
| 466 | remainder = voltage % 20; |
| 467 | if (remainder >= 10) { |
| 468 | temp |= PM8921_CHG_V_STEP_10MV_OFFSET_BIT; |
| 469 | } |
| 470 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 471 | pr_debug("voltage=%d setting %02x\n", voltage, temp); |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 472 | return pm8xxx_writeb(chip->dev->parent, CHG_VDD_MAX, temp); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 473 | } |
| 474 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 475 | static int pm_chg_vddmax_get(struct pm8921_chg_chip *chip, int *voltage) |
| 476 | { |
| 477 | u8 temp; |
| 478 | int rc; |
| 479 | |
| 480 | rc = pm8xxx_readb(chip->dev->parent, CHG_VDD_MAX, &temp); |
| 481 | if (rc) { |
| 482 | pr_err("rc = %d while reading vdd max\n", rc); |
Stephen Boyd | 8198223 | 2011-09-26 12:08:38 -0700 | [diff] [blame] | 483 | *voltage = 0; |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 484 | return rc; |
| 485 | } |
Abhijeet Dharmapurikar | 08e7e0a | 2012-02-22 19:34:20 -0800 | [diff] [blame] | 486 | *voltage = (int)(temp & PM8921_CHG_V_MASK) * PM8921_CHG_V_STEP_MV |
| 487 | + PM8921_CHG_V_MIN_MV; |
| 488 | if (temp & PM8921_CHG_V_STEP_10MV_OFFSET_BIT) |
| 489 | *voltage = *voltage + 10; |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 490 | return 0; |
| 491 | } |
| 492 | |
David Keitel | cf86723 | 2012-01-27 18:40:12 -0800 | [diff] [blame] | 493 | static int pm_chg_vddmax_set(struct pm8921_chg_chip *chip, int voltage) |
| 494 | { |
| 495 | int current_mv, ret, steps, i; |
| 496 | bool increase; |
| 497 | |
| 498 | ret = 0; |
| 499 | |
| 500 | if (voltage < PM8921_CHG_VDDMAX_MIN |
| 501 | || voltage > PM8921_CHG_VDDMAX_MAX) { |
| 502 | pr_err("bad mV=%d asked to set\n", voltage); |
| 503 | return -EINVAL; |
| 504 | } |
| 505 | |
| 506 | ret = pm_chg_vddmax_get(chip, ¤t_mv); |
| 507 | if (ret) { |
| 508 | pr_err("Failed to read vddmax rc=%d\n", ret); |
| 509 | return -EINVAL; |
| 510 | } |
| 511 | if (current_mv == voltage) |
| 512 | return 0; |
| 513 | |
| 514 | /* Only change in increments when USB is present */ |
| 515 | if (is_usb_chg_plugged_in(chip)) { |
| 516 | if (current_mv < voltage) { |
| 517 | steps = (voltage - current_mv) / PM8921_CHG_V_STEP_MV; |
| 518 | increase = true; |
| 519 | } else { |
| 520 | steps = (current_mv - voltage) / PM8921_CHG_V_STEP_MV; |
| 521 | increase = false; |
| 522 | } |
| 523 | for (i = 0; i < steps; i++) { |
| 524 | if (increase) |
| 525 | current_mv += PM8921_CHG_V_STEP_MV; |
| 526 | else |
| 527 | current_mv -= PM8921_CHG_V_STEP_MV; |
| 528 | ret |= __pm_chg_vddmax_set(chip, current_mv); |
| 529 | } |
| 530 | } |
| 531 | ret |= __pm_chg_vddmax_set(chip, voltage); |
| 532 | return ret; |
| 533 | } |
| 534 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 535 | #define PM8921_CHG_VDDSAFE_MIN 3400 |
| 536 | #define PM8921_CHG_VDDSAFE_MAX 4500 |
| 537 | static int pm_chg_vddsafe_set(struct pm8921_chg_chip *chip, int voltage) |
| 538 | { |
| 539 | u8 temp; |
| 540 | |
| 541 | if (voltage < PM8921_CHG_VDDSAFE_MIN |
| 542 | || voltage > PM8921_CHG_VDDSAFE_MAX) { |
| 543 | pr_err("bad mV=%d asked to set\n", voltage); |
| 544 | return -EINVAL; |
| 545 | } |
| 546 | temp = (voltage - PM8921_CHG_V_MIN_MV) / PM8921_CHG_V_STEP_MV; |
| 547 | pr_debug("voltage=%d setting %02x\n", voltage, temp); |
| 548 | return pm_chg_masked_write(chip, CHG_VDD_SAFE, PM8921_CHG_V_MASK, temp); |
| 549 | } |
| 550 | |
| 551 | #define PM8921_CHG_VBATDET_MIN 3240 |
| 552 | #define PM8921_CHG_VBATDET_MAX 5780 |
| 553 | static int pm_chg_vbatdet_set(struct pm8921_chg_chip *chip, int voltage) |
| 554 | { |
| 555 | u8 temp; |
| 556 | |
| 557 | if (voltage < PM8921_CHG_VBATDET_MIN |
| 558 | || voltage > PM8921_CHG_VBATDET_MAX) { |
| 559 | pr_err("bad mV=%d asked to set\n", voltage); |
| 560 | return -EINVAL; |
| 561 | } |
| 562 | temp = (voltage - PM8921_CHG_V_MIN_MV) / PM8921_CHG_V_STEP_MV; |
| 563 | pr_debug("voltage=%d setting %02x\n", voltage, temp); |
| 564 | return pm_chg_masked_write(chip, CHG_VBAT_DET, PM8921_CHG_V_MASK, temp); |
| 565 | } |
| 566 | |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 567 | #define PM8921_CHG_VINMIN_MIN_MV 3800 |
| 568 | #define PM8921_CHG_VINMIN_STEP_MV 100 |
| 569 | #define PM8921_CHG_VINMIN_USABLE_MAX 6500 |
| 570 | #define PM8921_CHG_VINMIN_USABLE_MIN 4300 |
| 571 | #define PM8921_CHG_VINMIN_MASK 0x1F |
| 572 | static int pm_chg_vinmin_set(struct pm8921_chg_chip *chip, int voltage) |
| 573 | { |
| 574 | u8 temp; |
| 575 | |
| 576 | if (voltage < PM8921_CHG_VINMIN_USABLE_MIN |
| 577 | || voltage > PM8921_CHG_VINMIN_USABLE_MAX) { |
| 578 | pr_err("bad mV=%d asked to set\n", voltage); |
| 579 | return -EINVAL; |
| 580 | } |
| 581 | temp = (voltage - PM8921_CHG_VINMIN_MIN_MV) / PM8921_CHG_VINMIN_STEP_MV; |
| 582 | pr_debug("voltage=%d setting %02x\n", voltage, temp); |
| 583 | return pm_chg_masked_write(chip, CHG_VIN_MIN, PM8921_CHG_VINMIN_MASK, |
| 584 | temp); |
| 585 | } |
| 586 | |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 587 | static int pm_chg_vinmin_get(struct pm8921_chg_chip *chip) |
| 588 | { |
| 589 | u8 temp; |
| 590 | int rc, voltage_mv; |
| 591 | |
| 592 | rc = pm8xxx_readb(chip->dev->parent, CHG_VIN_MIN, &temp); |
| 593 | temp &= PM8921_CHG_VINMIN_MASK; |
| 594 | |
| 595 | voltage_mv = PM8921_CHG_VINMIN_MIN_MV + |
| 596 | (int)temp * PM8921_CHG_VINMIN_STEP_MV; |
| 597 | |
| 598 | return voltage_mv; |
| 599 | } |
| 600 | |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 601 | #define PM8917_USB_UVD_MIN_MV 3850 |
| 602 | #define PM8917_USB_UVD_MAX_MV 4350 |
| 603 | #define PM8917_USB_UVD_STEP_MV 100 |
| 604 | #define PM8917_USB_UVD_MASK 0x7 |
| 605 | static int pm_chg_uvd_threshold_set(struct pm8921_chg_chip *chip, int thresh_mv) |
| 606 | { |
| 607 | u8 temp; |
| 608 | |
| 609 | if (thresh_mv < PM8917_USB_UVD_MIN_MV |
| 610 | || thresh_mv > PM8917_USB_UVD_MAX_MV) { |
| 611 | pr_err("bad mV=%d asked to set\n", thresh_mv); |
| 612 | return -EINVAL; |
| 613 | } |
| 614 | temp = (thresh_mv - PM8917_USB_UVD_MIN_MV) / PM8917_USB_UVD_STEP_MV; |
| 615 | return pm_chg_masked_write(chip, OVP_USB_UVD, |
| 616 | PM8917_USB_UVD_MASK, temp); |
| 617 | } |
| 618 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 619 | #define PM8921_CHG_IBATMAX_MIN 325 |
| 620 | #define PM8921_CHG_IBATMAX_MAX 2000 |
| 621 | #define PM8921_CHG_I_MIN_MA 225 |
| 622 | #define PM8921_CHG_I_STEP_MA 50 |
| 623 | #define PM8921_CHG_I_MASK 0x3F |
| 624 | static int pm_chg_ibatmax_set(struct pm8921_chg_chip *chip, int chg_current) |
| 625 | { |
| 626 | u8 temp; |
| 627 | |
| 628 | if (chg_current < PM8921_CHG_IBATMAX_MIN |
| 629 | || chg_current > PM8921_CHG_IBATMAX_MAX) { |
| 630 | pr_err("bad mA=%d asked to set\n", chg_current); |
| 631 | return -EINVAL; |
| 632 | } |
| 633 | temp = (chg_current - PM8921_CHG_I_MIN_MA) / PM8921_CHG_I_STEP_MA; |
| 634 | return pm_chg_masked_write(chip, CHG_IBAT_MAX, PM8921_CHG_I_MASK, temp); |
| 635 | } |
| 636 | |
| 637 | #define PM8921_CHG_IBATSAFE_MIN 225 |
| 638 | #define PM8921_CHG_IBATSAFE_MAX 3375 |
| 639 | static int pm_chg_ibatsafe_set(struct pm8921_chg_chip *chip, int chg_current) |
| 640 | { |
| 641 | u8 temp; |
| 642 | |
| 643 | if (chg_current < PM8921_CHG_IBATSAFE_MIN |
| 644 | || chg_current > PM8921_CHG_IBATSAFE_MAX) { |
| 645 | pr_err("bad mA=%d asked to set\n", chg_current); |
| 646 | return -EINVAL; |
| 647 | } |
| 648 | temp = (chg_current - PM8921_CHG_I_MIN_MA) / PM8921_CHG_I_STEP_MA; |
| 649 | return pm_chg_masked_write(chip, CHG_IBAT_SAFE, |
| 650 | PM8921_CHG_I_MASK, temp); |
| 651 | } |
| 652 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 653 | #define PM8921_CHG_ITERM_MIN_MA 50 |
Abhijeet Dharmapurikar | 71816fd | 2011-08-12 17:14:10 -0700 | [diff] [blame] | 654 | #define PM8921_CHG_ITERM_MAX_MA 200 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 655 | #define PM8921_CHG_ITERM_STEP_MA 10 |
| 656 | #define PM8921_CHG_ITERM_MASK 0xF |
| 657 | static int pm_chg_iterm_set(struct pm8921_chg_chip *chip, int chg_current) |
| 658 | { |
| 659 | u8 temp; |
| 660 | |
Abhijeet Dharmapurikar | 71816fd | 2011-08-12 17:14:10 -0700 | [diff] [blame] | 661 | if (chg_current < PM8921_CHG_ITERM_MIN_MA |
| 662 | || chg_current > PM8921_CHG_ITERM_MAX_MA) { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 663 | pr_err("bad mA=%d asked to set\n", chg_current); |
| 664 | return -EINVAL; |
| 665 | } |
| 666 | |
| 667 | temp = (chg_current - PM8921_CHG_ITERM_MIN_MA) |
| 668 | / PM8921_CHG_ITERM_STEP_MA; |
Abhijeet Dharmapurikar | 71816fd | 2011-08-12 17:14:10 -0700 | [diff] [blame] | 669 | return pm_chg_masked_write(chip, CHG_ITERM, PM8921_CHG_ITERM_MASK, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 670 | temp); |
| 671 | } |
| 672 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 673 | static int pm_chg_iterm_get(struct pm8921_chg_chip *chip, int *chg_current) |
| 674 | { |
| 675 | u8 temp; |
| 676 | int rc; |
| 677 | |
| 678 | rc = pm8xxx_readb(chip->dev->parent, CHG_ITERM, &temp); |
| 679 | if (rc) { |
| 680 | pr_err("err=%d reading CHG_ITEM\n", rc); |
Stephen Boyd | 8198223 | 2011-09-26 12:08:38 -0700 | [diff] [blame] | 681 | *chg_current = 0; |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 682 | return rc; |
| 683 | } |
| 684 | temp &= PM8921_CHG_ITERM_MASK; |
| 685 | *chg_current = (int)temp * PM8921_CHG_ITERM_STEP_MA |
| 686 | + PM8921_CHG_ITERM_MIN_MA; |
| 687 | return 0; |
| 688 | } |
| 689 | |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 690 | struct usb_ma_limit_entry { |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 691 | int usb_ma; |
| 692 | u8 value; |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 693 | }; |
| 694 | |
| 695 | static struct usb_ma_limit_entry usb_ma_table[] = { |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 696 | {100, 0x0}, |
| 697 | {200, 0x1}, |
| 698 | {500, 0x2}, |
| 699 | {600, 0x3}, |
| 700 | {700, 0x4}, |
| 701 | {800, 0x5}, |
| 702 | {850, 0x6}, |
| 703 | {900, 0x8}, |
| 704 | {950, 0x7}, |
| 705 | {1000, 0x9}, |
| 706 | {1100, 0xA}, |
| 707 | {1200, 0xB}, |
| 708 | {1300, 0xC}, |
| 709 | {1400, 0xD}, |
| 710 | {1500, 0xE}, |
| 711 | {1600, 0xF}, |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 712 | }; |
| 713 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 714 | #define PM8921_CHG_IUSB_MASK 0x1C |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 715 | #define PM8921_CHG_IUSB_SHIFT 2 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 716 | #define PM8921_CHG_IUSB_MAX 7 |
| 717 | #define PM8921_CHG_IUSB_MIN 0 |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 718 | #define PM8917_IUSB_FINE_RES BIT(0) |
Abhijeet Dharmapurikar | 485a053 | 2011-08-12 17:18:10 -0700 | [diff] [blame] | 719 | static int pm_chg_iusbmax_set(struct pm8921_chg_chip *chip, int reg_val) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 720 | { |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 721 | u8 temp, fineres; |
| 722 | int rc; |
| 723 | |
| 724 | fineres = PM8917_IUSB_FINE_RES & usb_ma_table[reg_val].value; |
| 725 | reg_val = usb_ma_table[reg_val].value >> 1; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 726 | |
Abhijeet Dharmapurikar | 485a053 | 2011-08-12 17:18:10 -0700 | [diff] [blame] | 727 | if (reg_val < PM8921_CHG_IUSB_MIN || reg_val > PM8921_CHG_IUSB_MAX) { |
| 728 | pr_err("bad mA=%d asked to set\n", reg_val); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 729 | return -EINVAL; |
| 730 | } |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 731 | temp = reg_val << PM8921_CHG_IUSB_SHIFT; |
| 732 | |
| 733 | /* IUSB_FINE_RES */ |
| 734 | if (chip->iusb_fine_res) { |
| 735 | /* Clear IUSB_FINE_RES bit to avoid overshoot */ |
| 736 | rc = pm_chg_masked_write(chip, IUSB_FINE_RES, |
| 737 | PM8917_IUSB_FINE_RES, 0); |
| 738 | |
| 739 | rc |= pm_chg_masked_write(chip, PBL_ACCESS2, |
| 740 | PM8921_CHG_IUSB_MASK, temp); |
| 741 | |
| 742 | if (rc) { |
| 743 | pr_err("Failed to write PBL_ACCESS2 rc=%d\n", rc); |
| 744 | return rc; |
| 745 | } |
| 746 | |
| 747 | if (fineres) { |
| 748 | rc = pm_chg_masked_write(chip, IUSB_FINE_RES, |
| 749 | PM8917_IUSB_FINE_RES, fineres); |
| 750 | if (rc) |
| 751 | pr_err("Failed to write ISUB_FINE_RES rc=%d\n", |
| 752 | rc); |
| 753 | } |
| 754 | } else { |
| 755 | rc = pm_chg_masked_write(chip, PBL_ACCESS2, |
| 756 | PM8921_CHG_IUSB_MASK, temp); |
| 757 | if (rc) |
| 758 | pr_err("Failed to write PBL_ACCESS2 rc=%d\n", rc); |
| 759 | } |
| 760 | |
| 761 | return rc; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 762 | } |
| 763 | |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 764 | static int pm_chg_iusbmax_get(struct pm8921_chg_chip *chip, int *mA) |
| 765 | { |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 766 | u8 temp, fineres; |
| 767 | int rc, i; |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 768 | |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 769 | fineres = 0; |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 770 | *mA = 0; |
| 771 | rc = pm8xxx_readb(chip->dev->parent, PBL_ACCESS2, &temp); |
| 772 | if (rc) { |
| 773 | pr_err("err=%d reading PBL_ACCESS2\n", rc); |
| 774 | return rc; |
| 775 | } |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 776 | |
| 777 | if (chip->iusb_fine_res) { |
| 778 | rc = pm8xxx_readb(chip->dev->parent, IUSB_FINE_RES, &fineres); |
| 779 | if (rc) { |
| 780 | pr_err("err=%d reading IUSB_FINE_RES\n", rc); |
| 781 | return rc; |
| 782 | } |
| 783 | } |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 784 | temp &= PM8921_CHG_IUSB_MASK; |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 785 | temp = temp >> PM8921_CHG_IUSB_SHIFT; |
| 786 | |
| 787 | temp = (temp << 1) | (fineres & PM8917_IUSB_FINE_RES); |
| 788 | for (i = ARRAY_SIZE(usb_ma_table) - 1; i >= 0; i--) { |
| 789 | if (usb_ma_table[i].value == temp) |
| 790 | break; |
| 791 | } |
| 792 | |
| 793 | *mA = usb_ma_table[i].usb_ma; |
| 794 | |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 795 | return rc; |
| 796 | } |
| 797 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 798 | #define PM8921_CHG_WD_MASK 0x1F |
| 799 | static int pm_chg_disable_wd(struct pm8921_chg_chip *chip) |
| 800 | { |
| 801 | /* writing 0 to the wd timer disables it */ |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 802 | return pm_chg_masked_write(chip, CHG_TWDOG, PM8921_CHG_WD_MASK, 0); |
| 803 | } |
| 804 | |
Abhijeet Dharmapurikar | c26cd90 | 2011-10-26 18:07:45 -0700 | [diff] [blame] | 805 | #define PM8921_CHG_TCHG_MASK 0x7F |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 806 | #define PM8921_CHG_TCHG_MIN 4 |
| 807 | #define PM8921_CHG_TCHG_MAX 512 |
| 808 | #define PM8921_CHG_TCHG_STEP 4 |
| 809 | static int pm_chg_tchg_max_set(struct pm8921_chg_chip *chip, int minutes) |
| 810 | { |
| 811 | u8 temp; |
| 812 | |
| 813 | if (minutes < PM8921_CHG_TCHG_MIN || minutes > PM8921_CHG_TCHG_MAX) { |
| 814 | pr_err("bad max minutes =%d asked to set\n", minutes); |
| 815 | return -EINVAL; |
| 816 | } |
| 817 | |
| 818 | temp = (minutes - 1)/PM8921_CHG_TCHG_STEP; |
| 819 | return pm_chg_masked_write(chip, CHG_TCHG_MAX, PM8921_CHG_TCHG_MASK, |
| 820 | temp); |
| 821 | } |
| 822 | |
David Keitel | fb81b0a | 2012-08-31 20:00:53 -0700 | [diff] [blame^] | 823 | #define PM8921_CHG_TTRKL_MASK 0x3F |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 824 | #define PM8921_CHG_TTRKL_MIN 1 |
| 825 | #define PM8921_CHG_TTRKL_MAX 64 |
| 826 | static int pm_chg_ttrkl_max_set(struct pm8921_chg_chip *chip, int minutes) |
| 827 | { |
| 828 | u8 temp; |
| 829 | |
| 830 | if (minutes < PM8921_CHG_TTRKL_MIN || minutes > PM8921_CHG_TTRKL_MAX) { |
| 831 | pr_err("bad max minutes =%d asked to set\n", minutes); |
| 832 | return -EINVAL; |
| 833 | } |
| 834 | |
| 835 | temp = minutes - 1; |
| 836 | return pm_chg_masked_write(chip, CHG_TTRKL_MAX, PM8921_CHG_TTRKL_MASK, |
| 837 | temp); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 838 | } |
| 839 | |
Abhijeet Dharmapurikar | 26cef9c | 2011-08-25 19:16:42 -0700 | [diff] [blame] | 840 | #define PM8921_CHG_VTRKL_MIN_MV 2050 |
| 841 | #define PM8921_CHG_VTRKL_MAX_MV 2800 |
| 842 | #define PM8921_CHG_VTRKL_STEP_MV 50 |
| 843 | #define PM8921_CHG_VTRKL_SHIFT 4 |
| 844 | #define PM8921_CHG_VTRKL_MASK 0xF0 |
| 845 | static int pm_chg_vtrkl_low_set(struct pm8921_chg_chip *chip, int millivolts) |
| 846 | { |
| 847 | u8 temp; |
| 848 | |
| 849 | if (millivolts < PM8921_CHG_VTRKL_MIN_MV |
| 850 | || millivolts > PM8921_CHG_VTRKL_MAX_MV) { |
| 851 | pr_err("bad voltage = %dmV asked to set\n", millivolts); |
| 852 | return -EINVAL; |
| 853 | } |
| 854 | |
| 855 | temp = (millivolts - PM8921_CHG_VTRKL_MIN_MV)/PM8921_CHG_VTRKL_STEP_MV; |
| 856 | temp = temp << PM8921_CHG_VTRKL_SHIFT; |
| 857 | return pm_chg_masked_write(chip, CHG_VTRICKLE, PM8921_CHG_VTRKL_MASK, |
| 858 | temp); |
| 859 | } |
| 860 | |
| 861 | #define PM8921_CHG_VWEAK_MIN_MV 2100 |
| 862 | #define PM8921_CHG_VWEAK_MAX_MV 3600 |
| 863 | #define PM8921_CHG_VWEAK_STEP_MV 100 |
| 864 | #define PM8921_CHG_VWEAK_MASK 0x0F |
| 865 | static int pm_chg_vweak_set(struct pm8921_chg_chip *chip, int millivolts) |
| 866 | { |
| 867 | u8 temp; |
| 868 | |
| 869 | if (millivolts < PM8921_CHG_VWEAK_MIN_MV |
| 870 | || millivolts > PM8921_CHG_VWEAK_MAX_MV) { |
| 871 | pr_err("bad voltage = %dmV asked to set\n", millivolts); |
| 872 | return -EINVAL; |
| 873 | } |
| 874 | |
| 875 | temp = (millivolts - PM8921_CHG_VWEAK_MIN_MV)/PM8921_CHG_VWEAK_STEP_MV; |
| 876 | return pm_chg_masked_write(chip, CHG_VTRICKLE, PM8921_CHG_VWEAK_MASK, |
| 877 | temp); |
| 878 | } |
| 879 | |
| 880 | #define PM8921_CHG_ITRKL_MIN_MA 50 |
| 881 | #define PM8921_CHG_ITRKL_MAX_MA 200 |
| 882 | #define PM8921_CHG_ITRKL_MASK 0x0F |
| 883 | #define PM8921_CHG_ITRKL_STEP_MA 10 |
| 884 | static int pm_chg_itrkl_set(struct pm8921_chg_chip *chip, int milliamps) |
| 885 | { |
| 886 | u8 temp; |
| 887 | |
| 888 | if (milliamps < PM8921_CHG_ITRKL_MIN_MA |
| 889 | || milliamps > PM8921_CHG_ITRKL_MAX_MA) { |
| 890 | pr_err("bad current = %dmA asked to set\n", milliamps); |
| 891 | return -EINVAL; |
| 892 | } |
| 893 | |
| 894 | temp = (milliamps - PM8921_CHG_ITRKL_MIN_MA)/PM8921_CHG_ITRKL_STEP_MA; |
| 895 | |
| 896 | return pm_chg_masked_write(chip, CHG_ITRICKLE, PM8921_CHG_ITRKL_MASK, |
| 897 | temp); |
| 898 | } |
| 899 | |
| 900 | #define PM8921_CHG_IWEAK_MIN_MA 325 |
| 901 | #define PM8921_CHG_IWEAK_MAX_MA 525 |
| 902 | #define PM8921_CHG_IWEAK_SHIFT 7 |
| 903 | #define PM8921_CHG_IWEAK_MASK 0x80 |
| 904 | static int pm_chg_iweak_set(struct pm8921_chg_chip *chip, int milliamps) |
| 905 | { |
| 906 | u8 temp; |
| 907 | |
| 908 | if (milliamps < PM8921_CHG_IWEAK_MIN_MA |
| 909 | || milliamps > PM8921_CHG_IWEAK_MAX_MA) { |
| 910 | pr_err("bad current = %dmA asked to set\n", milliamps); |
| 911 | return -EINVAL; |
| 912 | } |
| 913 | |
| 914 | if (milliamps < PM8921_CHG_IWEAK_MAX_MA) |
| 915 | temp = 0; |
| 916 | else |
| 917 | temp = 1; |
| 918 | |
| 919 | temp = temp << PM8921_CHG_IWEAK_SHIFT; |
| 920 | return pm_chg_masked_write(chip, CHG_ITRICKLE, PM8921_CHG_IWEAK_MASK, |
| 921 | temp); |
| 922 | } |
| 923 | |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 924 | #define PM8921_CHG_BATT_TEMP_THR_COLD BIT(1) |
| 925 | #define PM8921_CHG_BATT_TEMP_THR_COLD_SHIFT 1 |
| 926 | static int pm_chg_batt_cold_temp_config(struct pm8921_chg_chip *chip, |
| 927 | enum pm8921_chg_cold_thr cold_thr) |
| 928 | { |
| 929 | u8 temp; |
| 930 | |
| 931 | temp = cold_thr << PM8921_CHG_BATT_TEMP_THR_COLD_SHIFT; |
| 932 | temp = temp & PM8921_CHG_BATT_TEMP_THR_COLD; |
| 933 | return pm_chg_masked_write(chip, CHG_CNTRL_2, |
| 934 | PM8921_CHG_BATT_TEMP_THR_COLD, |
| 935 | temp); |
| 936 | } |
| 937 | |
| 938 | #define PM8921_CHG_BATT_TEMP_THR_HOT BIT(0) |
| 939 | #define PM8921_CHG_BATT_TEMP_THR_HOT_SHIFT 0 |
| 940 | static int pm_chg_batt_hot_temp_config(struct pm8921_chg_chip *chip, |
| 941 | enum pm8921_chg_hot_thr hot_thr) |
| 942 | { |
| 943 | u8 temp; |
| 944 | |
| 945 | temp = hot_thr << PM8921_CHG_BATT_TEMP_THR_HOT_SHIFT; |
| 946 | temp = temp & PM8921_CHG_BATT_TEMP_THR_HOT; |
| 947 | return pm_chg_masked_write(chip, CHG_CNTRL_2, |
| 948 | PM8921_CHG_BATT_TEMP_THR_HOT, |
| 949 | temp); |
| 950 | } |
| 951 | |
Jay Chokshi | d674a51 | 2012-03-15 14:06:04 -0700 | [diff] [blame] | 952 | #define PM8921_CHG_LED_SRC_CONFIG_SHIFT 4 |
| 953 | #define PM8921_CHG_LED_SRC_CONFIG_MASK 0x30 |
| 954 | static int pm_chg_led_src_config(struct pm8921_chg_chip *chip, |
| 955 | enum pm8921_chg_led_src_config led_src_config) |
| 956 | { |
| 957 | u8 temp; |
| 958 | |
| 959 | if (led_src_config < LED_SRC_GND || |
| 960 | led_src_config > LED_SRC_BYPASS) |
| 961 | return -EINVAL; |
| 962 | |
| 963 | if (led_src_config == LED_SRC_BYPASS) |
| 964 | return 0; |
| 965 | |
| 966 | temp = led_src_config << PM8921_CHG_LED_SRC_CONFIG_SHIFT; |
| 967 | |
| 968 | return pm_chg_masked_write(chip, CHG_CNTRL_3, |
| 969 | PM8921_CHG_LED_SRC_CONFIG_MASK, temp); |
| 970 | } |
| 971 | |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 972 | static void disable_input_voltage_regulation(struct pm8921_chg_chip *chip) |
| 973 | { |
| 974 | u8 temp; |
| 975 | int rc; |
| 976 | |
| 977 | rc = pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, 0x70); |
| 978 | if (rc) { |
| 979 | pr_err("Failed to write 0x70 to CTRL_TEST3 rc = %d\n", rc); |
| 980 | return; |
| 981 | } |
| 982 | rc = pm8xxx_readb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, &temp); |
| 983 | if (rc) { |
| 984 | pr_err("Failed to read CTRL_TEST3 rc = %d\n", rc); |
| 985 | return; |
| 986 | } |
| 987 | /* set the input voltage disable bit and the write bit */ |
| 988 | temp |= 0x81; |
| 989 | rc = pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, temp); |
| 990 | if (rc) { |
| 991 | pr_err("Failed to write 0x%x to CTRL_TEST3 rc=%d\n", temp, rc); |
| 992 | return; |
| 993 | } |
| 994 | } |
| 995 | |
| 996 | static void enable_input_voltage_regulation(struct pm8921_chg_chip *chip) |
| 997 | { |
| 998 | u8 temp; |
| 999 | int rc; |
| 1000 | |
| 1001 | rc = pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, 0x70); |
| 1002 | if (rc) { |
| 1003 | pr_err("Failed to write 0x70 to CTRL_TEST3 rc = %d\n", rc); |
| 1004 | return; |
| 1005 | } |
| 1006 | rc = pm8xxx_readb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, &temp); |
| 1007 | if (rc) { |
| 1008 | pr_err("Failed to read CTRL_TEST3 rc = %d\n", rc); |
| 1009 | return; |
| 1010 | } |
| 1011 | /* unset the input voltage disable bit */ |
| 1012 | temp &= 0xFE; |
| 1013 | /* set the write bit */ |
| 1014 | temp |= 0x80; |
| 1015 | rc = pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, temp); |
| 1016 | if (rc) { |
| 1017 | pr_err("Failed to write 0x%x to CTRL_TEST3 rc=%d\n", temp, rc); |
| 1018 | return; |
| 1019 | } |
| 1020 | } |
| 1021 | |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 1022 | static int64_t read_battery_id(struct pm8921_chg_chip *chip) |
| 1023 | { |
| 1024 | int rc; |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1025 | struct pm8xxx_adc_chan_result result; |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 1026 | |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1027 | rc = pm8xxx_adc_read(chip->batt_id_channel, &result); |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 1028 | if (rc) { |
| 1029 | pr_err("error reading batt id channel = %d, rc = %d\n", |
| 1030 | chip->vbat_channel, rc); |
| 1031 | return rc; |
| 1032 | } |
| 1033 | pr_debug("batt_id phy = %lld meas = 0x%llx\n", result.physical, |
| 1034 | result.measurement); |
| 1035 | return result.physical; |
| 1036 | } |
| 1037 | |
| 1038 | static int is_battery_valid(struct pm8921_chg_chip *chip) |
| 1039 | { |
| 1040 | int64_t rc; |
| 1041 | |
| 1042 | if (chip->batt_id_min == 0 && chip->batt_id_max == 0) |
| 1043 | return 1; |
| 1044 | |
| 1045 | rc = read_battery_id(chip); |
| 1046 | if (rc < 0) { |
| 1047 | pr_err("error reading batt id channel = %d, rc = %lld\n", |
| 1048 | chip->vbat_channel, rc); |
| 1049 | /* assume battery id is valid when adc error happens */ |
| 1050 | return 1; |
| 1051 | } |
| 1052 | |
| 1053 | if (rc < chip->batt_id_min || rc > chip->batt_id_max) { |
| 1054 | pr_err("batt_id phy =%lld is not valid\n", rc); |
| 1055 | return 0; |
| 1056 | } |
| 1057 | return 1; |
| 1058 | } |
| 1059 | |
| 1060 | static void check_battery_valid(struct pm8921_chg_chip *chip) |
| 1061 | { |
| 1062 | if (is_battery_valid(chip) == 0) { |
| 1063 | pr_err("batt_id not valid, disbling charging\n"); |
| 1064 | pm_chg_auto_enable(chip, 0); |
| 1065 | } else { |
| 1066 | pm_chg_auto_enable(chip, !charging_disabled); |
| 1067 | } |
| 1068 | } |
| 1069 | |
| 1070 | static void battery_id_valid(struct work_struct *work) |
| 1071 | { |
| 1072 | struct pm8921_chg_chip *chip = container_of(work, |
| 1073 | struct pm8921_chg_chip, battery_id_valid_work); |
| 1074 | |
| 1075 | check_battery_valid(chip); |
| 1076 | } |
| 1077 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1078 | static void pm8921_chg_enable_irq(struct pm8921_chg_chip *chip, int interrupt) |
| 1079 | { |
| 1080 | if (!__test_and_set_bit(interrupt, chip->enabled_irqs)) { |
| 1081 | dev_dbg(chip->dev, "%d\n", chip->pmic_chg_irq[interrupt]); |
| 1082 | enable_irq(chip->pmic_chg_irq[interrupt]); |
| 1083 | } |
| 1084 | } |
| 1085 | |
| 1086 | static void pm8921_chg_disable_irq(struct pm8921_chg_chip *chip, int interrupt) |
| 1087 | { |
| 1088 | if (__test_and_clear_bit(interrupt, chip->enabled_irqs)) { |
| 1089 | dev_dbg(chip->dev, "%d\n", chip->pmic_chg_irq[interrupt]); |
| 1090 | disable_irq_nosync(chip->pmic_chg_irq[interrupt]); |
| 1091 | } |
| 1092 | } |
| 1093 | |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 1094 | static int pm8921_chg_is_enabled(struct pm8921_chg_chip *chip, int interrupt) |
| 1095 | { |
| 1096 | return test_bit(interrupt, chip->enabled_irqs); |
| 1097 | } |
| 1098 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1099 | static bool is_ext_charging(struct pm8921_chg_chip *chip) |
| 1100 | { |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1101 | union power_supply_propval ret = {0,}; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1102 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1103 | if (!chip->ext_psy) |
| 1104 | return false; |
| 1105 | if (chip->ext_psy->get_property(chip->ext_psy, |
| 1106 | POWER_SUPPLY_PROP_CHARGE_TYPE, &ret)) |
| 1107 | return false; |
| 1108 | if (ret.intval > POWER_SUPPLY_CHARGE_TYPE_NONE) |
| 1109 | return ret.intval; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1110 | |
| 1111 | return false; |
| 1112 | } |
| 1113 | |
| 1114 | static bool is_ext_trickle_charging(struct pm8921_chg_chip *chip) |
| 1115 | { |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1116 | union power_supply_propval ret = {0,}; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1117 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1118 | if (!chip->ext_psy) |
| 1119 | return false; |
| 1120 | if (chip->ext_psy->get_property(chip->ext_psy, |
| 1121 | POWER_SUPPLY_PROP_CHARGE_TYPE, &ret)) |
| 1122 | return false; |
| 1123 | if (ret.intval == POWER_SUPPLY_CHARGE_TYPE_TRICKLE) |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1124 | return true; |
| 1125 | |
| 1126 | return false; |
| 1127 | } |
| 1128 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1129 | static int is_battery_charging(int fsm_state) |
| 1130 | { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1131 | if (is_ext_charging(the_chip)) |
| 1132 | return 1; |
| 1133 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1134 | switch (fsm_state) { |
| 1135 | case FSM_STATE_ATC_2A: |
| 1136 | case FSM_STATE_ATC_2B: |
| 1137 | case FSM_STATE_ON_CHG_AND_BAT_6: |
| 1138 | case FSM_STATE_FAST_CHG_7: |
| 1139 | case FSM_STATE_TRKL_CHG_8: |
| 1140 | return 1; |
| 1141 | } |
| 1142 | return 0; |
| 1143 | } |
| 1144 | |
| 1145 | static void bms_notify(struct work_struct *work) |
| 1146 | { |
| 1147 | struct bms_notify *n = container_of(work, struct bms_notify, work); |
| 1148 | |
Abhijeet Dharmapurikar | fad7235 | 2011-09-25 23:06:05 -0700 | [diff] [blame] | 1149 | if (n->is_charging) { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1150 | pm8921_bms_charging_began(); |
Abhijeet Dharmapurikar | fad7235 | 2011-09-25 23:06:05 -0700 | [diff] [blame] | 1151 | } else { |
| 1152 | pm8921_bms_charging_end(n->is_battery_full); |
| 1153 | n->is_battery_full = 0; |
| 1154 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1155 | } |
| 1156 | |
Abhijeet Dharmapurikar | f247105 | 2011-09-25 22:18:36 -0700 | [diff] [blame] | 1157 | static void bms_notify_check(struct pm8921_chg_chip *chip) |
| 1158 | { |
| 1159 | int fsm_state, new_is_charging; |
| 1160 | |
| 1161 | fsm_state = pm_chg_get_fsm_state(chip); |
| 1162 | new_is_charging = is_battery_charging(fsm_state); |
| 1163 | |
| 1164 | if (chip->bms_notify.is_charging ^ new_is_charging) { |
| 1165 | chip->bms_notify.is_charging = new_is_charging; |
| 1166 | schedule_work(&(chip->bms_notify.work)); |
| 1167 | } |
| 1168 | } |
| 1169 | |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1170 | static enum power_supply_property pm_power_props_usb[] = { |
| 1171 | POWER_SUPPLY_PROP_PRESENT, |
| 1172 | POWER_SUPPLY_PROP_ONLINE, |
| 1173 | POWER_SUPPLY_PROP_CURRENT_MAX, |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 1174 | POWER_SUPPLY_PROP_SCOPE, |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1175 | }; |
| 1176 | |
| 1177 | static enum power_supply_property pm_power_props_mains[] = { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1178 | POWER_SUPPLY_PROP_PRESENT, |
Willie Ruan | 9ad6d83 | 2011-08-19 11:58:42 -0700 | [diff] [blame] | 1179 | POWER_SUPPLY_PROP_ONLINE, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1180 | }; |
| 1181 | |
| 1182 | static char *pm_power_supplied_to[] = { |
| 1183 | "battery", |
| 1184 | }; |
| 1185 | |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 1186 | #define USB_WALL_THRESHOLD_MA 500 |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1187 | static int pm_power_get_property_mains(struct power_supply *psy, |
| 1188 | enum power_supply_property psp, |
| 1189 | union power_supply_propval *val) |
| 1190 | { |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1191 | /* Check if called before init */ |
| 1192 | if (!the_chip) |
| 1193 | return -EINVAL; |
| 1194 | |
| 1195 | switch (psp) { |
| 1196 | case POWER_SUPPLY_PROP_PRESENT: |
| 1197 | case POWER_SUPPLY_PROP_ONLINE: |
| 1198 | val->intval = 0; |
David Keitel | a3cf943 | 2012-08-24 15:11:23 -0700 | [diff] [blame] | 1199 | |
| 1200 | if (the_chip->has_dc_supply) { |
| 1201 | val->intval = 1; |
| 1202 | return 0; |
| 1203 | } |
| 1204 | |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1205 | if (charging_disabled) |
| 1206 | return 0; |
| 1207 | |
| 1208 | /* check external charger first before the dc path */ |
| 1209 | if (is_ext_charging(the_chip)) { |
| 1210 | val->intval = 1; |
| 1211 | return 0; |
| 1212 | } |
| 1213 | |
| 1214 | if (pm_is_chg_charge_dis(the_chip)) { |
| 1215 | val->intval = 0; |
| 1216 | return 0; |
| 1217 | } |
| 1218 | |
| 1219 | if (the_chip->dc_present) { |
| 1220 | val->intval = 1; |
| 1221 | return 0; |
| 1222 | } |
| 1223 | |
| 1224 | /* USB with max current greater than 500 mA connected */ |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1225 | if (usb_target_ma > USB_WALL_THRESHOLD_MA) |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1226 | val->intval = is_usb_chg_plugged_in(the_chip); |
| 1227 | return 0; |
| 1228 | |
| 1229 | break; |
| 1230 | default: |
| 1231 | return -EINVAL; |
| 1232 | } |
| 1233 | return 0; |
| 1234 | } |
| 1235 | |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 1236 | static int switch_usb_to_charge_mode(struct pm8921_chg_chip *chip) |
| 1237 | { |
| 1238 | int rc; |
| 1239 | |
| 1240 | if (!chip->host_mode) |
| 1241 | return 0; |
| 1242 | |
| 1243 | /* enable usbin valid comparator and remove force usb ovp fet off */ |
| 1244 | rc = pm8xxx_writeb(chip->dev->parent, USB_OVP_TEST, 0xB2); |
| 1245 | if (rc < 0) { |
| 1246 | pr_err("Failed to write 0xB2 to USB_OVP_TEST rc = %d\n", rc); |
| 1247 | return rc; |
| 1248 | } |
| 1249 | |
| 1250 | chip->host_mode = 0; |
| 1251 | |
| 1252 | return 0; |
| 1253 | } |
| 1254 | |
| 1255 | static int switch_usb_to_host_mode(struct pm8921_chg_chip *chip) |
| 1256 | { |
| 1257 | int rc; |
| 1258 | |
| 1259 | if (chip->host_mode) |
| 1260 | return 0; |
| 1261 | |
| 1262 | /* disable usbin valid comparator and force usb ovp fet off */ |
| 1263 | rc = pm8xxx_writeb(chip->dev->parent, USB_OVP_TEST, 0xB3); |
| 1264 | if (rc < 0) { |
| 1265 | pr_err("Failed to write 0xB3 to USB_OVP_TEST rc = %d\n", rc); |
| 1266 | return rc; |
| 1267 | } |
| 1268 | |
| 1269 | chip->host_mode = 1; |
| 1270 | |
| 1271 | return 0; |
| 1272 | } |
| 1273 | |
| 1274 | static int pm_power_set_property_usb(struct power_supply *psy, |
| 1275 | enum power_supply_property psp, |
| 1276 | const union power_supply_propval *val) |
| 1277 | { |
| 1278 | /* Check if called before init */ |
| 1279 | if (!the_chip) |
| 1280 | return -EINVAL; |
| 1281 | |
| 1282 | switch (psp) { |
| 1283 | case POWER_SUPPLY_PROP_SCOPE: |
| 1284 | if (val->intval == POWER_SUPPLY_SCOPE_SYSTEM) |
| 1285 | return switch_usb_to_host_mode(the_chip); |
| 1286 | if (val->intval == POWER_SUPPLY_SCOPE_DEVICE) |
| 1287 | return switch_usb_to_charge_mode(the_chip); |
| 1288 | else |
| 1289 | return -EINVAL; |
| 1290 | break; |
David Keitel | 0e65147 | 2012-06-06 14:44:38 -0700 | [diff] [blame] | 1291 | case POWER_SUPPLY_PROP_TYPE: |
| 1292 | return pm8921_set_usb_power_supply_type(val->intval); |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 1293 | default: |
| 1294 | return -EINVAL; |
| 1295 | } |
| 1296 | return 0; |
| 1297 | } |
| 1298 | |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1299 | static int pm_power_get_property_usb(struct power_supply *psy, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1300 | enum power_supply_property psp, |
| 1301 | union power_supply_propval *val) |
| 1302 | { |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 1303 | int current_max; |
| 1304 | |
| 1305 | /* Check if called before init */ |
| 1306 | if (!the_chip) |
| 1307 | return -EINVAL; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1308 | |
| 1309 | switch (psp) { |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 1310 | case POWER_SUPPLY_PROP_CURRENT_MAX: |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1311 | if (pm_is_chg_charge_dis(the_chip)) { |
| 1312 | val->intval = 0; |
| 1313 | } else { |
| 1314 | pm_chg_iusbmax_get(the_chip, ¤t_max); |
| 1315 | val->intval = current_max; |
| 1316 | } |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 1317 | break; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1318 | case POWER_SUPPLY_PROP_PRESENT: |
Willie Ruan | 9ad6d83 | 2011-08-19 11:58:42 -0700 | [diff] [blame] | 1319 | case POWER_SUPPLY_PROP_ONLINE: |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 1320 | val->intval = 0; |
| 1321 | if (charging_disabled) |
| 1322 | return 0; |
| 1323 | |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 1324 | /* |
| 1325 | * if drawing any current from usb is disabled behave |
| 1326 | * as if no usb cable is connected |
| 1327 | */ |
| 1328 | if (pm_is_chg_charge_dis(the_chip)) |
| 1329 | return 0; |
| 1330 | |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 1331 | /* USB charging */ |
David Keitel | af51571 | 2012-04-13 17:25:31 -0700 | [diff] [blame] | 1332 | if (usb_target_ma < USB_WALL_THRESHOLD_MA) |
David Keitel | 8603402 | 2012-04-18 12:33:58 -0700 | [diff] [blame] | 1333 | val->intval = is_usb_chg_plugged_in(the_chip); |
David Keitel | af51571 | 2012-04-13 17:25:31 -0700 | [diff] [blame] | 1334 | else |
| 1335 | return 0; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1336 | break; |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 1337 | |
| 1338 | case POWER_SUPPLY_PROP_SCOPE: |
| 1339 | if (the_chip->host_mode) |
| 1340 | val->intval = POWER_SUPPLY_SCOPE_SYSTEM; |
| 1341 | else |
| 1342 | val->intval = POWER_SUPPLY_SCOPE_DEVICE; |
| 1343 | break; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1344 | default: |
| 1345 | return -EINVAL; |
| 1346 | } |
| 1347 | return 0; |
| 1348 | } |
| 1349 | |
| 1350 | static enum power_supply_property msm_batt_power_props[] = { |
| 1351 | POWER_SUPPLY_PROP_STATUS, |
| 1352 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
| 1353 | POWER_SUPPLY_PROP_HEALTH, |
| 1354 | POWER_SUPPLY_PROP_PRESENT, |
| 1355 | POWER_SUPPLY_PROP_TECHNOLOGY, |
| 1356 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, |
| 1357 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, |
| 1358 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 1359 | POWER_SUPPLY_PROP_CAPACITY, |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1360 | POWER_SUPPLY_PROP_CURRENT_NOW, |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1361 | POWER_SUPPLY_PROP_TEMP, |
Abhijeet Dharmapurikar | 325bdc9 | 2011-09-07 20:45:49 -0700 | [diff] [blame] | 1362 | POWER_SUPPLY_PROP_ENERGY_FULL, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1363 | }; |
| 1364 | |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1365 | static int get_prop_battery_uvolts(struct pm8921_chg_chip *chip) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1366 | { |
| 1367 | int rc; |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1368 | struct pm8xxx_adc_chan_result result; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1369 | |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1370 | rc = pm8xxx_adc_read(chip->vbat_channel, &result); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1371 | if (rc) { |
| 1372 | pr_err("error reading adc channel = %d, rc = %d\n", |
| 1373 | chip->vbat_channel, rc); |
| 1374 | return rc; |
| 1375 | } |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 1376 | pr_debug("mvolts phy = %lld meas = 0x%llx\n", result.physical, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1377 | result.measurement); |
| 1378 | return (int)result.physical; |
| 1379 | } |
| 1380 | |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1381 | static unsigned int voltage_based_capacity(struct pm8921_chg_chip *chip) |
| 1382 | { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1383 | unsigned int current_voltage_uv = get_prop_battery_uvolts(chip); |
| 1384 | unsigned int current_voltage_mv = current_voltage_uv / 1000; |
| 1385 | unsigned int low_voltage = chip->min_voltage_mv; |
| 1386 | unsigned int high_voltage = chip->max_voltage_mv; |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1387 | |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1388 | if (current_voltage_mv <= low_voltage) |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1389 | return 0; |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1390 | else if (current_voltage_mv >= high_voltage) |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1391 | return 100; |
| 1392 | else |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1393 | return (current_voltage_mv - low_voltage) * 100 |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1394 | / (high_voltage - low_voltage); |
| 1395 | } |
| 1396 | |
David Keitel | 4f9397b | 2012-04-16 11:46:16 -0700 | [diff] [blame] | 1397 | static int get_prop_batt_present(struct pm8921_chg_chip *chip) |
| 1398 | { |
| 1399 | return pm_chg_get_rt_status(chip, BATT_INSERTED_IRQ); |
| 1400 | } |
| 1401 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1402 | static int get_prop_batt_capacity(struct pm8921_chg_chip *chip) |
| 1403 | { |
David Keitel | 4f9397b | 2012-04-16 11:46:16 -0700 | [diff] [blame] | 1404 | int percent_soc; |
| 1405 | |
| 1406 | if (!get_prop_batt_present(chip)) |
| 1407 | percent_soc = voltage_based_capacity(chip); |
| 1408 | else |
| 1409 | percent_soc = pm8921_bms_get_percent_charge(); |
Abhijeet Dharmapurikar | 5a7df4e | 2011-07-27 13:16:24 -0700 | [diff] [blame] | 1410 | |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1411 | if (percent_soc == -ENXIO) |
| 1412 | percent_soc = voltage_based_capacity(chip); |
| 1413 | |
Abhijeet Dharmapurikar | 5a7df4e | 2011-07-27 13:16:24 -0700 | [diff] [blame] | 1414 | if (percent_soc <= 10) |
| 1415 | pr_warn("low battery charge = %d%%\n", percent_soc); |
| 1416 | |
Abhijeet Dharmapurikar | de9c7e7 | 2012-07-15 16:29:51 -0700 | [diff] [blame] | 1417 | chip->recent_reported_soc = percent_soc; |
Abhijeet Dharmapurikar | 5a7df4e | 2011-07-27 13:16:24 -0700 | [diff] [blame] | 1418 | return percent_soc; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1419 | } |
| 1420 | |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1421 | static int get_prop_batt_current(struct pm8921_chg_chip *chip) |
| 1422 | { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1423 | int result_ua, rc; |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1424 | |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1425 | rc = pm8921_bms_get_battery_current(&result_ua); |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1426 | if (rc == -ENXIO) { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1427 | rc = pm8xxx_ccadc_get_battery_current(&result_ua); |
Abhijeet Dharmapurikar | 4ffea2c | 2011-11-11 18:25:02 -0800 | [diff] [blame] | 1428 | } |
| 1429 | |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1430 | if (rc) { |
| 1431 | pr_err("unable to get batt current rc = %d\n", rc); |
| 1432 | return rc; |
| 1433 | } else { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1434 | return result_ua; |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1435 | } |
| 1436 | } |
| 1437 | |
Abhijeet Dharmapurikar | 325bdc9 | 2011-09-07 20:45:49 -0700 | [diff] [blame] | 1438 | static int get_prop_batt_fcc(struct pm8921_chg_chip *chip) |
| 1439 | { |
| 1440 | int rc; |
| 1441 | |
| 1442 | rc = pm8921_bms_get_fcc(); |
| 1443 | if (rc < 0) |
| 1444 | pr_err("unable to get batt fcc rc = %d\n", rc); |
| 1445 | return rc; |
| 1446 | } |
| 1447 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1448 | static int get_prop_batt_health(struct pm8921_chg_chip *chip) |
| 1449 | { |
| 1450 | int temp; |
| 1451 | |
| 1452 | temp = pm_chg_get_rt_status(chip, BATTTEMP_HOT_IRQ); |
| 1453 | if (temp) |
| 1454 | return POWER_SUPPLY_HEALTH_OVERHEAT; |
| 1455 | |
| 1456 | temp = pm_chg_get_rt_status(chip, BATTTEMP_COLD_IRQ); |
| 1457 | if (temp) |
| 1458 | return POWER_SUPPLY_HEALTH_COLD; |
| 1459 | |
| 1460 | return POWER_SUPPLY_HEALTH_GOOD; |
| 1461 | } |
| 1462 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1463 | static int get_prop_charge_type(struct pm8921_chg_chip *chip) |
| 1464 | { |
| 1465 | int temp; |
| 1466 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1467 | if (!get_prop_batt_present(chip)) |
| 1468 | return POWER_SUPPLY_CHARGE_TYPE_NONE; |
| 1469 | |
| 1470 | if (is_ext_trickle_charging(chip)) |
| 1471 | return POWER_SUPPLY_CHARGE_TYPE_TRICKLE; |
| 1472 | |
| 1473 | if (is_ext_charging(chip)) |
| 1474 | return POWER_SUPPLY_CHARGE_TYPE_FAST; |
| 1475 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1476 | temp = pm_chg_get_rt_status(chip, TRKLCHG_IRQ); |
| 1477 | if (temp) |
| 1478 | return POWER_SUPPLY_CHARGE_TYPE_TRICKLE; |
| 1479 | |
| 1480 | temp = pm_chg_get_rt_status(chip, FASTCHG_IRQ); |
| 1481 | if (temp) |
| 1482 | return POWER_SUPPLY_CHARGE_TYPE_FAST; |
| 1483 | |
| 1484 | return POWER_SUPPLY_CHARGE_TYPE_NONE; |
| 1485 | } |
| 1486 | |
| 1487 | static int get_prop_batt_status(struct pm8921_chg_chip *chip) |
| 1488 | { |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 1489 | int batt_state = POWER_SUPPLY_STATUS_DISCHARGING; |
| 1490 | int fsm_state = pm_chg_get_fsm_state(chip); |
| 1491 | int i; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1492 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1493 | if (chip->ext_psy) { |
David Keitel | d4e59ef | 2011-11-09 17:38:31 -0800 | [diff] [blame] | 1494 | if (chip->ext_charge_done) |
| 1495 | return POWER_SUPPLY_STATUS_FULL; |
| 1496 | if (chip->ext_charging) |
| 1497 | return POWER_SUPPLY_STATUS_CHARGING; |
| 1498 | } |
| 1499 | |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 1500 | for (i = 0; i < ARRAY_SIZE(map); i++) |
| 1501 | if (map[i].fsm_state == fsm_state) |
| 1502 | batt_state = map[i].batt_state; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1503 | |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 1504 | if (fsm_state == FSM_STATE_ON_CHG_HIGHI_1) { |
| 1505 | if (!pm_chg_get_rt_status(chip, BATT_INSERTED_IRQ) |
| 1506 | || !pm_chg_get_rt_status(chip, BAT_TEMP_OK_IRQ) |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 1507 | || pm_chg_get_rt_status(chip, CHGHOT_IRQ) |
| 1508 | || pm_chg_get_rt_status(chip, VBATDET_LOW_IRQ)) |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1509 | |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 1510 | batt_state = POWER_SUPPLY_STATUS_NOT_CHARGING; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1511 | } |
Abhijeet Dharmapurikar | 236aa5a | 2011-11-03 12:17:19 -0700 | [diff] [blame] | 1512 | return batt_state; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1513 | } |
| 1514 | |
Abhijeet Dharmapurikar | 728bc4d | 2012-01-03 11:08:33 -0800 | [diff] [blame] | 1515 | #define MAX_TOLERABLE_BATT_TEMP_DDC 680 |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1516 | static int get_prop_batt_temp(struct pm8921_chg_chip *chip) |
| 1517 | { |
| 1518 | int rc; |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1519 | struct pm8xxx_adc_chan_result result; |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1520 | |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 1521 | rc = pm8xxx_adc_read(chip->batt_temp_channel, &result); |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1522 | if (rc) { |
| 1523 | pr_err("error reading adc channel = %d, rc = %d\n", |
| 1524 | chip->vbat_channel, rc); |
| 1525 | return rc; |
| 1526 | } |
| 1527 | pr_debug("batt_temp phy = %lld meas = 0x%llx\n", result.physical, |
| 1528 | result.measurement); |
Abhijeet Dharmapurikar | 728bc4d | 2012-01-03 11:08:33 -0800 | [diff] [blame] | 1529 | if (result.physical > MAX_TOLERABLE_BATT_TEMP_DDC) |
| 1530 | pr_err("BATT_TEMP= %d > 68degC, device will be shutdown\n", |
| 1531 | (int) result.physical); |
| 1532 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1533 | return (int)result.physical; |
| 1534 | } |
| 1535 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1536 | static int pm_batt_power_get_property(struct power_supply *psy, |
| 1537 | enum power_supply_property psp, |
| 1538 | union power_supply_propval *val) |
| 1539 | { |
| 1540 | struct pm8921_chg_chip *chip = container_of(psy, struct pm8921_chg_chip, |
| 1541 | batt_psy); |
| 1542 | |
| 1543 | switch (psp) { |
| 1544 | case POWER_SUPPLY_PROP_STATUS: |
| 1545 | val->intval = get_prop_batt_status(chip); |
| 1546 | break; |
| 1547 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
| 1548 | val->intval = get_prop_charge_type(chip); |
| 1549 | break; |
| 1550 | case POWER_SUPPLY_PROP_HEALTH: |
| 1551 | val->intval = get_prop_batt_health(chip); |
| 1552 | break; |
| 1553 | case POWER_SUPPLY_PROP_PRESENT: |
| 1554 | val->intval = get_prop_batt_present(chip); |
| 1555 | break; |
| 1556 | case POWER_SUPPLY_PROP_TECHNOLOGY: |
| 1557 | val->intval = POWER_SUPPLY_TECHNOLOGY_LION; |
| 1558 | break; |
| 1559 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1560 | val->intval = chip->max_voltage_mv * 1000; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1561 | break; |
| 1562 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1563 | val->intval = chip->min_voltage_mv * 1000; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1564 | break; |
| 1565 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1566 | val->intval = get_prop_battery_uvolts(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1567 | break; |
| 1568 | case POWER_SUPPLY_PROP_CAPACITY: |
| 1569 | val->intval = get_prop_batt_capacity(chip); |
| 1570 | break; |
Abhijeet Dharmapurikar | e0c3e5f | 2011-07-11 21:17:23 -0700 | [diff] [blame] | 1571 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
| 1572 | val->intval = get_prop_batt_current(chip); |
| 1573 | break; |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1574 | case POWER_SUPPLY_PROP_TEMP: |
| 1575 | val->intval = get_prop_batt_temp(chip); |
| 1576 | break; |
Abhijeet Dharmapurikar | 325bdc9 | 2011-09-07 20:45:49 -0700 | [diff] [blame] | 1577 | case POWER_SUPPLY_PROP_ENERGY_FULL: |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 1578 | val->intval = get_prop_batt_fcc(chip) * 1000; |
Abhijeet Dharmapurikar | 325bdc9 | 2011-09-07 20:45:49 -0700 | [diff] [blame] | 1579 | break; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1580 | default: |
| 1581 | return -EINVAL; |
| 1582 | } |
| 1583 | |
| 1584 | return 0; |
| 1585 | } |
| 1586 | |
| 1587 | static void (*notify_vbus_state_func_ptr)(int); |
| 1588 | static int usb_chg_current; |
| 1589 | static DEFINE_SPINLOCK(vbus_lock); |
| 1590 | |
| 1591 | int pm8921_charger_register_vbus_sn(void (*callback)(int)) |
| 1592 | { |
| 1593 | pr_debug("%p\n", callback); |
| 1594 | notify_vbus_state_func_ptr = callback; |
| 1595 | return 0; |
| 1596 | } |
| 1597 | EXPORT_SYMBOL_GPL(pm8921_charger_register_vbus_sn); |
| 1598 | |
| 1599 | /* this is passed to the hsusb via platform_data msm_otg_pdata */ |
| 1600 | void pm8921_charger_unregister_vbus_sn(void (*callback)(int)) |
| 1601 | { |
| 1602 | pr_debug("%p\n", callback); |
| 1603 | notify_vbus_state_func_ptr = NULL; |
| 1604 | } |
| 1605 | EXPORT_SYMBOL_GPL(pm8921_charger_unregister_vbus_sn); |
| 1606 | |
| 1607 | static void notify_usb_of_the_plugin_event(int plugin) |
| 1608 | { |
| 1609 | plugin = !!plugin; |
| 1610 | if (notify_vbus_state_func_ptr) { |
| 1611 | pr_debug("notifying plugin\n"); |
| 1612 | (*notify_vbus_state_func_ptr) (plugin); |
| 1613 | } else { |
| 1614 | pr_debug("unable to notify plugin\n"); |
| 1615 | } |
| 1616 | } |
| 1617 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1618 | /* assumes vbus_lock is held */ |
| 1619 | static void __pm8921_charger_vbus_draw(unsigned int mA) |
| 1620 | { |
| 1621 | int i, rc; |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 1622 | if (!the_chip) { |
| 1623 | pr_err("called before init\n"); |
| 1624 | return; |
| 1625 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1626 | |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 1627 | if (mA >= 0 && mA <= 2) { |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1628 | usb_chg_current = 0; |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1629 | rc = pm_chg_iusbmax_set(the_chip, 0); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1630 | if (rc) { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1631 | pr_err("unable to set iusb to %d rc = %d\n", 0, rc); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1632 | } |
| 1633 | rc = pm_chg_usb_suspend_enable(the_chip, 1); |
| 1634 | if (rc) |
| 1635 | pr_err("fail to set suspend bit rc=%d\n", rc); |
| 1636 | } else { |
| 1637 | rc = pm_chg_usb_suspend_enable(the_chip, 0); |
| 1638 | if (rc) |
| 1639 | pr_err("fail to reset suspend bit rc=%d\n", rc); |
| 1640 | for (i = ARRAY_SIZE(usb_ma_table) - 1; i >= 0; i--) { |
| 1641 | if (usb_ma_table[i].usb_ma <= mA) |
| 1642 | break; |
| 1643 | } |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 1644 | |
| 1645 | /* Check if IUSB_FINE_RES is available */ |
| 1646 | if ((usb_ma_table[i].value & PM8917_IUSB_FINE_RES) |
| 1647 | && !the_chip->iusb_fine_res) |
| 1648 | i--; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1649 | if (i < 0) |
| 1650 | i = 0; |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1651 | rc = pm_chg_iusbmax_set(the_chip, i); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1652 | if (rc) { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1653 | pr_err("unable to set iusb to %d rc = %d\n", i, rc); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1654 | } |
| 1655 | } |
| 1656 | } |
| 1657 | |
| 1658 | /* USB calls these to tell us how much max usb current the system can draw */ |
| 1659 | void pm8921_charger_vbus_draw(unsigned int mA) |
| 1660 | { |
| 1661 | unsigned long flags; |
| 1662 | |
| 1663 | pr_debug("Enter charge=%d\n", mA); |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1664 | |
David Keitel | 62c6a4b | 2012-05-17 12:54:59 -0700 | [diff] [blame] | 1665 | if (!the_chip) { |
| 1666 | pr_err("chip not yet initalized\n"); |
| 1667 | return; |
| 1668 | } |
| 1669 | |
| 1670 | /* |
| 1671 | * Reject VBUS requests if USB connection is the only available |
| 1672 | * power source. This makes sure that if booting without |
| 1673 | * battery the iusb_max value is not decreased avoiding potential |
| 1674 | * brown_outs. |
| 1675 | * |
| 1676 | * This would also apply when the battery has been |
| 1677 | * removed from the running system. |
| 1678 | */ |
| 1679 | if (!get_prop_batt_present(the_chip) |
| 1680 | && !is_dc_chg_plugged_in(the_chip)) { |
David Keitel | a3cf943 | 2012-08-24 15:11:23 -0700 | [diff] [blame] | 1681 | if (!the_chip->has_dc_supply) { |
David Keitel | acb258c | 2012-07-13 17:12:04 -0700 | [diff] [blame] | 1682 | pr_err("rejected: no other power source connected\n"); |
| 1683 | return; |
| 1684 | } |
David Keitel | 62c6a4b | 2012-05-17 12:54:59 -0700 | [diff] [blame] | 1685 | } |
| 1686 | |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1687 | if (usb_max_current && mA > usb_max_current) { |
| 1688 | pr_warn("restricting usb current to %d instead of %d\n", |
| 1689 | usb_max_current, mA); |
| 1690 | mA = usb_max_current; |
| 1691 | } |
| 1692 | if (usb_target_ma == 0 && mA > USB_WALL_THRESHOLD_MA) |
| 1693 | usb_target_ma = mA; |
| 1694 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1695 | spin_lock_irqsave(&vbus_lock, flags); |
| 1696 | if (the_chip) { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1697 | if (mA > USB_WALL_THRESHOLD_MA) |
| 1698 | __pm8921_charger_vbus_draw(USB_WALL_THRESHOLD_MA); |
| 1699 | else |
| 1700 | __pm8921_charger_vbus_draw(mA); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1701 | } else { |
| 1702 | /* |
| 1703 | * called before pmic initialized, |
| 1704 | * save this value and use it at probe |
| 1705 | */ |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1706 | if (mA > USB_WALL_THRESHOLD_MA) |
| 1707 | usb_chg_current = USB_WALL_THRESHOLD_MA; |
| 1708 | else |
| 1709 | usb_chg_current = mA; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1710 | } |
| 1711 | spin_unlock_irqrestore(&vbus_lock, flags); |
| 1712 | } |
| 1713 | EXPORT_SYMBOL_GPL(pm8921_charger_vbus_draw); |
| 1714 | |
Abhijeet Dharmapurikar | 1f52c41 | 2011-08-12 17:11:45 -0700 | [diff] [blame] | 1715 | int pm8921_charger_enable(bool enable) |
| 1716 | { |
| 1717 | int rc; |
| 1718 | |
| 1719 | if (!the_chip) { |
| 1720 | pr_err("called before init\n"); |
| 1721 | return -EINVAL; |
| 1722 | } |
| 1723 | enable = !!enable; |
| 1724 | rc = pm_chg_auto_enable(the_chip, enable); |
| 1725 | if (rc) |
| 1726 | pr_err("Failed rc=%d\n", rc); |
| 1727 | return rc; |
| 1728 | } |
| 1729 | EXPORT_SYMBOL(pm8921_charger_enable); |
| 1730 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1731 | int pm8921_is_usb_chg_plugged_in(void) |
| 1732 | { |
| 1733 | if (!the_chip) { |
| 1734 | pr_err("called before init\n"); |
| 1735 | return -EINVAL; |
| 1736 | } |
| 1737 | return is_usb_chg_plugged_in(the_chip); |
| 1738 | } |
| 1739 | EXPORT_SYMBOL(pm8921_is_usb_chg_plugged_in); |
| 1740 | |
| 1741 | int pm8921_is_dc_chg_plugged_in(void) |
| 1742 | { |
| 1743 | if (!the_chip) { |
| 1744 | pr_err("called before init\n"); |
| 1745 | return -EINVAL; |
| 1746 | } |
| 1747 | return is_dc_chg_plugged_in(the_chip); |
| 1748 | } |
| 1749 | EXPORT_SYMBOL(pm8921_is_dc_chg_plugged_in); |
| 1750 | |
| 1751 | int pm8921_is_battery_present(void) |
| 1752 | { |
| 1753 | if (!the_chip) { |
| 1754 | pr_err("called before init\n"); |
| 1755 | return -EINVAL; |
| 1756 | } |
| 1757 | return get_prop_batt_present(the_chip); |
| 1758 | } |
| 1759 | EXPORT_SYMBOL(pm8921_is_battery_present); |
| 1760 | |
Abhijeet Dharmapurikar | b268013 | 2012-05-15 16:32:51 -0700 | [diff] [blame] | 1761 | int pm8921_is_batfet_closed(void) |
| 1762 | { |
| 1763 | if (!the_chip) { |
| 1764 | pr_err("called before init\n"); |
| 1765 | return -EINVAL; |
| 1766 | } |
| 1767 | return is_batfet_closed(the_chip); |
| 1768 | } |
| 1769 | EXPORT_SYMBOL(pm8921_is_batfet_closed); |
David Keitel | 012deef | 2011-12-02 11:49:33 -0800 | [diff] [blame] | 1770 | /* |
| 1771 | * Disabling the charge current limit causes current |
| 1772 | * current limits to have no monitoring. An adequate charger |
| 1773 | * capable of supplying high current while sustaining VIN_MIN |
| 1774 | * is required if the limiting is disabled. |
| 1775 | */ |
| 1776 | int pm8921_disable_input_current_limit(bool disable) |
| 1777 | { |
| 1778 | if (!the_chip) { |
| 1779 | pr_err("called before init\n"); |
| 1780 | return -EINVAL; |
| 1781 | } |
| 1782 | if (disable) { |
| 1783 | pr_warn("Disabling input current limit!\n"); |
| 1784 | |
| 1785 | return pm8xxx_writeb(the_chip->dev->parent, |
| 1786 | CHG_BUCK_CTRL_TEST3, 0xF2); |
| 1787 | } |
| 1788 | return 0; |
| 1789 | } |
| 1790 | EXPORT_SYMBOL(pm8921_disable_input_current_limit); |
| 1791 | |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 1792 | int pm8917_set_under_voltage_detection_threshold(int mv) |
| 1793 | { |
| 1794 | if (!the_chip) { |
| 1795 | pr_err("called before init\n"); |
| 1796 | return -EINVAL; |
| 1797 | } |
| 1798 | return pm_chg_uvd_threshold_set(the_chip, mv); |
| 1799 | } |
| 1800 | EXPORT_SYMBOL(pm8917_set_under_voltage_detection_threshold); |
| 1801 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1802 | int pm8921_set_max_battery_charge_current(int ma) |
| 1803 | { |
| 1804 | if (!the_chip) { |
| 1805 | pr_err("called before init\n"); |
| 1806 | return -EINVAL; |
| 1807 | } |
| 1808 | return pm_chg_ibatmax_set(the_chip, ma); |
| 1809 | } |
| 1810 | EXPORT_SYMBOL(pm8921_set_max_battery_charge_current); |
| 1811 | |
| 1812 | int pm8921_disable_source_current(bool disable) |
| 1813 | { |
| 1814 | if (!the_chip) { |
| 1815 | pr_err("called before init\n"); |
| 1816 | return -EINVAL; |
| 1817 | } |
| 1818 | if (disable) |
| 1819 | pr_warn("current drawn from chg=0, battery provides current\n"); |
| 1820 | return pm_chg_charge_dis(the_chip, disable); |
| 1821 | } |
| 1822 | EXPORT_SYMBOL(pm8921_disable_source_current); |
| 1823 | |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 1824 | int pm8921_regulate_input_voltage(int voltage) |
| 1825 | { |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 1826 | int rc; |
| 1827 | |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 1828 | if (!the_chip) { |
| 1829 | pr_err("called before init\n"); |
| 1830 | return -EINVAL; |
| 1831 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 1832 | rc = pm_chg_vinmin_set(the_chip, voltage); |
| 1833 | |
| 1834 | if (rc == 0) |
| 1835 | the_chip->vin_min = voltage; |
| 1836 | |
| 1837 | return rc; |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 1838 | } |
| 1839 | |
Abhijeet Dharmapurikar | 2866930 | 2011-12-21 08:31:28 -0800 | [diff] [blame] | 1840 | #define USB_OV_THRESHOLD_MASK 0x60 |
| 1841 | #define USB_OV_THRESHOLD_SHIFT 5 |
| 1842 | int pm8921_usb_ovp_set_threshold(enum pm8921_usb_ov_threshold ov) |
| 1843 | { |
| 1844 | u8 temp; |
| 1845 | |
| 1846 | if (!the_chip) { |
| 1847 | pr_err("called before init\n"); |
| 1848 | return -EINVAL; |
| 1849 | } |
| 1850 | |
| 1851 | if (ov > PM_USB_OV_7V) { |
| 1852 | pr_err("limiting to over voltage threshold to 7volts\n"); |
| 1853 | ov = PM_USB_OV_7V; |
| 1854 | } |
| 1855 | |
| 1856 | temp = USB_OV_THRESHOLD_MASK & (ov << USB_OV_THRESHOLD_SHIFT); |
| 1857 | |
| 1858 | return pm_chg_masked_write(the_chip, USB_OVP_CONTROL, |
| 1859 | USB_OV_THRESHOLD_MASK, temp); |
| 1860 | } |
| 1861 | EXPORT_SYMBOL(pm8921_usb_ovp_set_threshold); |
| 1862 | |
| 1863 | #define USB_DEBOUNCE_TIME_MASK 0x06 |
| 1864 | #define USB_DEBOUNCE_TIME_SHIFT 1 |
| 1865 | int pm8921_usb_ovp_set_hystersis(enum pm8921_usb_debounce_time ms) |
| 1866 | { |
| 1867 | u8 temp; |
| 1868 | |
| 1869 | if (!the_chip) { |
| 1870 | pr_err("called before init\n"); |
| 1871 | return -EINVAL; |
| 1872 | } |
| 1873 | |
| 1874 | if (ms > PM_USB_DEBOUNCE_80P5MS) { |
| 1875 | pr_err("limiting debounce to 80.5ms\n"); |
| 1876 | ms = PM_USB_DEBOUNCE_80P5MS; |
| 1877 | } |
| 1878 | |
| 1879 | temp = USB_DEBOUNCE_TIME_MASK & (ms << USB_DEBOUNCE_TIME_SHIFT); |
| 1880 | |
| 1881 | return pm_chg_masked_write(the_chip, USB_OVP_CONTROL, |
| 1882 | USB_DEBOUNCE_TIME_MASK, temp); |
| 1883 | } |
| 1884 | EXPORT_SYMBOL(pm8921_usb_ovp_set_hystersis); |
| 1885 | |
| 1886 | #define USB_OVP_DISABLE_MASK 0x80 |
| 1887 | int pm8921_usb_ovp_disable(int disable) |
| 1888 | { |
| 1889 | u8 temp = 0; |
| 1890 | |
| 1891 | if (!the_chip) { |
| 1892 | pr_err("called before init\n"); |
| 1893 | return -EINVAL; |
| 1894 | } |
| 1895 | |
| 1896 | if (disable) |
| 1897 | temp = USB_OVP_DISABLE_MASK; |
| 1898 | |
| 1899 | return pm_chg_masked_write(the_chip, USB_OVP_CONTROL, |
| 1900 | USB_OVP_DISABLE_MASK, temp); |
| 1901 | } |
| 1902 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1903 | bool pm8921_is_battery_charging(int *source) |
| 1904 | { |
| 1905 | int fsm_state, is_charging, dc_present, usb_present; |
| 1906 | |
| 1907 | if (!the_chip) { |
| 1908 | pr_err("called before init\n"); |
| 1909 | return -EINVAL; |
| 1910 | } |
| 1911 | fsm_state = pm_chg_get_fsm_state(the_chip); |
| 1912 | is_charging = is_battery_charging(fsm_state); |
| 1913 | if (is_charging == 0) { |
| 1914 | *source = PM8921_CHG_SRC_NONE; |
| 1915 | return is_charging; |
| 1916 | } |
| 1917 | |
| 1918 | if (source == NULL) |
| 1919 | return is_charging; |
| 1920 | |
| 1921 | /* the battery is charging, the source is requested, find it */ |
| 1922 | dc_present = is_dc_chg_plugged_in(the_chip); |
| 1923 | usb_present = is_usb_chg_plugged_in(the_chip); |
| 1924 | |
| 1925 | if (dc_present && !usb_present) |
| 1926 | *source = PM8921_CHG_SRC_DC; |
| 1927 | |
| 1928 | if (usb_present && !dc_present) |
| 1929 | *source = PM8921_CHG_SRC_USB; |
| 1930 | |
| 1931 | if (usb_present && dc_present) |
| 1932 | /* |
| 1933 | * The system always chooses dc for charging since it has |
| 1934 | * higher priority. |
| 1935 | */ |
| 1936 | *source = PM8921_CHG_SRC_DC; |
| 1937 | |
| 1938 | return is_charging; |
| 1939 | } |
| 1940 | EXPORT_SYMBOL(pm8921_is_battery_charging); |
| 1941 | |
David Keitel | 8603402 | 2012-04-18 12:33:58 -0700 | [diff] [blame] | 1942 | int pm8921_set_usb_power_supply_type(enum power_supply_type type) |
| 1943 | { |
| 1944 | if (!the_chip) { |
| 1945 | pr_err("called before init\n"); |
| 1946 | return -EINVAL; |
| 1947 | } |
| 1948 | |
| 1949 | if (type < POWER_SUPPLY_TYPE_USB) |
| 1950 | return -EINVAL; |
| 1951 | |
| 1952 | the_chip->usb_psy.type = type; |
| 1953 | power_supply_changed(&the_chip->usb_psy); |
| 1954 | power_supply_changed(&the_chip->dc_psy); |
| 1955 | return 0; |
| 1956 | } |
| 1957 | EXPORT_SYMBOL_GPL(pm8921_set_usb_power_supply_type); |
| 1958 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 1959 | int pm8921_batt_temperature(void) |
| 1960 | { |
| 1961 | if (!the_chip) { |
| 1962 | pr_err("called before init\n"); |
| 1963 | return -EINVAL; |
| 1964 | } |
| 1965 | return get_prop_batt_temp(the_chip); |
| 1966 | } |
| 1967 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1968 | static void handle_usb_insertion_removal(struct pm8921_chg_chip *chip) |
| 1969 | { |
| 1970 | int usb_present; |
| 1971 | |
Abhijeet Dharmapurikar | e451f34 | 2012-02-23 16:39:42 -0800 | [diff] [blame] | 1972 | pm_chg_failed_clear(chip, 1); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1973 | usb_present = is_usb_chg_plugged_in(chip); |
| 1974 | if (chip->usb_present ^ usb_present) { |
| 1975 | notify_usb_of_the_plugin_event(usb_present); |
| 1976 | chip->usb_present = usb_present; |
| 1977 | power_supply_changed(&chip->usb_psy); |
Abhijeet Dharmapurikar | 0c4bc15 | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 1978 | power_supply_changed(&chip->batt_psy); |
Abhijeet Dharmapurikar | c9ba271 | 2012-02-23 12:42:24 -0800 | [diff] [blame] | 1979 | pm8921_bms_calibrate_hkadc(); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1980 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 1981 | if (usb_present) { |
| 1982 | schedule_delayed_work(&chip->unplug_check_work, |
| 1983 | round_jiffies_relative(msecs_to_jiffies |
| 1984 | (UNPLUG_CHECK_WAIT_PERIOD_MS))); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 1985 | pm8921_chg_enable_irq(chip, CHG_GONE_IRQ); |
| 1986 | } else { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 1987 | /* USB unplugged reset target current */ |
| 1988 | usb_target_ma = 0; |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 1989 | pm8921_chg_disable_irq(chip, CHG_GONE_IRQ); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 1990 | } |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 1991 | enable_input_voltage_regulation(chip); |
Abhijeet Dharmapurikar | f247105 | 2011-09-25 22:18:36 -0700 | [diff] [blame] | 1992 | bms_notify_check(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 1993 | } |
| 1994 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1995 | static void handle_stop_ext_chg(struct pm8921_chg_chip *chip) |
| 1996 | { |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 1997 | if (!chip->ext_psy) { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 1998 | pr_debug("external charger not registered.\n"); |
| 1999 | return; |
| 2000 | } |
| 2001 | |
| 2002 | if (!chip->ext_charging) { |
| 2003 | pr_debug("already not charging.\n"); |
| 2004 | return; |
| 2005 | } |
| 2006 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2007 | power_supply_set_charge_type(chip->ext_psy, |
| 2008 | POWER_SUPPLY_CHARGE_TYPE_NONE); |
| 2009 | pm8921_disable_source_current(false); /* release BATFET */ |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2010 | power_supply_changed(&chip->dc_psy); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2011 | chip->ext_charging = false; |
David Keitel | d4e59ef | 2011-11-09 17:38:31 -0800 | [diff] [blame] | 2012 | chip->ext_charge_done = false; |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2013 | bms_notify_check(chip); |
Amir Samuelov | 4ffc8ec | 2012-05-16 09:38:43 +0300 | [diff] [blame] | 2014 | /* Update battery charging LEDs and user space battery info */ |
| 2015 | power_supply_changed(&chip->batt_psy); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2016 | } |
| 2017 | |
| 2018 | static void handle_start_ext_chg(struct pm8921_chg_chip *chip) |
| 2019 | { |
| 2020 | int dc_present; |
| 2021 | int batt_present; |
| 2022 | int batt_temp_ok; |
| 2023 | int vbat_ov; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2024 | unsigned long delay = |
| 2025 | round_jiffies_relative(msecs_to_jiffies(EOC_CHECK_PERIOD_MS)); |
| 2026 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2027 | if (!chip->ext_psy) { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2028 | pr_debug("external charger not registered.\n"); |
| 2029 | return; |
| 2030 | } |
| 2031 | |
| 2032 | if (chip->ext_charging) { |
| 2033 | pr_debug("already charging.\n"); |
| 2034 | return; |
| 2035 | } |
| 2036 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2037 | dc_present = is_dc_chg_plugged_in(the_chip); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2038 | batt_present = pm_chg_get_rt_status(chip, BATT_INSERTED_IRQ); |
| 2039 | batt_temp_ok = pm_chg_get_rt_status(chip, BAT_TEMP_OK_IRQ); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2040 | |
| 2041 | if (!dc_present) { |
| 2042 | pr_warn("%s. dc not present.\n", __func__); |
| 2043 | return; |
| 2044 | } |
| 2045 | if (!batt_present) { |
| 2046 | pr_warn("%s. battery not present.\n", __func__); |
| 2047 | return; |
| 2048 | } |
| 2049 | if (!batt_temp_ok) { |
| 2050 | pr_warn("%s. battery temperature not ok.\n", __func__); |
| 2051 | return; |
| 2052 | } |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2053 | pm8921_disable_source_current(true); /* Force BATFET=ON */ |
| 2054 | vbat_ov = pm_chg_get_rt_status(chip, VBAT_OV_IRQ); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2055 | if (vbat_ov) { |
| 2056 | pr_warn("%s. battery over voltage.\n", __func__); |
| 2057 | return; |
| 2058 | } |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2059 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2060 | schedule_delayed_work(&chip->unplug_check_work, |
| 2061 | round_jiffies_relative(msecs_to_jiffies |
| 2062 | (UNPLUG_CHECK_WAIT_PERIOD_MS))); |
| 2063 | pm8921_chg_enable_irq(chip, CHG_GONE_IRQ); |
| 2064 | |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2065 | power_supply_set_online(chip->ext_psy, dc_present); |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2066 | power_supply_set_charge_type(chip->ext_psy, |
| 2067 | POWER_SUPPLY_CHARGE_TYPE_FAST); |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2068 | power_supply_changed(&chip->dc_psy); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2069 | chip->ext_charging = true; |
| 2070 | chip->ext_charge_done = false; |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2071 | bms_notify_check(chip); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2072 | /* Start BMS */ |
| 2073 | schedule_delayed_work(&chip->eoc_work, delay); |
| 2074 | wake_lock(&chip->eoc_wake_lock); |
Amir Samuelov | 4ffc8ec | 2012-05-16 09:38:43 +0300 | [diff] [blame] | 2075 | /* Update battery charging LEDs and user space battery info */ |
| 2076 | power_supply_changed(&chip->batt_psy); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2077 | } |
| 2078 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2079 | static void turn_off_ovp_fet(struct pm8921_chg_chip *chip, u16 ovptestreg) |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2080 | { |
| 2081 | u8 temp; |
| 2082 | int rc; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2083 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2084 | rc = pm8xxx_writeb(chip->dev->parent, ovptestreg, 0x30); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2085 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2086 | pr_err("Failed to write 0x30 to OVP_TEST rc = %d\n", rc); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2087 | return; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2088 | } |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2089 | rc = pm8xxx_readb(chip->dev->parent, ovptestreg, &temp); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2090 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2091 | pr_err("Failed to read from OVP_TEST rc = %d\n", rc); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2092 | return; |
| 2093 | } |
| 2094 | /* set ovp fet disable bit and the write bit */ |
| 2095 | temp |= 0x81; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2096 | rc = pm8xxx_writeb(chip->dev->parent, ovptestreg, temp); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2097 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2098 | pr_err("Failed to write 0x%x OVP_TEST rc=%d\n", temp, rc); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2099 | return; |
| 2100 | } |
| 2101 | } |
| 2102 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2103 | static void turn_on_ovp_fet(struct pm8921_chg_chip *chip, u16 ovptestreg) |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2104 | { |
| 2105 | u8 temp; |
| 2106 | int rc; |
| 2107 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2108 | rc = pm8xxx_writeb(chip->dev->parent, ovptestreg, 0x30); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2109 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2110 | pr_err("Failed to write 0x30 to OVP_TEST rc = %d\n", rc); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2111 | return; |
| 2112 | } |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2113 | rc = pm8xxx_readb(chip->dev->parent, ovptestreg, &temp); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2114 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2115 | pr_err("Failed to read from OVP_TEST rc = %d\n", rc); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2116 | return; |
| 2117 | } |
| 2118 | /* unset ovp fet disable bit and set the write bit */ |
| 2119 | temp &= 0xFE; |
| 2120 | temp |= 0x80; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2121 | rc = pm8xxx_writeb(chip->dev->parent, ovptestreg, temp); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2122 | if (rc) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2123 | pr_err("Failed to write 0x%x to OVP_TEST rc = %d\n", |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2124 | temp, rc); |
| 2125 | return; |
| 2126 | } |
| 2127 | } |
| 2128 | |
| 2129 | static int param_open_ovp_counter = 10; |
| 2130 | module_param(param_open_ovp_counter, int, 0644); |
| 2131 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2132 | #define USB_ACTIVE_BIT BIT(5) |
| 2133 | #define DC_ACTIVE_BIT BIT(6) |
| 2134 | static int is_active_chg_plugged_in(struct pm8921_chg_chip *chip, |
| 2135 | u8 active_chg_mask) |
| 2136 | { |
| 2137 | if (active_chg_mask & USB_ACTIVE_BIT) |
| 2138 | return pm_chg_get_rt_status(chip, USBIN_VALID_IRQ); |
| 2139 | else if (active_chg_mask & DC_ACTIVE_BIT) |
| 2140 | return pm_chg_get_rt_status(chip, DCIN_VALID_IRQ); |
| 2141 | else |
| 2142 | return 0; |
| 2143 | } |
| 2144 | |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2145 | #define WRITE_BANK_4 0xC0 |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2146 | #define OVP_DEBOUNCE_TIME 0x06 |
David Keitel | c3e15bd | 2012-05-25 17:07:25 -0700 | [diff] [blame] | 2147 | static void unplug_ovp_fet_open(struct pm8921_chg_chip *chip) |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2148 | { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2149 | int chg_gone = 0, active_chg_plugged_in = 0; |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2150 | int count = 0; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2151 | u8 active_mask = 0; |
| 2152 | u16 ovpreg, ovptestreg; |
| 2153 | |
| 2154 | if (is_usb_chg_plugged_in(chip) && |
| 2155 | (chip->active_path & USB_ACTIVE_BIT)) { |
| 2156 | ovpreg = USB_OVP_CONTROL; |
| 2157 | ovptestreg = USB_OVP_TEST; |
| 2158 | active_mask = USB_ACTIVE_BIT; |
| 2159 | } else if (is_dc_chg_plugged_in(chip) && |
| 2160 | (chip->active_path & DC_ACTIVE_BIT)) { |
| 2161 | ovpreg = DC_OVP_CONTROL; |
| 2162 | ovptestreg = DC_OVP_TEST; |
| 2163 | active_mask = DC_ACTIVE_BIT; |
| 2164 | } else { |
| 2165 | return; |
| 2166 | } |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2167 | |
| 2168 | while (count++ < param_open_ovp_counter) { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2169 | pm_chg_masked_write(chip, ovpreg, OVP_DEBOUNCE_TIME, 0x0); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2170 | usleep(10); |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2171 | active_chg_plugged_in |
| 2172 | = is_active_chg_plugged_in(chip, active_mask); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2173 | chg_gone = pm_chg_get_rt_status(chip, CHG_GONE_IRQ); |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2174 | pr_debug("OVP FET count = %d chg_gone=%d, active_valid = %d\n", |
| 2175 | count, chg_gone, active_chg_plugged_in); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2176 | |
| 2177 | /* note usb_chg_plugged_in=0 => chg_gone=1 */ |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2178 | if (chg_gone == 1 && active_chg_plugged_in == 1) { |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2179 | pr_debug("since chg_gone = 1 dis ovp_fet for 20msec\n"); |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2180 | turn_off_ovp_fet(chip, ovptestreg); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2181 | |
| 2182 | msleep(20); |
| 2183 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2184 | turn_on_ovp_fet(chip, ovptestreg); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2185 | } else { |
David Keitel | 712782e | 2012-03-29 14:11:47 -0700 | [diff] [blame] | 2186 | break; |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2187 | } |
| 2188 | } |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2189 | pm_chg_masked_write(chip, ovpreg, OVP_DEBOUNCE_TIME, 0x2); |
| 2190 | pr_debug("Exit count=%d chg_gone=%d, active_valid=%d\n", |
| 2191 | count, chg_gone, active_chg_plugged_in); |
David Keitel | 712782e | 2012-03-29 14:11:47 -0700 | [diff] [blame] | 2192 | return; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2193 | } |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2194 | |
| 2195 | static int find_usb_ma_value(int value) |
| 2196 | { |
| 2197 | int i; |
| 2198 | |
| 2199 | for (i = ARRAY_SIZE(usb_ma_table) - 1; i >= 0; i--) { |
| 2200 | if (value >= usb_ma_table[i].usb_ma) |
| 2201 | break; |
| 2202 | } |
| 2203 | |
| 2204 | return i; |
| 2205 | } |
| 2206 | |
| 2207 | static void decrease_usb_ma_value(int *value) |
| 2208 | { |
| 2209 | int i; |
| 2210 | |
| 2211 | if (value) { |
| 2212 | i = find_usb_ma_value(*value); |
| 2213 | if (i > 0) |
| 2214 | i--; |
David Keitel | c7bba2f | 2012-06-15 17:05:52 -0700 | [diff] [blame] | 2215 | while (!the_chip->iusb_fine_res && i > 0 |
| 2216 | && (usb_ma_table[i].value & PM8917_IUSB_FINE_RES)) |
| 2217 | i--; |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2218 | *value = usb_ma_table[i].usb_ma; |
| 2219 | } |
| 2220 | } |
| 2221 | |
| 2222 | static void increase_usb_ma_value(int *value) |
| 2223 | { |
| 2224 | int i; |
| 2225 | |
| 2226 | if (value) { |
| 2227 | i = find_usb_ma_value(*value); |
| 2228 | |
| 2229 | if (i < (ARRAY_SIZE(usb_ma_table) - 1)) |
| 2230 | i++; |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 2231 | /* Get next correct entry if IUSB_FINE_RES is not available */ |
| 2232 | while (!the_chip->iusb_fine_res |
| 2233 | && (usb_ma_table[i].value & PM8917_IUSB_FINE_RES) |
| 2234 | && i < (ARRAY_SIZE(usb_ma_table) - 1)) |
| 2235 | i++; |
| 2236 | |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2237 | *value = usb_ma_table[i].usb_ma; |
| 2238 | } |
| 2239 | } |
| 2240 | |
| 2241 | static void vin_collapse_check_worker(struct work_struct *work) |
| 2242 | { |
| 2243 | struct delayed_work *dwork = to_delayed_work(work); |
| 2244 | struct pm8921_chg_chip *chip = container_of(dwork, |
| 2245 | struct pm8921_chg_chip, vin_collapse_check_work); |
| 2246 | |
| 2247 | /* AICL only for wall-chargers */ |
| 2248 | if (is_usb_chg_plugged_in(chip) && |
| 2249 | usb_target_ma > USB_WALL_THRESHOLD_MA) { |
| 2250 | /* decrease usb_target_ma */ |
| 2251 | decrease_usb_ma_value(&usb_target_ma); |
| 2252 | /* reset here, increase in unplug_check_worker */ |
| 2253 | __pm8921_charger_vbus_draw(USB_WALL_THRESHOLD_MA); |
| 2254 | pr_debug("usb_now=%d, usb_target = %d\n", |
| 2255 | USB_WALL_THRESHOLD_MA, usb_target_ma); |
| 2256 | } else { |
| 2257 | handle_usb_insertion_removal(chip); |
| 2258 | } |
| 2259 | } |
| 2260 | |
| 2261 | #define VIN_MIN_COLLAPSE_CHECK_MS 50 |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2262 | static irqreturn_t usbin_valid_irq_handler(int irq, void *data) |
| 2263 | { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2264 | if (usb_target_ma) |
| 2265 | schedule_delayed_work(&the_chip->vin_collapse_check_work, |
| 2266 | round_jiffies_relative(msecs_to_jiffies |
| 2267 | (VIN_MIN_COLLAPSE_CHECK_MS))); |
| 2268 | else |
| 2269 | handle_usb_insertion_removal(data); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2270 | return IRQ_HANDLED; |
| 2271 | } |
| 2272 | |
| 2273 | static irqreturn_t usbin_ov_irq_handler(int irq, void *data) |
| 2274 | { |
Abhijeet Dharmapurikar | 485a053 | 2011-08-12 17:18:10 -0700 | [diff] [blame] | 2275 | pr_err("USB OverVoltage\n"); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2276 | return IRQ_HANDLED; |
| 2277 | } |
| 2278 | |
| 2279 | static irqreturn_t batt_inserted_irq_handler(int irq, void *data) |
| 2280 | { |
| 2281 | struct pm8921_chg_chip *chip = data; |
| 2282 | int status; |
| 2283 | |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 2284 | status = pm_chg_get_rt_status(chip, BATT_INSERTED_IRQ); |
| 2285 | schedule_work(&chip->battery_id_valid_work); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2286 | handle_start_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2287 | pr_debug("battery present=%d", status); |
| 2288 | power_supply_changed(&chip->batt_psy); |
| 2289 | return IRQ_HANDLED; |
| 2290 | } |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2291 | |
| 2292 | /* |
| 2293 | * this interrupt used to restart charging a battery. |
| 2294 | * |
| 2295 | * Note: When DC-inserted the VBAT can't go low. |
| 2296 | * VPH_PWR is provided by the ext-charger. |
| 2297 | * After End-Of-Charging from DC, charging can be resumed only |
| 2298 | * if DC is removed and then inserted after the battery was in use. |
| 2299 | * Therefore the handle_start_ext_chg() is not called. |
| 2300 | */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2301 | static irqreturn_t vbatdet_low_irq_handler(int irq, void *data) |
| 2302 | { |
| 2303 | struct pm8921_chg_chip *chip = data; |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2304 | int high_transition; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2305 | |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2306 | high_transition = pm_chg_get_rt_status(chip, VBATDET_LOW_IRQ); |
Abhijeet Dharmapurikar | 07e48bf | 2011-09-26 19:46:40 -0700 | [diff] [blame] | 2307 | |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2308 | if (high_transition) { |
| 2309 | /* enable auto charging */ |
| 2310 | pm_chg_auto_enable(chip, !charging_disabled); |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 2311 | pr_info("batt fell below resume voltage %s\n", |
| 2312 | charging_disabled ? "" : "charger enabled"); |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2313 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2314 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2315 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2316 | power_supply_changed(&chip->batt_psy); |
| 2317 | power_supply_changed(&chip->usb_psy); |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2318 | power_supply_changed(&chip->dc_psy); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2319 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2320 | return IRQ_HANDLED; |
| 2321 | } |
| 2322 | |
| 2323 | static irqreturn_t usbin_uv_irq_handler(int irq, void *data) |
| 2324 | { |
Abhijeet Dharmapurikar | 485a053 | 2011-08-12 17:18:10 -0700 | [diff] [blame] | 2325 | pr_err("USB UnderVoltage\n"); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2326 | return IRQ_HANDLED; |
| 2327 | } |
| 2328 | |
| 2329 | static irqreturn_t vbat_ov_irq_handler(int irq, void *data) |
| 2330 | { |
| 2331 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2332 | return IRQ_HANDLED; |
| 2333 | } |
| 2334 | |
| 2335 | static irqreturn_t chgwdog_irq_handler(int irq, void *data) |
| 2336 | { |
| 2337 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2338 | return IRQ_HANDLED; |
| 2339 | } |
| 2340 | |
| 2341 | static irqreturn_t vcp_irq_handler(int irq, void *data) |
| 2342 | { |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2343 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2344 | return IRQ_HANDLED; |
| 2345 | } |
| 2346 | |
| 2347 | static irqreturn_t atcdone_irq_handler(int irq, void *data) |
| 2348 | { |
| 2349 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2350 | return IRQ_HANDLED; |
| 2351 | } |
| 2352 | |
| 2353 | static irqreturn_t atcfail_irq_handler(int irq, void *data) |
| 2354 | { |
| 2355 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2356 | return IRQ_HANDLED; |
| 2357 | } |
| 2358 | |
| 2359 | static irqreturn_t chgdone_irq_handler(int irq, void *data) |
| 2360 | { |
| 2361 | struct pm8921_chg_chip *chip = data; |
| 2362 | |
| 2363 | pr_debug("state_changed_to=%d\n", pm_chg_get_fsm_state(data)); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2364 | |
| 2365 | handle_stop_ext_chg(chip); |
| 2366 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2367 | power_supply_changed(&chip->batt_psy); |
| 2368 | power_supply_changed(&chip->usb_psy); |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2369 | power_supply_changed(&chip->dc_psy); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2370 | |
Abhijeet Dharmapurikar | fad7235 | 2011-09-25 23:06:05 -0700 | [diff] [blame] | 2371 | bms_notify_check(chip); |
| 2372 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2373 | return IRQ_HANDLED; |
| 2374 | } |
| 2375 | |
| 2376 | static irqreturn_t chgfail_irq_handler(int irq, void *data) |
| 2377 | { |
| 2378 | struct pm8921_chg_chip *chip = data; |
David Keitel | 753ec8d | 2011-11-02 10:56:37 -0700 | [diff] [blame] | 2379 | int ret; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2380 | |
David Keitel | 753ec8d | 2011-11-02 10:56:37 -0700 | [diff] [blame] | 2381 | ret = pm_chg_failed_clear(chip, 1); |
| 2382 | if (ret) |
| 2383 | pr_err("Failed to write CHG_FAILED_CLEAR bit\n"); |
| 2384 | |
| 2385 | pr_err("batt_present = %d, batt_temp_ok = %d, state_changed_to=%d\n", |
| 2386 | get_prop_batt_present(chip), |
| 2387 | pm_chg_get_rt_status(chip, BAT_TEMP_OK_IRQ), |
| 2388 | pm_chg_get_fsm_state(data)); |
| 2389 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2390 | power_supply_changed(&chip->batt_psy); |
| 2391 | power_supply_changed(&chip->usb_psy); |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2392 | power_supply_changed(&chip->dc_psy); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2393 | return IRQ_HANDLED; |
| 2394 | } |
| 2395 | |
| 2396 | static irqreturn_t chgstate_irq_handler(int irq, void *data) |
| 2397 | { |
| 2398 | struct pm8921_chg_chip *chip = data; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2399 | |
| 2400 | pr_debug("state_changed_to=%d\n", pm_chg_get_fsm_state(data)); |
| 2401 | power_supply_changed(&chip->batt_psy); |
| 2402 | power_supply_changed(&chip->usb_psy); |
David Keitel | 63f7166 | 2012-02-08 20:30:00 -0800 | [diff] [blame] | 2403 | power_supply_changed(&chip->dc_psy); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2404 | |
Abhijeet Dharmapurikar | f247105 | 2011-09-25 22:18:36 -0700 | [diff] [blame] | 2405 | bms_notify_check(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2406 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2407 | return IRQ_HANDLED; |
| 2408 | } |
| 2409 | |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2410 | static int param_vin_disable_counter = 5; |
| 2411 | module_param(param_vin_disable_counter, int, 0644); |
| 2412 | |
| 2413 | static void attempt_reverse_boost_fix(struct pm8921_chg_chip *chip, |
| 2414 | int count, int usb_ma) |
| 2415 | { |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2416 | if (usb_ma) |
| 2417 | __pm8921_charger_vbus_draw(500); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2418 | pr_debug("count = %d iusb=500mA\n", count); |
| 2419 | disable_input_voltage_regulation(chip); |
| 2420 | pr_debug("count = %d disable_input_regulation\n", count); |
| 2421 | |
| 2422 | msleep(20); |
| 2423 | |
| 2424 | pr_debug("count = %d end sleep 20ms chg_gone=%d, usb_valid = %d\n", |
| 2425 | count, |
| 2426 | pm_chg_get_rt_status(chip, CHG_GONE_IRQ), |
| 2427 | is_usb_chg_plugged_in(chip)); |
| 2428 | pr_debug("count = %d restoring input regulation and usb_ma = %d\n", |
| 2429 | count, usb_ma); |
| 2430 | enable_input_voltage_regulation(chip); |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2431 | if (usb_ma) |
| 2432 | __pm8921_charger_vbus_draw(usb_ma); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2433 | } |
| 2434 | |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2435 | #define VIN_ACTIVE_BIT BIT(0) |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2436 | #define UNPLUG_WRKARND_RESTORE_WAIT_PERIOD_US 200 |
| 2437 | #define VIN_MIN_INCREASE_MV 100 |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2438 | static void unplug_check_worker(struct work_struct *work) |
| 2439 | { |
| 2440 | struct delayed_work *dwork = to_delayed_work(work); |
| 2441 | struct pm8921_chg_chip *chip = container_of(dwork, |
| 2442 | struct pm8921_chg_chip, unplug_check_work); |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2443 | u8 reg_loop, active_path; |
| 2444 | int rc, ibat, active_chg_plugged_in, usb_ma; |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2445 | int chg_gone = 0; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2446 | |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2447 | reg_loop = 0; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2448 | |
| 2449 | rc = pm8xxx_readb(chip->dev->parent, PBL_ACCESS1, &active_path); |
| 2450 | if (rc) { |
| 2451 | pr_err("Failed to read PBL_ACCESS1 rc=%d\n", rc); |
| 2452 | return; |
| 2453 | } |
| 2454 | chip->active_path = active_path; |
| 2455 | |
| 2456 | active_chg_plugged_in = is_active_chg_plugged_in(chip, active_path); |
| 2457 | pr_debug("active_path = 0x%x, active_chg_plugged_in = %d\n", |
| 2458 | active_path, active_chg_plugged_in); |
| 2459 | if (active_path & USB_ACTIVE_BIT) { |
| 2460 | pr_debug("USB charger active\n"); |
| 2461 | |
| 2462 | pm_chg_iusbmax_get(chip, &usb_ma); |
| 2463 | if (usb_ma == 500 && !usb_target_ma) { |
| 2464 | pr_debug("Stopping Unplug Check Worker USB == 500mA\n"); |
| 2465 | disable_input_voltage_regulation(chip); |
| 2466 | return; |
| 2467 | } |
| 2468 | |
| 2469 | if (usb_ma <= 100) { |
| 2470 | pr_debug( |
| 2471 | "Unenumerated or suspended usb_ma = %d skip\n", |
| 2472 | usb_ma); |
| 2473 | goto check_again_later; |
| 2474 | } |
| 2475 | } else if (active_path & DC_ACTIVE_BIT) { |
| 2476 | pr_debug("DC charger active\n"); |
David Keitel | 5bed4f1 | 2012-05-25 18:04:14 -0700 | [diff] [blame] | 2477 | /* Some board designs are not prone to reverse boost on DC |
| 2478 | * charging path */ |
| 2479 | if (!chip->dc_unplug_check) |
| 2480 | return; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2481 | } else { |
| 2482 | /* No charger active */ |
| 2483 | if (!(is_usb_chg_plugged_in(chip) |
| 2484 | && !(is_dc_chg_plugged_in(chip)))) { |
| 2485 | pr_debug( |
| 2486 | "Stop: chg removed reg_loop = %d, fsm = %d ibat = %d\n", |
| 2487 | pm_chg_get_regulation_loop(chip), |
| 2488 | pm_chg_get_fsm_state(chip), |
| 2489 | get_prop_batt_current(chip) |
| 2490 | ); |
Abhijeet Dharmapurikar | 76d2548 | 2012-08-28 19:33:49 -0700 | [diff] [blame] | 2491 | return; |
| 2492 | } else { |
| 2493 | goto check_again_later; |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2494 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2495 | } |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2496 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2497 | if (active_path & USB_ACTIVE_BIT) { |
| 2498 | reg_loop = pm_chg_get_regulation_loop(chip); |
| 2499 | pr_debug("reg_loop=0x%x usb_ma = %d\n", reg_loop, usb_ma); |
| 2500 | if ((reg_loop & VIN_ACTIVE_BIT) && |
| 2501 | (usb_ma > USB_WALL_THRESHOLD_MA)) { |
| 2502 | decrease_usb_ma_value(&usb_ma); |
| 2503 | usb_target_ma = usb_ma; |
| 2504 | /* end AICL here */ |
| 2505 | __pm8921_charger_vbus_draw(usb_ma); |
| 2506 | pr_debug("usb_now=%d, usb_target = %d\n", |
| 2507 | usb_ma, usb_target_ma); |
| 2508 | } |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2509 | } |
| 2510 | |
| 2511 | reg_loop = pm_chg_get_regulation_loop(chip); |
| 2512 | pr_debug("reg_loop=0x%x usb_ma = %d\n", reg_loop, usb_ma); |
| 2513 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2514 | ibat = get_prop_batt_current(chip); |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2515 | if (reg_loop & VIN_ACTIVE_BIT) { |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2516 | pr_debug("ibat = %d fsm = %d reg_loop = 0x%x\n", |
| 2517 | ibat, pm_chg_get_fsm_state(chip), reg_loop); |
| 2518 | if (ibat > 0) { |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2519 | int count = 0; |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2520 | |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2521 | while (count++ < param_vin_disable_counter |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2522 | && active_chg_plugged_in == 1) { |
| 2523 | if (active_path & USB_ACTIVE_BIT) |
| 2524 | attempt_reverse_boost_fix(chip, |
| 2525 | count, usb_ma); |
| 2526 | else |
| 2527 | attempt_reverse_boost_fix(chip, |
| 2528 | count, 0); |
| 2529 | /* after reverse boost fix check if the active |
| 2530 | * charger was detected as removed */ |
| 2531 | active_chg_plugged_in |
| 2532 | = is_active_chg_plugged_in(chip, |
| 2533 | active_path); |
| 2534 | pr_debug("active_chg_plugged_in = %d\n", |
| 2535 | active_chg_plugged_in); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2536 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2537 | } |
| 2538 | } |
| 2539 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2540 | active_chg_plugged_in = is_active_chg_plugged_in(chip, active_path); |
| 2541 | pr_debug("active_path = 0x%x, active_chg = %d\n", |
| 2542 | active_path, active_chg_plugged_in); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2543 | chg_gone = pm_chg_get_rt_status(chip, CHG_GONE_IRQ); |
| 2544 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2545 | if (chg_gone == 1 && active_chg_plugged_in == 1) { |
| 2546 | pr_debug("chg_gone=%d, active_chg_plugged_in = %d\n", |
| 2547 | chg_gone, active_chg_plugged_in); |
David Keitel | c3e15bd | 2012-05-25 17:07:25 -0700 | [diff] [blame] | 2548 | unplug_ovp_fet_open(chip); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2549 | } |
| 2550 | |
David Keitel | 6ccbf13 | 2012-05-30 14:21:24 -0700 | [diff] [blame] | 2551 | if (!(reg_loop & VIN_ACTIVE_BIT) && (active_path & USB_ACTIVE_BIT)) { |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2552 | /* only increase iusb_max if vin loop not active */ |
| 2553 | if (usb_ma < usb_target_ma) { |
| 2554 | increase_usb_ma_value(&usb_ma); |
| 2555 | __pm8921_charger_vbus_draw(usb_ma); |
| 2556 | pr_debug("usb_now=%d, usb_target = %d\n", |
| 2557 | usb_ma, usb_target_ma); |
| 2558 | } else { |
| 2559 | usb_target_ma = usb_ma; |
| 2560 | } |
| 2561 | } |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2562 | check_again_later: |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 2563 | /* schedule to check again later */ |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2564 | schedule_delayed_work(&chip->unplug_check_work, |
| 2565 | round_jiffies_relative(msecs_to_jiffies |
| 2566 | (UNPLUG_CHECK_WAIT_PERIOD_MS))); |
| 2567 | } |
| 2568 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2569 | static irqreturn_t loop_change_irq_handler(int irq, void *data) |
| 2570 | { |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 2571 | struct pm8921_chg_chip *chip = data; |
| 2572 | |
| 2573 | pr_debug("fsm_state=%d reg_loop=0x%x\n", |
| 2574 | pm_chg_get_fsm_state(data), |
| 2575 | pm_chg_get_regulation_loop(data)); |
David Keitel | b57db9e | 2012-03-28 16:08:43 -0700 | [diff] [blame] | 2576 | schedule_work(&chip->unplug_check_work.work); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2577 | return IRQ_HANDLED; |
| 2578 | } |
| 2579 | |
| 2580 | static irqreturn_t fastchg_irq_handler(int irq, void *data) |
| 2581 | { |
| 2582 | struct pm8921_chg_chip *chip = data; |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2583 | int high_transition; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2584 | |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2585 | high_transition = pm_chg_get_rt_status(chip, FASTCHG_IRQ); |
| 2586 | if (high_transition && !delayed_work_pending(&chip->eoc_work)) { |
| 2587 | wake_lock(&chip->eoc_wake_lock); |
| 2588 | schedule_delayed_work(&chip->eoc_work, |
| 2589 | round_jiffies_relative(msecs_to_jiffies |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2590 | (EOC_CHECK_PERIOD_MS))); |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 2591 | } |
| 2592 | power_supply_changed(&chip->batt_psy); |
| 2593 | bms_notify_check(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2594 | return IRQ_HANDLED; |
| 2595 | } |
| 2596 | |
| 2597 | static irqreturn_t trklchg_irq_handler(int irq, void *data) |
| 2598 | { |
| 2599 | struct pm8921_chg_chip *chip = data; |
| 2600 | |
| 2601 | power_supply_changed(&chip->batt_psy); |
| 2602 | return IRQ_HANDLED; |
| 2603 | } |
| 2604 | |
| 2605 | static irqreturn_t batt_removed_irq_handler(int irq, void *data) |
| 2606 | { |
| 2607 | struct pm8921_chg_chip *chip = data; |
| 2608 | int status; |
| 2609 | |
| 2610 | status = pm_chg_get_rt_status(chip, BATT_REMOVED_IRQ); |
| 2611 | pr_debug("battery present=%d state=%d", !status, |
| 2612 | pm_chg_get_fsm_state(data)); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2613 | handle_stop_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2614 | power_supply_changed(&chip->batt_psy); |
| 2615 | return IRQ_HANDLED; |
| 2616 | } |
| 2617 | |
| 2618 | static irqreturn_t batttemp_hot_irq_handler(int irq, void *data) |
| 2619 | { |
| 2620 | struct pm8921_chg_chip *chip = data; |
| 2621 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2622 | handle_stop_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2623 | power_supply_changed(&chip->batt_psy); |
| 2624 | return IRQ_HANDLED; |
| 2625 | } |
| 2626 | |
| 2627 | static irqreturn_t chghot_irq_handler(int irq, void *data) |
| 2628 | { |
| 2629 | struct pm8921_chg_chip *chip = data; |
| 2630 | |
| 2631 | pr_debug("Chg hot fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2632 | power_supply_changed(&chip->batt_psy); |
| 2633 | power_supply_changed(&chip->usb_psy); |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2634 | handle_stop_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2635 | return IRQ_HANDLED; |
| 2636 | } |
| 2637 | |
| 2638 | static irqreturn_t batttemp_cold_irq_handler(int irq, void *data) |
| 2639 | { |
| 2640 | struct pm8921_chg_chip *chip = data; |
| 2641 | |
| 2642 | pr_debug("Batt cold fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2643 | handle_stop_ext_chg(chip); |
| 2644 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2645 | power_supply_changed(&chip->batt_psy); |
| 2646 | power_supply_changed(&chip->usb_psy); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2647 | return IRQ_HANDLED; |
| 2648 | } |
| 2649 | |
| 2650 | static irqreturn_t chg_gone_irq_handler(int irq, void *data) |
| 2651 | { |
| 2652 | struct pm8921_chg_chip *chip = data; |
David Keitel | c3e15bd | 2012-05-25 17:07:25 -0700 | [diff] [blame] | 2653 | int chg_gone, usb_chg_plugged_in; |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 2654 | |
| 2655 | usb_chg_plugged_in = is_usb_chg_plugged_in(chip); |
| 2656 | chg_gone = pm_chg_get_rt_status(chip, CHG_GONE_IRQ); |
| 2657 | |
| 2658 | pr_debug("chg_gone=%d, usb_valid = %d\n", chg_gone, usb_chg_plugged_in); |
David Keitel | 0873d0f | 2012-03-29 11:44:49 -0700 | [diff] [blame] | 2659 | pr_debug("Chg gone fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2660 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2661 | power_supply_changed(&chip->batt_psy); |
| 2662 | power_supply_changed(&chip->usb_psy); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2663 | return IRQ_HANDLED; |
| 2664 | } |
David Keitel | 52fda53 | 2011-11-10 10:43:44 -0800 | [diff] [blame] | 2665 | /* |
| 2666 | * |
| 2667 | * bat_temp_ok_irq_handler - is edge triggered, hence it will |
| 2668 | * fire for two cases: |
| 2669 | * |
| 2670 | * If the interrupt line switches to high temperature is okay |
| 2671 | * and thus charging begins. |
| 2672 | * If bat_temp_ok is low this means the temperature is now |
| 2673 | * too hot or cold, so charging is stopped. |
| 2674 | * |
| 2675 | */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2676 | static irqreturn_t bat_temp_ok_irq_handler(int irq, void *data) |
| 2677 | { |
David Keitel | 52fda53 | 2011-11-10 10:43:44 -0800 | [diff] [blame] | 2678 | int bat_temp_ok; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2679 | struct pm8921_chg_chip *chip = data; |
| 2680 | |
David Keitel | 52fda53 | 2011-11-10 10:43:44 -0800 | [diff] [blame] | 2681 | bat_temp_ok = pm_chg_get_rt_status(chip, BAT_TEMP_OK_IRQ); |
| 2682 | |
| 2683 | pr_debug("batt_temp_ok = %d fsm_state%d\n", |
| 2684 | bat_temp_ok, pm_chg_get_fsm_state(data)); |
| 2685 | |
| 2686 | if (bat_temp_ok) |
| 2687 | handle_start_ext_chg(chip); |
| 2688 | else |
| 2689 | handle_stop_ext_chg(chip); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2690 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2691 | power_supply_changed(&chip->batt_psy); |
| 2692 | power_supply_changed(&chip->usb_psy); |
Abhijeet Dharmapurikar | f247105 | 2011-09-25 22:18:36 -0700 | [diff] [blame] | 2693 | bms_notify_check(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2694 | return IRQ_HANDLED; |
| 2695 | } |
| 2696 | |
| 2697 | static irqreturn_t coarse_det_low_irq_handler(int irq, void *data) |
| 2698 | { |
| 2699 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2700 | return IRQ_HANDLED; |
| 2701 | } |
| 2702 | |
| 2703 | static irqreturn_t vdd_loop_irq_handler(int irq, void *data) |
| 2704 | { |
| 2705 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2706 | return IRQ_HANDLED; |
| 2707 | } |
| 2708 | |
| 2709 | static irqreturn_t vreg_ov_irq_handler(int irq, void *data) |
| 2710 | { |
| 2711 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2712 | return IRQ_HANDLED; |
| 2713 | } |
| 2714 | |
| 2715 | static irqreturn_t vbatdet_irq_handler(int irq, void *data) |
| 2716 | { |
| 2717 | pr_debug("fsm_state=%d\n", pm_chg_get_fsm_state(data)); |
| 2718 | return IRQ_HANDLED; |
| 2719 | } |
| 2720 | |
| 2721 | static irqreturn_t batfet_irq_handler(int irq, void *data) |
| 2722 | { |
| 2723 | struct pm8921_chg_chip *chip = data; |
| 2724 | |
| 2725 | pr_debug("vreg ov\n"); |
| 2726 | power_supply_changed(&chip->batt_psy); |
| 2727 | return IRQ_HANDLED; |
| 2728 | } |
| 2729 | |
| 2730 | static irqreturn_t dcin_valid_irq_handler(int irq, void *data) |
| 2731 | { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2732 | struct pm8921_chg_chip *chip = data; |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2733 | int dc_present; |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2734 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2735 | dc_present = pm_chg_get_rt_status(chip, DCIN_VALID_IRQ); |
| 2736 | if (chip->ext_psy) |
| 2737 | power_supply_set_online(chip->ext_psy, dc_present); |
| 2738 | chip->dc_present = dc_present; |
| 2739 | if (dc_present) |
| 2740 | handle_start_ext_chg(chip); |
| 2741 | else |
| 2742 | handle_stop_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2743 | return IRQ_HANDLED; |
| 2744 | } |
| 2745 | |
| 2746 | static irqreturn_t dcin_ov_irq_handler(int irq, void *data) |
| 2747 | { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2748 | struct pm8921_chg_chip *chip = data; |
| 2749 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2750 | handle_stop_ext_chg(chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2751 | return IRQ_HANDLED; |
| 2752 | } |
| 2753 | |
| 2754 | static irqreturn_t dcin_uv_irq_handler(int irq, void *data) |
| 2755 | { |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2756 | struct pm8921_chg_chip *chip = data; |
| 2757 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2758 | handle_stop_ext_chg(chip); |
| 2759 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 2760 | return IRQ_HANDLED; |
| 2761 | } |
| 2762 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 2763 | static int __pm_batt_external_power_changed_work(struct device *dev, void *data) |
| 2764 | { |
| 2765 | struct power_supply *psy = &the_chip->batt_psy; |
| 2766 | struct power_supply *epsy = dev_get_drvdata(dev); |
| 2767 | int i, dcin_irq; |
| 2768 | |
| 2769 | /* Only search for external supply if none is registered */ |
| 2770 | if (!the_chip->ext_psy) { |
| 2771 | dcin_irq = the_chip->pmic_chg_irq[DCIN_VALID_IRQ]; |
| 2772 | for (i = 0; i < epsy->num_supplicants; i++) { |
| 2773 | if (!strncmp(epsy->supplied_to[i], psy->name, 7)) { |
| 2774 | if (!strncmp(epsy->name, "dc", 2)) { |
| 2775 | the_chip->ext_psy = epsy; |
| 2776 | dcin_valid_irq_handler(dcin_irq, |
| 2777 | the_chip); |
| 2778 | } |
| 2779 | } |
| 2780 | } |
| 2781 | } |
| 2782 | return 0; |
| 2783 | } |
| 2784 | |
| 2785 | static void pm_batt_external_power_changed(struct power_supply *psy) |
| 2786 | { |
| 2787 | /* Only look for an external supply if it hasn't been registered */ |
| 2788 | if (!the_chip->ext_psy) |
| 2789 | class_for_each_device(power_supply_class, NULL, psy, |
| 2790 | __pm_batt_external_power_changed_work); |
| 2791 | } |
| 2792 | |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 2793 | /** |
| 2794 | * update_heartbeat - internal function to update userspace |
| 2795 | * per update_time minutes |
| 2796 | * |
| 2797 | */ |
Abhijeet Dharmapurikar | de9c7e7 | 2012-07-15 16:29:51 -0700 | [diff] [blame] | 2798 | #define LOW_SOC_HEARTBEAT_MS 20000 |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 2799 | static void update_heartbeat(struct work_struct *work) |
| 2800 | { |
| 2801 | struct delayed_work *dwork = to_delayed_work(work); |
| 2802 | struct pm8921_chg_chip *chip = container_of(dwork, |
| 2803 | struct pm8921_chg_chip, update_heartbeat_work); |
| 2804 | |
Abhijeet Dharmapurikar | e451f34 | 2012-02-23 16:39:42 -0800 | [diff] [blame] | 2805 | pm_chg_failed_clear(chip, 1); |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 2806 | power_supply_changed(&chip->batt_psy); |
Abhijeet Dharmapurikar | de9c7e7 | 2012-07-15 16:29:51 -0700 | [diff] [blame] | 2807 | if (chip->recent_reported_soc <= 20) |
| 2808 | schedule_delayed_work(&chip->update_heartbeat_work, |
| 2809 | round_jiffies_relative(msecs_to_jiffies |
| 2810 | (LOW_SOC_HEARTBEAT_MS))); |
| 2811 | else |
| 2812 | schedule_delayed_work(&chip->update_heartbeat_work, |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 2813 | round_jiffies_relative(msecs_to_jiffies |
| 2814 | (chip->update_time))); |
| 2815 | } |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 2816 | #define VDD_LOOP_ACTIVE_BIT BIT(3) |
| 2817 | #define VDD_MAX_INCREASE_MV 400 |
| 2818 | static int vdd_max_increase_mv = VDD_MAX_INCREASE_MV; |
| 2819 | module_param(vdd_max_increase_mv, int, 0644); |
| 2820 | |
| 2821 | static int ichg_threshold_ua = -400000; |
| 2822 | module_param(ichg_threshold_ua, int, 0644); |
Abhijeet Dharmapurikar | dc3323a | 2012-08-10 15:47:31 -0700 | [diff] [blame] | 2823 | |
| 2824 | #define PM8921_CHG_VDDMAX_RES_MV 10 |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 2825 | static void adjust_vdd_max_for_fastchg(struct pm8921_chg_chip *chip) |
| 2826 | { |
| 2827 | int ichg_meas_ua, vbat_uv; |
| 2828 | int ichg_meas_ma; |
| 2829 | int adj_vdd_max_mv, programmed_vdd_max; |
| 2830 | int vbat_batt_terminal_uv; |
| 2831 | int vbat_batt_terminal_mv; |
| 2832 | int reg_loop; |
| 2833 | int delta_mv = 0; |
| 2834 | |
| 2835 | if (chip->rconn_mohm == 0) { |
| 2836 | pr_debug("Exiting as rconn_mohm is 0\n"); |
| 2837 | return; |
| 2838 | } |
| 2839 | /* adjust vdd_max only in normal temperature zone */ |
| 2840 | if (chip->is_bat_cool || chip->is_bat_warm) { |
| 2841 | pr_debug("Exiting is_bat_cool = %d is_batt_warm = %d\n", |
| 2842 | chip->is_bat_cool, chip->is_bat_warm); |
| 2843 | return; |
| 2844 | } |
| 2845 | |
| 2846 | reg_loop = pm_chg_get_regulation_loop(chip); |
| 2847 | if (!(reg_loop & VDD_LOOP_ACTIVE_BIT)) { |
| 2848 | pr_debug("Exiting Vdd loop is not active reg loop=0x%x\n", |
| 2849 | reg_loop); |
| 2850 | return; |
| 2851 | } |
| 2852 | |
| 2853 | pm8921_bms_get_simultaneous_battery_voltage_and_current(&ichg_meas_ua, |
| 2854 | &vbat_uv); |
| 2855 | if (ichg_meas_ua >= 0) { |
| 2856 | pr_debug("Exiting ichg_meas_ua = %d > 0\n", ichg_meas_ua); |
| 2857 | return; |
| 2858 | } |
Abhijeet Dharmapurikar | 16e832d | 2012-08-28 18:34:47 -0700 | [diff] [blame] | 2859 | |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 2860 | ichg_meas_ma = ichg_meas_ua / 1000; |
| 2861 | |
| 2862 | /* rconn_mohm is in milliOhms */ |
| 2863 | vbat_batt_terminal_uv = vbat_uv + ichg_meas_ma * the_chip->rconn_mohm; |
| 2864 | vbat_batt_terminal_mv = vbat_batt_terminal_uv/1000; |
| 2865 | pm_chg_vddmax_get(the_chip, &programmed_vdd_max); |
| 2866 | |
| 2867 | delta_mv = chip->max_voltage_mv - vbat_batt_terminal_mv; |
| 2868 | |
| 2869 | adj_vdd_max_mv = programmed_vdd_max + delta_mv; |
| 2870 | pr_debug("vdd_max needs to be changed by %d mv from %d to %d\n", |
| 2871 | delta_mv, |
| 2872 | programmed_vdd_max, |
| 2873 | adj_vdd_max_mv); |
| 2874 | |
| 2875 | if (adj_vdd_max_mv < chip->max_voltage_mv) { |
| 2876 | pr_debug("adj vdd_max lower than default max voltage\n"); |
| 2877 | return; |
| 2878 | } |
| 2879 | |
Abhijeet Dharmapurikar | dc3323a | 2012-08-10 15:47:31 -0700 | [diff] [blame] | 2880 | adj_vdd_max_mv = DIV_ROUND_UP(adj_vdd_max_mv, PM8921_CHG_VDDMAX_RES_MV) |
| 2881 | * PM8921_CHG_VDDMAX_RES_MV; |
| 2882 | |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 2883 | if (adj_vdd_max_mv > (chip->max_voltage_mv + vdd_max_increase_mv)) |
| 2884 | adj_vdd_max_mv = chip->max_voltage_mv + vdd_max_increase_mv; |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 2885 | pr_debug("adjusting vdd_max_mv to %d to make " |
| 2886 | "vbat_batt_termial_uv = %d to %d\n", |
| 2887 | adj_vdd_max_mv, vbat_batt_terminal_uv, chip->max_voltage_mv); |
| 2888 | pm_chg_vddmax_set(chip, adj_vdd_max_mv); |
| 2889 | } |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 2890 | |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 2891 | enum { |
| 2892 | CHG_IN_PROGRESS, |
| 2893 | CHG_NOT_IN_PROGRESS, |
| 2894 | CHG_FINISHED, |
| 2895 | }; |
| 2896 | |
| 2897 | #define VBAT_TOLERANCE_MV 70 |
| 2898 | #define CHG_DISABLE_MSLEEP 100 |
| 2899 | static int is_charging_finished(struct pm8921_chg_chip *chip) |
| 2900 | { |
| 2901 | int vbat_meas_uv, vbat_meas_mv, vbat_programmed, vbatdet_low; |
| 2902 | int ichg_meas_ma, iterm_programmed; |
| 2903 | int regulation_loop, fast_chg, vcp; |
| 2904 | int rc; |
| 2905 | static int last_vbat_programmed = -EINVAL; |
| 2906 | |
| 2907 | if (!is_ext_charging(chip)) { |
| 2908 | /* return if the battery is not being fastcharged */ |
| 2909 | fast_chg = pm_chg_get_rt_status(chip, FASTCHG_IRQ); |
| 2910 | pr_debug("fast_chg = %d\n", fast_chg); |
| 2911 | if (fast_chg == 0) |
| 2912 | return CHG_NOT_IN_PROGRESS; |
| 2913 | |
| 2914 | vcp = pm_chg_get_rt_status(chip, VCP_IRQ); |
| 2915 | pr_debug("vcp = %d\n", vcp); |
| 2916 | if (vcp == 1) |
| 2917 | return CHG_IN_PROGRESS; |
| 2918 | |
| 2919 | vbatdet_low = pm_chg_get_rt_status(chip, VBATDET_LOW_IRQ); |
| 2920 | pr_debug("vbatdet_low = %d\n", vbatdet_low); |
| 2921 | if (vbatdet_low == 1) |
| 2922 | return CHG_IN_PROGRESS; |
| 2923 | |
| 2924 | /* reset count if battery is hot/cold */ |
| 2925 | rc = pm_chg_get_rt_status(chip, BAT_TEMP_OK_IRQ); |
| 2926 | pr_debug("batt_temp_ok = %d\n", rc); |
| 2927 | if (rc == 0) |
| 2928 | return CHG_IN_PROGRESS; |
| 2929 | |
| 2930 | /* reset count if battery voltage is less than vddmax */ |
| 2931 | vbat_meas_uv = get_prop_battery_uvolts(chip); |
| 2932 | if (vbat_meas_uv < 0) |
| 2933 | return CHG_IN_PROGRESS; |
| 2934 | vbat_meas_mv = vbat_meas_uv / 1000; |
| 2935 | |
| 2936 | rc = pm_chg_vddmax_get(chip, &vbat_programmed); |
| 2937 | if (rc) { |
| 2938 | pr_err("couldnt read vddmax rc = %d\n", rc); |
| 2939 | return CHG_IN_PROGRESS; |
| 2940 | } |
| 2941 | pr_debug("vddmax = %d vbat_meas_mv=%d\n", |
| 2942 | vbat_programmed, vbat_meas_mv); |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 2943 | |
| 2944 | if (last_vbat_programmed == -EINVAL) |
| 2945 | last_vbat_programmed = vbat_programmed; |
| 2946 | if (last_vbat_programmed != vbat_programmed) { |
| 2947 | /* vddmax changed, reset and check again */ |
| 2948 | pr_debug("vddmax = %d last_vdd_max=%d\n", |
| 2949 | vbat_programmed, last_vbat_programmed); |
| 2950 | last_vbat_programmed = vbat_programmed; |
| 2951 | return CHG_IN_PROGRESS; |
| 2952 | } |
| 2953 | |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 2954 | regulation_loop = pm_chg_get_regulation_loop(chip); |
| 2955 | if (regulation_loop < 0) { |
| 2956 | pr_err("couldnt read the regulation loop err=%d\n", |
| 2957 | regulation_loop); |
| 2958 | return CHG_IN_PROGRESS; |
| 2959 | } |
| 2960 | pr_debug("regulation_loop=%d\n", regulation_loop); |
| 2961 | |
| 2962 | if (regulation_loop != 0 && regulation_loop != VDD_LOOP) |
| 2963 | return CHG_IN_PROGRESS; |
| 2964 | } /* !is_ext_charging */ |
| 2965 | |
| 2966 | /* reset count if battery chg current is more than iterm */ |
| 2967 | rc = pm_chg_iterm_get(chip, &iterm_programmed); |
| 2968 | if (rc) { |
| 2969 | pr_err("couldnt read iterm rc = %d\n", rc); |
| 2970 | return CHG_IN_PROGRESS; |
| 2971 | } |
| 2972 | |
| 2973 | ichg_meas_ma = (get_prop_batt_current(chip)) / 1000; |
| 2974 | pr_debug("iterm_programmed = %d ichg_meas_ma=%d\n", |
| 2975 | iterm_programmed, ichg_meas_ma); |
| 2976 | /* |
| 2977 | * ichg_meas_ma < 0 means battery is drawing current |
| 2978 | * ichg_meas_ma > 0 means battery is providing current |
| 2979 | */ |
| 2980 | if (ichg_meas_ma > 0) |
| 2981 | return CHG_IN_PROGRESS; |
| 2982 | |
| 2983 | if (ichg_meas_ma * -1 > iterm_programmed) |
| 2984 | return CHG_IN_PROGRESS; |
| 2985 | |
| 2986 | return CHG_FINISHED; |
| 2987 | } |
| 2988 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2989 | /** |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 2990 | * eoc_worker - internal function to check if battery EOC |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 2991 | * has happened |
| 2992 | * |
| 2993 | * If all conditions favouring, if the charge current is |
| 2994 | * less than the term current for three consecutive times |
| 2995 | * an EOC has happened. |
| 2996 | * The wakelock is released if there is no need to reshedule |
| 2997 | * - this happens when the battery is removed or EOC has |
| 2998 | * happened |
| 2999 | */ |
| 3000 | #define CONSECUTIVE_COUNT 3 |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 3001 | static void eoc_worker(struct work_struct *work) |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3002 | { |
| 3003 | struct delayed_work *dwork = to_delayed_work(work); |
| 3004 | struct pm8921_chg_chip *chip = container_of(dwork, |
| 3005 | struct pm8921_chg_chip, eoc_work); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3006 | static int count; |
Abhijeet Dharmapurikar | e451f34 | 2012-02-23 16:39:42 -0800 | [diff] [blame] | 3007 | int end; |
| 3008 | |
| 3009 | pm_chg_failed_clear(chip, 1); |
| 3010 | end = is_charging_finished(chip); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3011 | |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 3012 | if (end == CHG_NOT_IN_PROGRESS) { |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 3013 | count = 0; |
| 3014 | wake_unlock(&chip->eoc_wake_lock); |
| 3015 | return; |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3016 | } |
| 3017 | |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 3018 | if (end == CHG_FINISHED) { |
| 3019 | count++; |
| 3020 | } else { |
| 3021 | count = 0; |
| 3022 | } |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3023 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3024 | if (count == CONSECUTIVE_COUNT) { |
| 3025 | count = 0; |
| 3026 | pr_info("End of Charging\n"); |
| 3027 | |
| 3028 | pm_chg_auto_enable(chip, 0); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3029 | |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 3030 | if (is_ext_charging(chip)) |
| 3031 | chip->ext_charge_done = true; |
| 3032 | |
Abhijeet Dharmapurikar | eb882f5 | 2011-12-22 09:02:34 -0800 | [diff] [blame] | 3033 | if (chip->is_bat_warm || chip->is_bat_cool) |
| 3034 | chip->bms_notify.is_battery_full = 0; |
| 3035 | else |
| 3036 | chip->bms_notify.is_battery_full = 1; |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3037 | /* declare end of charging by invoking chgdone interrupt */ |
| 3038 | chgdone_irq_handler(chip->pmic_chg_irq[CHGDONE_IRQ], chip); |
| 3039 | wake_unlock(&chip->eoc_wake_lock); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3040 | } else { |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 3041 | adjust_vdd_max_for_fastchg(chip); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3042 | pr_debug("EOC count = %d\n", count); |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 3043 | schedule_delayed_work(&chip->eoc_work, |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3044 | round_jiffies_relative(msecs_to_jiffies |
| 3045 | (EOC_CHECK_PERIOD_MS))); |
Abhijeet Dharmapurikar | 75c0350 | 2012-01-09 12:45:57 -0800 | [diff] [blame] | 3046 | } |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3047 | } |
| 3048 | |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3049 | static void btm_configure_work(struct work_struct *work) |
| 3050 | { |
| 3051 | int rc; |
| 3052 | |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 3053 | rc = pm8xxx_adc_btm_configure(&btm_config); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3054 | if (rc) |
| 3055 | pr_err("failed to configure btm rc=%d", rc); |
| 3056 | } |
| 3057 | |
| 3058 | DECLARE_WORK(btm_config_work, btm_configure_work); |
| 3059 | |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3060 | static void set_appropriate_battery_current(struct pm8921_chg_chip *chip) |
| 3061 | { |
| 3062 | unsigned int chg_current = chip->max_bat_chg_current; |
| 3063 | |
| 3064 | if (chip->is_bat_cool) |
| 3065 | chg_current = min(chg_current, chip->cool_bat_chg_current); |
| 3066 | |
| 3067 | if (chip->is_bat_warm) |
| 3068 | chg_current = min(chg_current, chip->warm_bat_chg_current); |
| 3069 | |
David Keitel | fdef3a4 | 2011-12-14 19:02:54 -0800 | [diff] [blame] | 3070 | if (thermal_mitigation != 0 && chip->thermal_mitigation) |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3071 | chg_current = min(chg_current, |
| 3072 | chip->thermal_mitigation[thermal_mitigation]); |
| 3073 | |
| 3074 | pm_chg_ibatmax_set(the_chip, chg_current); |
| 3075 | } |
| 3076 | |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3077 | #define TEMP_HYSTERISIS_DEGC 2 |
| 3078 | static void battery_cool(bool enter) |
| 3079 | { |
| 3080 | pr_debug("enter = %d\n", enter); |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3081 | if (enter == the_chip->is_bat_cool) |
| 3082 | return; |
| 3083 | the_chip->is_bat_cool = enter; |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3084 | if (enter) { |
| 3085 | btm_config.low_thr_temp = |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3086 | the_chip->cool_temp_dc + TEMP_HYSTERISIS_DEGC; |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3087 | set_appropriate_battery_current(the_chip); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3088 | pm_chg_vddmax_set(the_chip, the_chip->cool_bat_voltage); |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3089 | pm_chg_vbatdet_set(the_chip, |
| 3090 | the_chip->cool_bat_voltage |
| 3091 | - the_chip->resume_voltage_delta); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3092 | } else { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3093 | btm_config.low_thr_temp = the_chip->cool_temp_dc; |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3094 | set_appropriate_battery_current(the_chip); |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3095 | pm_chg_vddmax_set(the_chip, the_chip->max_voltage_mv); |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3096 | pm_chg_vbatdet_set(the_chip, |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3097 | the_chip->max_voltage_mv |
| 3098 | - the_chip->resume_voltage_delta); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3099 | } |
| 3100 | schedule_work(&btm_config_work); |
| 3101 | } |
| 3102 | |
| 3103 | static void battery_warm(bool enter) |
| 3104 | { |
| 3105 | pr_debug("enter = %d\n", enter); |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3106 | if (enter == the_chip->is_bat_warm) |
| 3107 | return; |
| 3108 | the_chip->is_bat_warm = enter; |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3109 | if (enter) { |
| 3110 | btm_config.high_thr_temp = |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3111 | the_chip->warm_temp_dc - TEMP_HYSTERISIS_DEGC; |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3112 | set_appropriate_battery_current(the_chip); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3113 | pm_chg_vddmax_set(the_chip, the_chip->warm_bat_voltage); |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3114 | pm_chg_vbatdet_set(the_chip, |
| 3115 | the_chip->warm_bat_voltage |
| 3116 | - the_chip->resume_voltage_delta); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3117 | } else { |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3118 | btm_config.high_thr_temp = the_chip->warm_temp_dc; |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3119 | set_appropriate_battery_current(the_chip); |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3120 | pm_chg_vddmax_set(the_chip, the_chip->max_voltage_mv); |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3121 | pm_chg_vbatdet_set(the_chip, |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3122 | the_chip->max_voltage_mv |
| 3123 | - the_chip->resume_voltage_delta); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3124 | } |
| 3125 | schedule_work(&btm_config_work); |
| 3126 | } |
| 3127 | |
| 3128 | static int configure_btm(struct pm8921_chg_chip *chip) |
| 3129 | { |
| 3130 | int rc; |
| 3131 | |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 3132 | if (chip->warm_temp_dc != INT_MIN) |
| 3133 | btm_config.btm_warm_fn = battery_warm; |
| 3134 | else |
| 3135 | btm_config.btm_warm_fn = NULL; |
| 3136 | |
| 3137 | if (chip->cool_temp_dc != INT_MIN) |
| 3138 | btm_config.btm_cool_fn = battery_cool; |
| 3139 | else |
| 3140 | btm_config.btm_cool_fn = NULL; |
| 3141 | |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3142 | btm_config.low_thr_temp = chip->cool_temp_dc; |
| 3143 | btm_config.high_thr_temp = chip->warm_temp_dc; |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3144 | btm_config.interval = chip->temp_check_period; |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 3145 | rc = pm8xxx_adc_btm_configure(&btm_config); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3146 | if (rc) |
| 3147 | pr_err("failed to configure btm rc = %d\n", rc); |
Siddartha Mohanadoss | af91d90 | 2011-10-20 10:23:34 -0700 | [diff] [blame] | 3148 | rc = pm8xxx_adc_btm_start(); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3149 | if (rc) |
| 3150 | pr_err("failed to start btm rc = %d\n", rc); |
| 3151 | |
| 3152 | return rc; |
| 3153 | } |
| 3154 | |
Abhijeet Dharmapurikar | 1f52c41 | 2011-08-12 17:11:45 -0700 | [diff] [blame] | 3155 | /** |
| 3156 | * set_disable_status_param - |
| 3157 | * |
| 3158 | * Internal function to disable battery charging and also disable drawing |
| 3159 | * any current from the source. The device is forced to run on a battery |
| 3160 | * after this. |
| 3161 | */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3162 | static int set_disable_status_param(const char *val, struct kernel_param *kp) |
| 3163 | { |
| 3164 | int ret; |
| 3165 | struct pm8921_chg_chip *chip = the_chip; |
| 3166 | |
| 3167 | ret = param_set_int(val, kp); |
| 3168 | if (ret) { |
| 3169 | pr_err("error setting value %d\n", ret); |
| 3170 | return ret; |
| 3171 | } |
| 3172 | pr_info("factory set disable param to %d\n", charging_disabled); |
| 3173 | if (chip) { |
| 3174 | pm_chg_auto_enable(chip, !charging_disabled); |
| 3175 | pm_chg_charge_dis(chip, charging_disabled); |
| 3176 | } |
| 3177 | return 0; |
| 3178 | } |
| 3179 | module_param_call(disabled, set_disable_status_param, param_get_uint, |
| 3180 | &charging_disabled, 0644); |
| 3181 | |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 3182 | static int rconn_mohm; |
| 3183 | static int set_rconn_mohm(const char *val, struct kernel_param *kp) |
| 3184 | { |
| 3185 | int ret; |
| 3186 | struct pm8921_chg_chip *chip = the_chip; |
| 3187 | |
| 3188 | ret = param_set_int(val, kp); |
| 3189 | if (ret) { |
| 3190 | pr_err("error setting value %d\n", ret); |
| 3191 | return ret; |
| 3192 | } |
| 3193 | if (chip) |
| 3194 | chip->rconn_mohm = rconn_mohm; |
| 3195 | return 0; |
| 3196 | } |
| 3197 | module_param_call(rconn_mohm, set_rconn_mohm, param_get_uint, |
| 3198 | &rconn_mohm, 0644); |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 3199 | /** |
| 3200 | * set_thermal_mitigation_level - |
| 3201 | * |
| 3202 | * Internal function to control battery charging current to reduce |
| 3203 | * temperature |
| 3204 | */ |
| 3205 | static int set_therm_mitigation_level(const char *val, struct kernel_param *kp) |
| 3206 | { |
| 3207 | int ret; |
| 3208 | struct pm8921_chg_chip *chip = the_chip; |
| 3209 | |
| 3210 | ret = param_set_int(val, kp); |
| 3211 | if (ret) { |
| 3212 | pr_err("error setting value %d\n", ret); |
| 3213 | return ret; |
| 3214 | } |
| 3215 | |
| 3216 | if (!chip) { |
| 3217 | pr_err("called before init\n"); |
| 3218 | return -EINVAL; |
| 3219 | } |
| 3220 | |
| 3221 | if (!chip->thermal_mitigation) { |
| 3222 | pr_err("no thermal mitigation\n"); |
| 3223 | return -EINVAL; |
| 3224 | } |
| 3225 | |
| 3226 | if (thermal_mitigation < 0 |
| 3227 | || thermal_mitigation >= chip->thermal_levels) { |
| 3228 | pr_err("out of bound level selected\n"); |
| 3229 | return -EINVAL; |
| 3230 | } |
| 3231 | |
Abhijeet Dharmapurikar | d585ff2 | 2011-11-10 14:27:25 -0800 | [diff] [blame] | 3232 | set_appropriate_battery_current(chip); |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 3233 | return ret; |
| 3234 | } |
| 3235 | module_param_call(thermal_mitigation, set_therm_mitigation_level, |
| 3236 | param_get_uint, |
| 3237 | &thermal_mitigation, 0644); |
| 3238 | |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 3239 | static int set_usb_max_current(const char *val, struct kernel_param *kp) |
| 3240 | { |
| 3241 | int ret, mA; |
| 3242 | struct pm8921_chg_chip *chip = the_chip; |
| 3243 | |
| 3244 | ret = param_set_int(val, kp); |
| 3245 | if (ret) { |
| 3246 | pr_err("error setting value %d\n", ret); |
| 3247 | return ret; |
| 3248 | } |
| 3249 | if (chip) { |
| 3250 | pr_warn("setting current max to %d\n", usb_max_current); |
| 3251 | pm_chg_iusbmax_get(chip, &mA); |
| 3252 | if (mA > usb_max_current) |
| 3253 | pm8921_charger_vbus_draw(usb_max_current); |
| 3254 | return 0; |
| 3255 | } |
| 3256 | return -EINVAL; |
| 3257 | } |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 3258 | module_param_call(usb_max_current, set_usb_max_current, |
| 3259 | param_get_uint, &usb_max_current, 0644); |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 3260 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3261 | static void free_irqs(struct pm8921_chg_chip *chip) |
| 3262 | { |
| 3263 | int i; |
| 3264 | |
| 3265 | for (i = 0; i < PM_CHG_MAX_INTS; i++) |
| 3266 | if (chip->pmic_chg_irq[i]) { |
| 3267 | free_irq(chip->pmic_chg_irq[i], chip); |
| 3268 | chip->pmic_chg_irq[i] = 0; |
| 3269 | } |
| 3270 | } |
| 3271 | |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 3272 | /* determines the initial present states */ |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3273 | static void __devinit determine_initial_state(struct pm8921_chg_chip *chip) |
| 3274 | { |
| 3275 | unsigned long flags; |
| 3276 | int fsm_state; |
| 3277 | |
| 3278 | chip->dc_present = !!is_dc_chg_plugged_in(chip); |
| 3279 | chip->usb_present = !!is_usb_chg_plugged_in(chip); |
| 3280 | |
| 3281 | notify_usb_of_the_plugin_event(chip->usb_present); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 3282 | if (chip->usb_present) { |
| 3283 | schedule_delayed_work(&chip->unplug_check_work, |
| 3284 | round_jiffies_relative(msecs_to_jiffies |
| 3285 | (UNPLUG_CHECK_WAIT_PERIOD_MS))); |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 3286 | pm8921_chg_enable_irq(chip, CHG_GONE_IRQ); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 3287 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3288 | |
| 3289 | pm8921_chg_enable_irq(chip, DCIN_VALID_IRQ); |
| 3290 | pm8921_chg_enable_irq(chip, USBIN_VALID_IRQ); |
| 3291 | pm8921_chg_enable_irq(chip, BATT_REMOVED_IRQ); |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 3292 | pm8921_chg_enable_irq(chip, BATT_INSERTED_IRQ); |
| 3293 | pm8921_chg_enable_irq(chip, USBIN_OV_IRQ); |
| 3294 | pm8921_chg_enable_irq(chip, USBIN_UV_IRQ); |
| 3295 | pm8921_chg_enable_irq(chip, DCIN_OV_IRQ); |
| 3296 | pm8921_chg_enable_irq(chip, DCIN_UV_IRQ); |
David Keitel | 753ec8d | 2011-11-02 10:56:37 -0700 | [diff] [blame] | 3297 | pm8921_chg_enable_irq(chip, CHGFAIL_IRQ); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3298 | pm8921_chg_enable_irq(chip, FASTCHG_IRQ); |
| 3299 | pm8921_chg_enable_irq(chip, VBATDET_LOW_IRQ); |
David Keitel | 52fda53 | 2011-11-10 10:43:44 -0800 | [diff] [blame] | 3300 | pm8921_chg_enable_irq(chip, BAT_TEMP_OK_IRQ); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3301 | |
| 3302 | spin_lock_irqsave(&vbus_lock, flags); |
| 3303 | if (usb_chg_current) { |
| 3304 | /* reissue a vbus draw call */ |
| 3305 | __pm8921_charger_vbus_draw(usb_chg_current); |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 3306 | fastchg_irq_handler(chip->pmic_chg_irq[FASTCHG_IRQ], chip); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3307 | } |
| 3308 | spin_unlock_irqrestore(&vbus_lock, flags); |
| 3309 | |
| 3310 | fsm_state = pm_chg_get_fsm_state(chip); |
| 3311 | if (is_battery_charging(fsm_state)) { |
| 3312 | chip->bms_notify.is_charging = 1; |
| 3313 | pm8921_bms_charging_began(); |
| 3314 | } |
| 3315 | |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 3316 | check_battery_valid(chip); |
| 3317 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3318 | pr_debug("usb = %d, dc = %d batt = %d state=%d\n", |
| 3319 | chip->usb_present, |
| 3320 | chip->dc_present, |
| 3321 | get_prop_batt_present(chip), |
| 3322 | fsm_state); |
| 3323 | } |
| 3324 | |
| 3325 | struct pm_chg_irq_init_data { |
| 3326 | unsigned int irq_id; |
| 3327 | char *name; |
| 3328 | unsigned long flags; |
| 3329 | irqreturn_t (*handler)(int, void *); |
| 3330 | }; |
| 3331 | |
| 3332 | #define CHG_IRQ(_id, _flags, _handler) \ |
| 3333 | { \ |
| 3334 | .irq_id = _id, \ |
| 3335 | .name = #_id, \ |
| 3336 | .flags = _flags, \ |
| 3337 | .handler = _handler, \ |
| 3338 | } |
| 3339 | struct pm_chg_irq_init_data chg_irq_data[] = { |
| 3340 | CHG_IRQ(USBIN_VALID_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3341 | usbin_valid_irq_handler), |
Abhijeet Dharmapurikar | 956215b | 2011-10-19 15:30:14 -0700 | [diff] [blame] | 3342 | CHG_IRQ(USBIN_OV_IRQ, IRQF_TRIGGER_RISING, usbin_ov_irq_handler), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3343 | CHG_IRQ(BATT_INSERTED_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3344 | batt_inserted_irq_handler), |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 3345 | CHG_IRQ(VBATDET_LOW_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3346 | vbatdet_low_irq_handler), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3347 | CHG_IRQ(USBIN_UV_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3348 | usbin_uv_irq_handler), |
| 3349 | CHG_IRQ(VBAT_OV_IRQ, IRQF_TRIGGER_RISING, vbat_ov_irq_handler), |
| 3350 | CHG_IRQ(CHGWDOG_IRQ, IRQF_TRIGGER_RISING, chgwdog_irq_handler), |
| 3351 | CHG_IRQ(VCP_IRQ, IRQF_TRIGGER_RISING, vcp_irq_handler), |
| 3352 | CHG_IRQ(ATCDONE_IRQ, IRQF_TRIGGER_RISING, atcdone_irq_handler), |
| 3353 | CHG_IRQ(ATCFAIL_IRQ, IRQF_TRIGGER_RISING, atcfail_irq_handler), |
| 3354 | CHG_IRQ(CHGDONE_IRQ, IRQF_TRIGGER_RISING, chgdone_irq_handler), |
| 3355 | CHG_IRQ(CHGFAIL_IRQ, IRQF_TRIGGER_RISING, chgfail_irq_handler), |
| 3356 | CHG_IRQ(CHGSTATE_IRQ, IRQF_TRIGGER_RISING, chgstate_irq_handler), |
| 3357 | CHG_IRQ(LOOP_CHANGE_IRQ, IRQF_TRIGGER_RISING, loop_change_irq_handler), |
Abhijeet Dharmapurikar | 19e3813 | 2011-11-03 12:03:36 -0700 | [diff] [blame] | 3358 | CHG_IRQ(FASTCHG_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3359 | fastchg_irq_handler), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3360 | CHG_IRQ(TRKLCHG_IRQ, IRQF_TRIGGER_RISING, trklchg_irq_handler), |
| 3361 | CHG_IRQ(BATT_REMOVED_IRQ, IRQF_TRIGGER_RISING, |
| 3362 | batt_removed_irq_handler), |
| 3363 | CHG_IRQ(BATTTEMP_HOT_IRQ, IRQF_TRIGGER_RISING, |
| 3364 | batttemp_hot_irq_handler), |
| 3365 | CHG_IRQ(CHGHOT_IRQ, IRQF_TRIGGER_RISING, chghot_irq_handler), |
| 3366 | CHG_IRQ(BATTTEMP_COLD_IRQ, IRQF_TRIGGER_RISING, |
| 3367 | batttemp_cold_irq_handler), |
David Keitel | 8c5201a | 2012-02-24 16:08:54 -0800 | [diff] [blame] | 3368 | CHG_IRQ(CHG_GONE_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3369 | chg_gone_irq_handler), |
Abhijeet Dharmapurikar | f247105 | 2011-09-25 22:18:36 -0700 | [diff] [blame] | 3370 | CHG_IRQ(BAT_TEMP_OK_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3371 | bat_temp_ok_irq_handler), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3372 | CHG_IRQ(COARSE_DET_LOW_IRQ, IRQF_TRIGGER_RISING, |
| 3373 | coarse_det_low_irq_handler), |
| 3374 | CHG_IRQ(VDD_LOOP_IRQ, IRQF_TRIGGER_RISING, vdd_loop_irq_handler), |
| 3375 | CHG_IRQ(VREG_OV_IRQ, IRQF_TRIGGER_RISING, vreg_ov_irq_handler), |
| 3376 | CHG_IRQ(VBATDET_IRQ, IRQF_TRIGGER_RISING, vbatdet_irq_handler), |
| 3377 | CHG_IRQ(BATFET_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3378 | batfet_irq_handler), |
| 3379 | CHG_IRQ(DCIN_VALID_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3380 | dcin_valid_irq_handler), |
| 3381 | CHG_IRQ(DCIN_OV_IRQ, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 3382 | dcin_ov_irq_handler), |
Abhijeet Dharmapurikar | 956215b | 2011-10-19 15:30:14 -0700 | [diff] [blame] | 3383 | CHG_IRQ(DCIN_UV_IRQ, IRQF_TRIGGER_RISING, dcin_uv_irq_handler), |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3384 | }; |
| 3385 | |
| 3386 | static int __devinit request_irqs(struct pm8921_chg_chip *chip, |
| 3387 | struct platform_device *pdev) |
| 3388 | { |
| 3389 | struct resource *res; |
| 3390 | int ret, i; |
| 3391 | |
| 3392 | ret = 0; |
| 3393 | bitmap_fill(chip->enabled_irqs, PM_CHG_MAX_INTS); |
| 3394 | |
| 3395 | for (i = 0; i < ARRAY_SIZE(chg_irq_data); i++) { |
| 3396 | res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, |
| 3397 | chg_irq_data[i].name); |
| 3398 | if (res == NULL) { |
| 3399 | pr_err("couldn't find %s\n", chg_irq_data[i].name); |
| 3400 | goto err_out; |
| 3401 | } |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3402 | chip->pmic_chg_irq[chg_irq_data[i].irq_id] = res->start; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3403 | ret = request_irq(res->start, chg_irq_data[i].handler, |
| 3404 | chg_irq_data[i].flags, |
| 3405 | chg_irq_data[i].name, chip); |
| 3406 | if (ret < 0) { |
| 3407 | pr_err("couldn't request %d (%s) %d\n", res->start, |
| 3408 | chg_irq_data[i].name, ret); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3409 | chip->pmic_chg_irq[chg_irq_data[i].irq_id] = 0; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3410 | goto err_out; |
| 3411 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3412 | pm8921_chg_disable_irq(chip, chg_irq_data[i].irq_id); |
| 3413 | } |
| 3414 | return 0; |
| 3415 | |
| 3416 | err_out: |
| 3417 | free_irqs(chip); |
| 3418 | return -EINVAL; |
| 3419 | } |
| 3420 | |
Abhijeet Dharmapurikar | ccac695 | 2012-01-18 16:35:34 -0800 | [diff] [blame] | 3421 | static void pm8921_chg_force_19p2mhz_clk(struct pm8921_chg_chip *chip) |
| 3422 | { |
| 3423 | int err; |
| 3424 | u8 temp; |
| 3425 | |
| 3426 | temp = 0xD1; |
| 3427 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3428 | if (err) { |
| 3429 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3430 | return; |
| 3431 | } |
| 3432 | |
| 3433 | temp = 0xD3; |
| 3434 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3435 | if (err) { |
| 3436 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3437 | return; |
| 3438 | } |
| 3439 | |
| 3440 | temp = 0xD1; |
| 3441 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3442 | if (err) { |
| 3443 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3444 | return; |
| 3445 | } |
| 3446 | |
| 3447 | temp = 0xD5; |
| 3448 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3449 | if (err) { |
| 3450 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3451 | return; |
| 3452 | } |
| 3453 | |
| 3454 | udelay(183); |
| 3455 | |
| 3456 | temp = 0xD1; |
| 3457 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3458 | if (err) { |
| 3459 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3460 | return; |
| 3461 | } |
| 3462 | |
| 3463 | temp = 0xD0; |
| 3464 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3465 | if (err) { |
| 3466 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3467 | return; |
| 3468 | } |
| 3469 | udelay(32); |
| 3470 | |
| 3471 | temp = 0xD1; |
| 3472 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3473 | if (err) { |
| 3474 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3475 | return; |
| 3476 | } |
| 3477 | |
| 3478 | temp = 0xD3; |
| 3479 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3480 | if (err) { |
| 3481 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3482 | return; |
| 3483 | } |
| 3484 | } |
| 3485 | |
| 3486 | static void pm8921_chg_set_hw_clk_switching(struct pm8921_chg_chip *chip) |
| 3487 | { |
| 3488 | int err; |
| 3489 | u8 temp; |
| 3490 | |
| 3491 | temp = 0xD1; |
| 3492 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3493 | if (err) { |
| 3494 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3495 | return; |
| 3496 | } |
| 3497 | |
| 3498 | temp = 0xD0; |
| 3499 | err = pm8xxx_writeb(chip->dev->parent, CHG_TEST, temp); |
| 3500 | if (err) { |
| 3501 | pr_err("Error %d writing %d to addr %d\n", err, temp, CHG_TEST); |
| 3502 | return; |
| 3503 | } |
| 3504 | } |
| 3505 | |
Abhijeet Dharmapurikar | ed2d87e | 2012-06-26 20:15:36 -0700 | [diff] [blame] | 3506 | #define VREF_BATT_THERM_FORCE_ON BIT(7) |
| 3507 | static void detect_battery_removal(struct pm8921_chg_chip *chip) |
| 3508 | { |
| 3509 | u8 temp; |
| 3510 | |
| 3511 | pm8xxx_readb(chip->dev->parent, CHG_CNTRL, &temp); |
| 3512 | pr_debug("upon restart CHG_CNTRL = 0x%x\n", temp); |
| 3513 | |
| 3514 | if (!(temp & VREF_BATT_THERM_FORCE_ON)) |
| 3515 | /* |
| 3516 | * batt therm force on bit is battery backed and is default 0 |
| 3517 | * The charger sets this bit at init time. If this bit is found |
| 3518 | * 0 that means the battery was removed. Tell the bms about it |
| 3519 | */ |
| 3520 | pm8921_bms_invalidate_shutdown_soc(); |
| 3521 | } |
| 3522 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3523 | #define ENUM_TIMER_STOP_BIT BIT(1) |
| 3524 | #define BOOT_DONE_BIT BIT(6) |
David Keitel | b157ff7 | 2012-06-14 11:22:30 -0700 | [diff] [blame] | 3525 | #define BOOT_TIMER_EN_BIT BIT(1) |
| 3526 | #define BOOT_DONE_MASK (BOOT_DONE_BIT | BOOT_TIMER_EN_BIT) |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3527 | #define CHG_BATFET_ON_BIT BIT(3) |
| 3528 | #define CHG_VCP_EN BIT(0) |
| 3529 | #define CHG_BAT_TEMP_DIS_BIT BIT(2) |
| 3530 | #define SAFE_CURRENT_MA 1500 |
| 3531 | static int __devinit pm8921_chg_hw_init(struct pm8921_chg_chip *chip) |
| 3532 | { |
| 3533 | int rc; |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 3534 | int vdd_safe; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3535 | |
Abhijeet Dharmapurikar | c3695de | 2012-06-22 14:50:23 -0700 | [diff] [blame] | 3536 | /* forcing 19p2mhz before accessing any charger registers */ |
| 3537 | pm8921_chg_force_19p2mhz_clk(chip); |
| 3538 | |
Abhijeet Dharmapurikar | ed2d87e | 2012-06-26 20:15:36 -0700 | [diff] [blame] | 3539 | detect_battery_removal(chip); |
| 3540 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3541 | rc = pm_chg_masked_write(chip, SYS_CONFIG_2, |
David Keitel | b157ff7 | 2012-06-14 11:22:30 -0700 | [diff] [blame] | 3542 | BOOT_DONE_MASK, BOOT_DONE_MASK); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3543 | if (rc) { |
| 3544 | pr_err("Failed to set BOOT_DONE_BIT rc=%d\n", rc); |
| 3545 | return rc; |
| 3546 | } |
| 3547 | |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 3548 | vdd_safe = chip->max_voltage_mv + VDD_MAX_INCREASE_MV; |
| 3549 | |
| 3550 | if (vdd_safe > PM8921_CHG_VDDSAFE_MAX) |
| 3551 | vdd_safe = PM8921_CHG_VDDSAFE_MAX; |
| 3552 | |
| 3553 | rc = pm_chg_vddsafe_set(chip, vdd_safe); |
| 3554 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3555 | if (rc) { |
| 3556 | pr_err("Failed to set safe voltage to %d rc=%d\n", |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3557 | chip->max_voltage_mv, rc); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3558 | return rc; |
| 3559 | } |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3560 | rc = pm_chg_vbatdet_set(chip, |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3561 | chip->max_voltage_mv |
| 3562 | - chip->resume_voltage_delta); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3563 | if (rc) { |
| 3564 | pr_err("Failed to set vbatdet comprator voltage to %d rc=%d\n", |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3565 | chip->max_voltage_mv - chip->resume_voltage_delta, rc); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3566 | return rc; |
| 3567 | } |
| 3568 | |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3569 | rc = pm_chg_vddmax_set(chip, chip->max_voltage_mv); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3570 | if (rc) { |
| 3571 | pr_err("Failed to set max voltage to %d rc=%d\n", |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 3572 | chip->max_voltage_mv, rc); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3573 | return rc; |
| 3574 | } |
| 3575 | rc = pm_chg_ibatsafe_set(chip, SAFE_CURRENT_MA); |
| 3576 | if (rc) { |
| 3577 | pr_err("Failed to set max voltage to %d rc=%d\n", |
| 3578 | SAFE_CURRENT_MA, rc); |
| 3579 | return rc; |
| 3580 | } |
| 3581 | |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 3582 | rc = pm_chg_ibatmax_set(chip, chip->max_bat_chg_current); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3583 | if (rc) { |
| 3584 | pr_err("Failed to set max current to 400 rc=%d\n", rc); |
| 3585 | return rc; |
| 3586 | } |
| 3587 | |
| 3588 | rc = pm_chg_iterm_set(chip, chip->term_current); |
| 3589 | if (rc) { |
| 3590 | pr_err("Failed to set term current to %d rc=%d\n", |
| 3591 | chip->term_current, rc); |
| 3592 | return rc; |
| 3593 | } |
| 3594 | |
| 3595 | /* Disable the ENUM TIMER */ |
| 3596 | rc = pm_chg_masked_write(chip, PBL_ACCESS2, ENUM_TIMER_STOP_BIT, |
| 3597 | ENUM_TIMER_STOP_BIT); |
| 3598 | if (rc) { |
| 3599 | pr_err("Failed to set enum timer stop rc=%d\n", rc); |
| 3600 | return rc; |
| 3601 | } |
| 3602 | |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 3603 | if (chip->safety_time != 0) { |
| 3604 | rc = pm_chg_tchg_max_set(chip, chip->safety_time); |
| 3605 | if (rc) { |
| 3606 | pr_err("Failed to set max time to %d minutes rc=%d\n", |
| 3607 | chip->safety_time, rc); |
| 3608 | return rc; |
| 3609 | } |
| 3610 | } |
| 3611 | |
| 3612 | if (chip->ttrkl_time != 0) { |
Abhijeet Dharmapurikar | e45c3d3 | 2011-10-19 19:46:48 -0700 | [diff] [blame] | 3613 | rc = pm_chg_ttrkl_max_set(chip, chip->ttrkl_time); |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 3614 | if (rc) { |
| 3615 | pr_err("Failed to set trkl time to %d minutes rc=%d\n", |
| 3616 | chip->safety_time, rc); |
| 3617 | return rc; |
| 3618 | } |
| 3619 | } |
| 3620 | |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 3621 | if (chip->vin_min != 0) { |
| 3622 | rc = pm_chg_vinmin_set(chip, chip->vin_min); |
| 3623 | if (rc) { |
| 3624 | pr_err("Failed to set vin min to %d mV rc=%d\n", |
| 3625 | chip->vin_min, rc); |
| 3626 | return rc; |
| 3627 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 3628 | } else { |
| 3629 | chip->vin_min = pm_chg_vinmin_get(chip); |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 3630 | } |
| 3631 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3632 | rc = pm_chg_disable_wd(chip); |
| 3633 | if (rc) { |
| 3634 | pr_err("Failed to disable wd rc=%d\n", rc); |
| 3635 | return rc; |
| 3636 | } |
| 3637 | |
| 3638 | rc = pm_chg_masked_write(chip, CHG_CNTRL_2, |
| 3639 | CHG_BAT_TEMP_DIS_BIT, 0); |
| 3640 | if (rc) { |
| 3641 | pr_err("Failed to enable temp control chg rc=%d\n", rc); |
| 3642 | return rc; |
| 3643 | } |
| 3644 | /* switch to a 3.2Mhz for the buck */ |
| 3645 | rc = pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CLOCK_CTRL, 0x15); |
| 3646 | if (rc) { |
| 3647 | pr_err("Failed to switch buck clk rc=%d\n", rc); |
| 3648 | return rc; |
| 3649 | } |
| 3650 | |
Abhijeet Dharmapurikar | 26cef9c | 2011-08-25 19:16:42 -0700 | [diff] [blame] | 3651 | if (chip->trkl_voltage != 0) { |
| 3652 | rc = pm_chg_vtrkl_low_set(chip, chip->trkl_voltage); |
| 3653 | if (rc) { |
| 3654 | pr_err("Failed to set trkl voltage to %dmv rc=%d\n", |
| 3655 | chip->trkl_voltage, rc); |
| 3656 | return rc; |
| 3657 | } |
| 3658 | } |
| 3659 | |
| 3660 | if (chip->weak_voltage != 0) { |
| 3661 | rc = pm_chg_vweak_set(chip, chip->weak_voltage); |
| 3662 | if (rc) { |
| 3663 | pr_err("Failed to set weak voltage to %dmv rc=%d\n", |
| 3664 | chip->weak_voltage, rc); |
| 3665 | return rc; |
| 3666 | } |
| 3667 | } |
| 3668 | |
| 3669 | if (chip->trkl_current != 0) { |
| 3670 | rc = pm_chg_itrkl_set(chip, chip->trkl_current); |
| 3671 | if (rc) { |
| 3672 | pr_err("Failed to set trkl current to %dmA rc=%d\n", |
| 3673 | chip->trkl_voltage, rc); |
| 3674 | return rc; |
| 3675 | } |
| 3676 | } |
| 3677 | |
| 3678 | if (chip->weak_current != 0) { |
| 3679 | rc = pm_chg_iweak_set(chip, chip->weak_current); |
| 3680 | if (rc) { |
| 3681 | pr_err("Failed to set weak current to %dmA rc=%d\n", |
| 3682 | chip->weak_current, rc); |
| 3683 | return rc; |
| 3684 | } |
| 3685 | } |
| 3686 | |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 3687 | rc = pm_chg_batt_cold_temp_config(chip, chip->cold_thr); |
| 3688 | if (rc) { |
| 3689 | pr_err("Failed to set cold config %d rc=%d\n", |
| 3690 | chip->cold_thr, rc); |
| 3691 | } |
| 3692 | |
| 3693 | rc = pm_chg_batt_hot_temp_config(chip, chip->hot_thr); |
| 3694 | if (rc) { |
| 3695 | pr_err("Failed to set hot config %d rc=%d\n", |
| 3696 | chip->hot_thr, rc); |
| 3697 | } |
| 3698 | |
Jay Chokshi | d674a51 | 2012-03-15 14:06:04 -0700 | [diff] [blame] | 3699 | rc = pm_chg_led_src_config(chip, chip->led_src_config); |
| 3700 | if (rc) { |
| 3701 | pr_err("Failed to set charger LED src config %d rc=%d\n", |
| 3702 | chip->led_src_config, rc); |
| 3703 | } |
| 3704 | |
David Keitel | b51995e | 2011-11-18 17:03:31 -0800 | [diff] [blame] | 3705 | /* Workarounds for die 3.0 */ |
David Keitel | 0a6ff48 | 2012-08-10 17:14:50 -0700 | [diff] [blame] | 3706 | if (pm8xxx_get_revision(chip->dev->parent) == PM8XXX_REVISION_8921_3p0 |
| 3707 | && pm8xxx_get_version(chip->dev->parent) == PM8XXX_VERSION_8921) |
David Keitel | b51995e | 2011-11-18 17:03:31 -0800 | [diff] [blame] | 3708 | pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, 0xAC); |
| 3709 | |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 3710 | /* Enable isub_fine resolution AICL for PM8917 */ |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 3711 | if (pm8xxx_get_version(chip->dev->parent) == PM8XXX_VERSION_8917) { |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 3712 | chip->iusb_fine_res = true; |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 3713 | if (chip->uvd_voltage_mv) |
| 3714 | rc = pm_chg_uvd_threshold_set(chip, |
| 3715 | chip->uvd_voltage_mv); |
| 3716 | if (rc) { |
| 3717 | pr_err("Failed to set UVD threshold %drc=%d\n", |
| 3718 | chip->uvd_voltage_mv, rc); |
| 3719 | return rc; |
| 3720 | } |
| 3721 | } |
David Keitel | 38bdd4f | 2012-04-19 15:39:13 -0700 | [diff] [blame] | 3722 | |
David Keitel | b51995e | 2011-11-18 17:03:31 -0800 | [diff] [blame] | 3723 | pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, 0xD9); |
| 3724 | |
David Keitel | a3c0d82 | 2011-11-03 14:18:52 -0700 | [diff] [blame] | 3725 | /* Disable EOC FSM processing */ |
| 3726 | pm8xxx_writeb(chip->dev->parent, CHG_BUCK_CTRL_TEST3, 0x91); |
| 3727 | |
Abhijeet Dharmapurikar | ccac695 | 2012-01-18 16:35:34 -0800 | [diff] [blame] | 3728 | rc = pm_chg_masked_write(chip, CHG_CNTRL, VREF_BATT_THERM_FORCE_ON, |
| 3729 | VREF_BATT_THERM_FORCE_ON); |
| 3730 | if (rc) |
| 3731 | pr_err("Failed to Force Vref therm rc=%d\n", rc); |
| 3732 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3733 | rc = pm_chg_charge_dis(chip, charging_disabled); |
| 3734 | if (rc) { |
| 3735 | pr_err("Failed to disable CHG_CHARGE_DIS bit rc=%d\n", rc); |
| 3736 | return rc; |
| 3737 | } |
| 3738 | |
| 3739 | rc = pm_chg_auto_enable(chip, !charging_disabled); |
| 3740 | if (rc) { |
| 3741 | pr_err("Failed to enable charging rc=%d\n", rc); |
| 3742 | return rc; |
| 3743 | } |
| 3744 | |
| 3745 | return 0; |
| 3746 | } |
| 3747 | |
| 3748 | static int get_rt_status(void *data, u64 * val) |
| 3749 | { |
| 3750 | int i = (int)data; |
| 3751 | int ret; |
| 3752 | |
| 3753 | /* global irq number is passed in via data */ |
| 3754 | ret = pm_chg_get_rt_status(the_chip, i); |
| 3755 | *val = ret; |
| 3756 | return 0; |
| 3757 | } |
| 3758 | DEFINE_SIMPLE_ATTRIBUTE(rt_fops, get_rt_status, NULL, "%llu\n"); |
| 3759 | |
| 3760 | static int get_fsm_status(void *data, u64 * val) |
| 3761 | { |
| 3762 | u8 temp; |
| 3763 | |
| 3764 | temp = pm_chg_get_fsm_state(the_chip); |
| 3765 | *val = temp; |
| 3766 | return 0; |
| 3767 | } |
| 3768 | DEFINE_SIMPLE_ATTRIBUTE(fsm_fops, get_fsm_status, NULL, "%llu\n"); |
| 3769 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3770 | static int get_reg_loop(void *data, u64 * val) |
| 3771 | { |
| 3772 | u8 temp; |
| 3773 | |
| 3774 | if (!the_chip) { |
| 3775 | pr_err("%s called before init\n", __func__); |
| 3776 | return -EINVAL; |
| 3777 | } |
| 3778 | temp = pm_chg_get_regulation_loop(the_chip); |
| 3779 | *val = temp; |
| 3780 | return 0; |
| 3781 | } |
| 3782 | DEFINE_SIMPLE_ATTRIBUTE(reg_loop_fops, get_reg_loop, NULL, "0x%02llx\n"); |
| 3783 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3784 | static int get_reg(void *data, u64 * val) |
| 3785 | { |
| 3786 | int addr = (int)data; |
| 3787 | int ret; |
| 3788 | u8 temp; |
| 3789 | |
| 3790 | ret = pm8xxx_readb(the_chip->dev->parent, addr, &temp); |
| 3791 | if (ret) { |
| 3792 | pr_err("pm8xxx_readb to %x value =%d errored = %d\n", |
| 3793 | addr, temp, ret); |
| 3794 | return -EAGAIN; |
| 3795 | } |
| 3796 | *val = temp; |
| 3797 | return 0; |
| 3798 | } |
| 3799 | |
| 3800 | static int set_reg(void *data, u64 val) |
| 3801 | { |
| 3802 | int addr = (int)data; |
| 3803 | int ret; |
| 3804 | u8 temp; |
| 3805 | |
| 3806 | temp = (u8) val; |
| 3807 | ret = pm8xxx_writeb(the_chip->dev->parent, addr, temp); |
| 3808 | if (ret) { |
| 3809 | pr_err("pm8xxx_writeb to %x value =%d errored = %d\n", |
| 3810 | addr, temp, ret); |
| 3811 | return -EAGAIN; |
| 3812 | } |
| 3813 | return 0; |
| 3814 | } |
| 3815 | DEFINE_SIMPLE_ATTRIBUTE(reg_fops, get_reg, set_reg, "0x%02llx\n"); |
| 3816 | |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3817 | enum { |
| 3818 | BAT_WARM_ZONE, |
| 3819 | BAT_COOL_ZONE, |
| 3820 | }; |
| 3821 | static int get_warm_cool(void *data, u64 * val) |
| 3822 | { |
| 3823 | if (!the_chip) { |
| 3824 | pr_err("%s called before init\n", __func__); |
| 3825 | return -EINVAL; |
| 3826 | } |
| 3827 | if ((int)data == BAT_WARM_ZONE) |
| 3828 | *val = the_chip->is_bat_warm; |
| 3829 | if ((int)data == BAT_COOL_ZONE) |
| 3830 | *val = the_chip->is_bat_cool; |
| 3831 | return 0; |
| 3832 | } |
| 3833 | DEFINE_SIMPLE_ATTRIBUTE(warm_cool_fops, get_warm_cool, NULL, "0x%lld\n"); |
| 3834 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3835 | static void create_debugfs_entries(struct pm8921_chg_chip *chip) |
| 3836 | { |
| 3837 | int i; |
| 3838 | |
| 3839 | chip->dent = debugfs_create_dir("pm8921_chg", NULL); |
| 3840 | |
| 3841 | if (IS_ERR(chip->dent)) { |
| 3842 | pr_err("pmic charger couldnt create debugfs dir\n"); |
| 3843 | return; |
| 3844 | } |
| 3845 | |
| 3846 | debugfs_create_file("CHG_CNTRL", 0644, chip->dent, |
| 3847 | (void *)CHG_CNTRL, ®_fops); |
| 3848 | debugfs_create_file("CHG_CNTRL_2", 0644, chip->dent, |
| 3849 | (void *)CHG_CNTRL_2, ®_fops); |
| 3850 | debugfs_create_file("CHG_CNTRL_3", 0644, chip->dent, |
| 3851 | (void *)CHG_CNTRL_3, ®_fops); |
| 3852 | debugfs_create_file("PBL_ACCESS1", 0644, chip->dent, |
| 3853 | (void *)PBL_ACCESS1, ®_fops); |
| 3854 | debugfs_create_file("PBL_ACCESS2", 0644, chip->dent, |
| 3855 | (void *)PBL_ACCESS2, ®_fops); |
| 3856 | debugfs_create_file("SYS_CONFIG_1", 0644, chip->dent, |
| 3857 | (void *)SYS_CONFIG_1, ®_fops); |
| 3858 | debugfs_create_file("SYS_CONFIG_2", 0644, chip->dent, |
| 3859 | (void *)SYS_CONFIG_2, ®_fops); |
| 3860 | debugfs_create_file("CHG_VDD_MAX", 0644, chip->dent, |
| 3861 | (void *)CHG_VDD_MAX, ®_fops); |
| 3862 | debugfs_create_file("CHG_VDD_SAFE", 0644, chip->dent, |
| 3863 | (void *)CHG_VDD_SAFE, ®_fops); |
| 3864 | debugfs_create_file("CHG_VBAT_DET", 0644, chip->dent, |
| 3865 | (void *)CHG_VBAT_DET, ®_fops); |
| 3866 | debugfs_create_file("CHG_IBAT_MAX", 0644, chip->dent, |
| 3867 | (void *)CHG_IBAT_MAX, ®_fops); |
| 3868 | debugfs_create_file("CHG_IBAT_SAFE", 0644, chip->dent, |
| 3869 | (void *)CHG_IBAT_SAFE, ®_fops); |
| 3870 | debugfs_create_file("CHG_VIN_MIN", 0644, chip->dent, |
| 3871 | (void *)CHG_VIN_MIN, ®_fops); |
| 3872 | debugfs_create_file("CHG_VTRICKLE", 0644, chip->dent, |
| 3873 | (void *)CHG_VTRICKLE, ®_fops); |
| 3874 | debugfs_create_file("CHG_ITRICKLE", 0644, chip->dent, |
| 3875 | (void *)CHG_ITRICKLE, ®_fops); |
| 3876 | debugfs_create_file("CHG_ITERM", 0644, chip->dent, |
| 3877 | (void *)CHG_ITERM, ®_fops); |
| 3878 | debugfs_create_file("CHG_TCHG_MAX", 0644, chip->dent, |
| 3879 | (void *)CHG_TCHG_MAX, ®_fops); |
| 3880 | debugfs_create_file("CHG_TWDOG", 0644, chip->dent, |
| 3881 | (void *)CHG_TWDOG, ®_fops); |
| 3882 | debugfs_create_file("CHG_TEMP_THRESH", 0644, chip->dent, |
| 3883 | (void *)CHG_TEMP_THRESH, ®_fops); |
| 3884 | debugfs_create_file("CHG_COMP_OVR", 0644, chip->dent, |
| 3885 | (void *)CHG_COMP_OVR, ®_fops); |
| 3886 | debugfs_create_file("CHG_BUCK_CTRL_TEST1", 0644, chip->dent, |
| 3887 | (void *)CHG_BUCK_CTRL_TEST1, ®_fops); |
| 3888 | debugfs_create_file("CHG_BUCK_CTRL_TEST2", 0644, chip->dent, |
| 3889 | (void *)CHG_BUCK_CTRL_TEST2, ®_fops); |
| 3890 | debugfs_create_file("CHG_BUCK_CTRL_TEST3", 0644, chip->dent, |
| 3891 | (void *)CHG_BUCK_CTRL_TEST3, ®_fops); |
| 3892 | debugfs_create_file("CHG_TEST", 0644, chip->dent, |
| 3893 | (void *)CHG_TEST, ®_fops); |
| 3894 | |
| 3895 | debugfs_create_file("FSM_STATE", 0644, chip->dent, NULL, |
| 3896 | &fsm_fops); |
| 3897 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 3898 | debugfs_create_file("REGULATION_LOOP_CONTROL", 0644, chip->dent, NULL, |
| 3899 | ®_loop_fops); |
| 3900 | |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 3901 | debugfs_create_file("BAT_WARM_ZONE", 0644, chip->dent, |
| 3902 | (void *)BAT_WARM_ZONE, &warm_cool_fops); |
| 3903 | debugfs_create_file("BAT_COOL_ZONE", 0644, chip->dent, |
| 3904 | (void *)BAT_COOL_ZONE, &warm_cool_fops); |
| 3905 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3906 | for (i = 0; i < ARRAY_SIZE(chg_irq_data); i++) { |
| 3907 | if (chip->pmic_chg_irq[chg_irq_data[i].irq_id]) |
| 3908 | debugfs_create_file(chg_irq_data[i].name, 0444, |
| 3909 | chip->dent, |
| 3910 | (void *)chg_irq_data[i].irq_id, |
| 3911 | &rt_fops); |
| 3912 | } |
| 3913 | } |
| 3914 | |
Abhijeet Dharmapurikar | ccac695 | 2012-01-18 16:35:34 -0800 | [diff] [blame] | 3915 | static int pm8921_charger_suspend_noirq(struct device *dev) |
| 3916 | { |
| 3917 | int rc; |
| 3918 | struct pm8921_chg_chip *chip = dev_get_drvdata(dev); |
| 3919 | |
| 3920 | rc = pm_chg_masked_write(chip, CHG_CNTRL, VREF_BATT_THERM_FORCE_ON, 0); |
| 3921 | if (rc) |
| 3922 | pr_err("Failed to Force Vref therm off rc=%d\n", rc); |
| 3923 | pm8921_chg_set_hw_clk_switching(chip); |
| 3924 | return 0; |
| 3925 | } |
| 3926 | |
| 3927 | static int pm8921_charger_resume_noirq(struct device *dev) |
| 3928 | { |
| 3929 | int rc; |
| 3930 | struct pm8921_chg_chip *chip = dev_get_drvdata(dev); |
| 3931 | |
| 3932 | pm8921_chg_force_19p2mhz_clk(chip); |
| 3933 | |
| 3934 | rc = pm_chg_masked_write(chip, CHG_CNTRL, VREF_BATT_THERM_FORCE_ON, |
| 3935 | VREF_BATT_THERM_FORCE_ON); |
| 3936 | if (rc) |
| 3937 | pr_err("Failed to Force Vref therm on rc=%d\n", rc); |
| 3938 | return 0; |
| 3939 | } |
| 3940 | |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 3941 | static int pm8921_charger_resume(struct device *dev) |
| 3942 | { |
| 3943 | int rc; |
| 3944 | struct pm8921_chg_chip *chip = dev_get_drvdata(dev); |
| 3945 | |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 3946 | if (!(chip->cool_temp_dc == INT_MIN && chip->warm_temp_dc == INT_MIN) |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 3947 | && !(chip->keep_btm_on_suspend)) { |
| 3948 | rc = pm8xxx_adc_btm_configure(&btm_config); |
| 3949 | if (rc) |
| 3950 | pr_err("couldn't reconfigure btm rc=%d\n", rc); |
| 3951 | |
| 3952 | rc = pm8xxx_adc_btm_start(); |
| 3953 | if (rc) |
| 3954 | pr_err("couldn't restart btm rc=%d\n", rc); |
| 3955 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 3956 | if (pm8921_chg_is_enabled(chip, LOOP_CHANGE_IRQ)) { |
| 3957 | disable_irq_wake(chip->pmic_chg_irq[LOOP_CHANGE_IRQ]); |
| 3958 | pm8921_chg_disable_irq(chip, LOOP_CHANGE_IRQ); |
| 3959 | } |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 3960 | return 0; |
| 3961 | } |
| 3962 | |
| 3963 | static int pm8921_charger_suspend(struct device *dev) |
| 3964 | { |
| 3965 | int rc; |
| 3966 | struct pm8921_chg_chip *chip = dev_get_drvdata(dev); |
| 3967 | |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 3968 | if (!(chip->cool_temp_dc == INT_MIN && chip->warm_temp_dc == INT_MIN) |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 3969 | && !(chip->keep_btm_on_suspend)) { |
| 3970 | rc = pm8xxx_adc_btm_end(); |
| 3971 | if (rc) |
| 3972 | pr_err("Failed to disable BTM on suspend rc=%d\n", rc); |
| 3973 | } |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 3974 | |
| 3975 | if (is_usb_chg_plugged_in(chip)) { |
| 3976 | pm8921_chg_enable_irq(chip, LOOP_CHANGE_IRQ); |
| 3977 | enable_irq_wake(chip->pmic_chg_irq[LOOP_CHANGE_IRQ]); |
| 3978 | } |
Abhijeet Dharmapurikar | ccac695 | 2012-01-18 16:35:34 -0800 | [diff] [blame] | 3979 | |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 3980 | return 0; |
| 3981 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 3982 | static int __devinit pm8921_charger_probe(struct platform_device *pdev) |
| 3983 | { |
| 3984 | int rc = 0; |
| 3985 | struct pm8921_chg_chip *chip; |
| 3986 | const struct pm8921_charger_platform_data *pdata |
| 3987 | = pdev->dev.platform_data; |
| 3988 | |
| 3989 | if (!pdata) { |
| 3990 | pr_err("missing platform data\n"); |
| 3991 | return -EINVAL; |
| 3992 | } |
| 3993 | |
| 3994 | chip = kzalloc(sizeof(struct pm8921_chg_chip), |
| 3995 | GFP_KERNEL); |
| 3996 | if (!chip) { |
| 3997 | pr_err("Cannot allocate pm_chg_chip\n"); |
| 3998 | return -ENOMEM; |
| 3999 | } |
| 4000 | |
| 4001 | chip->dev = &pdev->dev; |
| 4002 | chip->safety_time = pdata->safety_time; |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 4003 | chip->ttrkl_time = pdata->ttrkl_time; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4004 | chip->update_time = pdata->update_time; |
Siddartha Mohanadoss | 37e6fc0 | 2011-11-16 16:57:03 -0800 | [diff] [blame] | 4005 | chip->max_voltage_mv = pdata->max_voltage; |
| 4006 | chip->min_voltage_mv = pdata->min_voltage; |
David Keitel | 0789fc6 | 2012-06-07 17:43:27 -0700 | [diff] [blame] | 4007 | chip->uvd_voltage_mv = pdata->uvd_thresh_voltage; |
Abhijeet Dharmapurikar | d55878e | 2011-10-27 10:22:24 -0700 | [diff] [blame] | 4008 | chip->resume_voltage_delta = pdata->resume_voltage_delta; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4009 | chip->term_current = pdata->term_current; |
| 4010 | chip->vbat_channel = pdata->charger_cdata.vbat_channel; |
Abhijeet Dharmapurikar | b24e2c3 | 2011-08-17 17:13:09 -0700 | [diff] [blame] | 4011 | chip->batt_temp_channel = pdata->charger_cdata.batt_temp_channel; |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 4012 | chip->batt_id_channel = pdata->charger_cdata.batt_id_channel; |
| 4013 | chip->batt_id_min = pdata->batt_id_min; |
| 4014 | chip->batt_id_max = pdata->batt_id_max; |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 4015 | if (pdata->cool_temp != INT_MIN) |
| 4016 | chip->cool_temp_dc = pdata->cool_temp * 10; |
| 4017 | else |
| 4018 | chip->cool_temp_dc = INT_MIN; |
| 4019 | |
| 4020 | if (pdata->warm_temp != INT_MIN) |
| 4021 | chip->warm_temp_dc = pdata->warm_temp * 10; |
| 4022 | else |
| 4023 | chip->warm_temp_dc = INT_MIN; |
| 4024 | |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4025 | chip->temp_check_period = pdata->temp_check_period; |
David Keitel | 5bed4f1 | 2012-05-25 18:04:14 -0700 | [diff] [blame] | 4026 | chip->dc_unplug_check = pdata->dc_unplug_check; |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4027 | chip->max_bat_chg_current = pdata->max_bat_chg_current; |
| 4028 | chip->cool_bat_chg_current = pdata->cool_bat_chg_current; |
| 4029 | chip->warm_bat_chg_current = pdata->warm_bat_chg_current; |
| 4030 | chip->cool_bat_voltage = pdata->cool_bat_voltage; |
| 4031 | chip->warm_bat_voltage = pdata->warm_bat_voltage; |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 4032 | chip->keep_btm_on_suspend = pdata->keep_btm_on_suspend; |
Abhijeet Dharmapurikar | 26cef9c | 2011-08-25 19:16:42 -0700 | [diff] [blame] | 4033 | chip->trkl_voltage = pdata->trkl_voltage; |
| 4034 | chip->weak_voltage = pdata->weak_voltage; |
| 4035 | chip->trkl_current = pdata->trkl_current; |
| 4036 | chip->weak_current = pdata->weak_current; |
Abhijeet Dharmapurikar | 6fe50a8 | 2011-08-25 21:33:14 -0700 | [diff] [blame] | 4037 | chip->vin_min = pdata->vin_min; |
Abhijeet Dharmapurikar | ad74236 | 2011-08-29 19:50:02 -0700 | [diff] [blame] | 4038 | chip->thermal_mitigation = pdata->thermal_mitigation; |
| 4039 | chip->thermal_levels = pdata->thermal_levels; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4040 | |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 4041 | chip->cold_thr = pdata->cold_thr; |
| 4042 | chip->hot_thr = pdata->hot_thr; |
Abhijeet Dharmapurikar | 40491ce | 2011-11-07 11:38:54 -0800 | [diff] [blame] | 4043 | chip->rconn_mohm = pdata->rconn_mohm; |
Jay Chokshi | d674a51 | 2012-03-15 14:06:04 -0700 | [diff] [blame] | 4044 | chip->led_src_config = pdata->led_src_config; |
David Keitel | a3cf943 | 2012-08-24 15:11:23 -0700 | [diff] [blame] | 4045 | chip->has_dc_supply = pdata->has_dc_supply; |
Abhijeet Dharmapurikar | 0f02423 | 2011-10-03 12:00:15 -0700 | [diff] [blame] | 4046 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4047 | rc = pm8921_chg_hw_init(chip); |
| 4048 | if (rc) { |
| 4049 | pr_err("couldn't init hardware rc=%d\n", rc); |
| 4050 | goto free_chip; |
| 4051 | } |
| 4052 | |
| 4053 | chip->usb_psy.name = "usb", |
| 4054 | chip->usb_psy.type = POWER_SUPPLY_TYPE_USB, |
| 4055 | chip->usb_psy.supplied_to = pm_power_supplied_to, |
| 4056 | chip->usb_psy.num_supplicants = ARRAY_SIZE(pm_power_supplied_to), |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 4057 | chip->usb_psy.properties = pm_power_props_usb, |
| 4058 | chip->usb_psy.num_properties = ARRAY_SIZE(pm_power_props_usb), |
| 4059 | chip->usb_psy.get_property = pm_power_get_property_usb, |
Abhijeet Dharmapurikar | 5e96aaa | 2012-06-26 11:21:03 -0700 | [diff] [blame] | 4060 | chip->usb_psy.set_property = pm_power_set_property_usb, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4061 | |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 4062 | chip->dc_psy.name = "pm8921-dc", |
| 4063 | chip->dc_psy.type = POWER_SUPPLY_TYPE_MAINS, |
| 4064 | chip->dc_psy.supplied_to = pm_power_supplied_to, |
| 4065 | chip->dc_psy.num_supplicants = ARRAY_SIZE(pm_power_supplied_to), |
Abhijeet Dharmapurikar | 9da392d | 2012-02-22 18:59:57 -0800 | [diff] [blame] | 4066 | chip->dc_psy.properties = pm_power_props_mains, |
| 4067 | chip->dc_psy.num_properties = ARRAY_SIZE(pm_power_props_mains), |
| 4068 | chip->dc_psy.get_property = pm_power_get_property_mains, |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 4069 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4070 | chip->batt_psy.name = "battery", |
| 4071 | chip->batt_psy.type = POWER_SUPPLY_TYPE_BATTERY, |
| 4072 | chip->batt_psy.properties = msm_batt_power_props, |
| 4073 | chip->batt_psy.num_properties = ARRAY_SIZE(msm_batt_power_props), |
| 4074 | chip->batt_psy.get_property = pm_batt_power_get_property, |
David Keitel | 88e1b57 | 2012-01-11 11:57:14 -0800 | [diff] [blame] | 4075 | chip->batt_psy.external_power_changed = pm_batt_external_power_changed, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4076 | rc = power_supply_register(chip->dev, &chip->usb_psy); |
| 4077 | if (rc < 0) { |
| 4078 | pr_err("power_supply_register usb failed rc = %d\n", rc); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4079 | goto free_chip; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4080 | } |
| 4081 | |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 4082 | rc = power_supply_register(chip->dev, &chip->dc_psy); |
| 4083 | if (rc < 0) { |
| 4084 | pr_err("power_supply_register usb failed rc = %d\n", rc); |
| 4085 | goto unregister_usb; |
| 4086 | } |
| 4087 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4088 | rc = power_supply_register(chip->dev, &chip->batt_psy); |
| 4089 | if (rc < 0) { |
| 4090 | pr_err("power_supply_register batt failed rc = %d\n", rc); |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 4091 | goto unregister_dc; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4092 | } |
| 4093 | |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 4094 | platform_set_drvdata(pdev, chip); |
| 4095 | the_chip = chip; |
| 4096 | |
| 4097 | wake_lock_init(&chip->eoc_wake_lock, WAKE_LOCK_SUSPEND, "pm8921_eoc"); |
Amir Samuelov | d31ef50 | 2011-10-26 14:41:36 +0200 | [diff] [blame] | 4098 | INIT_DELAYED_WORK(&chip->eoc_work, eoc_worker); |
David Keitel | acf57c8 | 2012-03-07 18:48:50 -0800 | [diff] [blame] | 4099 | INIT_DELAYED_WORK(&chip->vin_collapse_check_work, |
| 4100 | vin_collapse_check_worker); |
Abhijeet Dharmapurikar | c459955 | 2011-12-22 17:27:56 -0800 | [diff] [blame] | 4101 | INIT_DELAYED_WORK(&chip->unplug_check_work, unplug_check_worker); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 4102 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4103 | rc = request_irqs(chip, pdev); |
| 4104 | if (rc) { |
| 4105 | pr_err("couldn't register interrupts rc=%d\n", rc); |
| 4106 | goto unregister_batt; |
| 4107 | } |
| 4108 | |
Abhijeet Dharmapurikar | e27d809 | 2011-08-12 17:16:29 -0700 | [diff] [blame] | 4109 | enable_irq_wake(chip->pmic_chg_irq[USBIN_VALID_IRQ]); |
| 4110 | enable_irq_wake(chip->pmic_chg_irq[USBIN_OV_IRQ]); |
| 4111 | enable_irq_wake(chip->pmic_chg_irq[USBIN_UV_IRQ]); |
David Keitel | 64dd3f5 | 2011-11-10 14:19:38 -0800 | [diff] [blame] | 4112 | enable_irq_wake(chip->pmic_chg_irq[BAT_TEMP_OK_IRQ]); |
| 4113 | enable_irq_wake(chip->pmic_chg_irq[VBATDET_LOW_IRQ]); |
Abhijeet Dharmapurikar | 28fd0c6 | 2012-01-27 13:28:29 -0800 | [diff] [blame] | 4114 | enable_irq_wake(chip->pmic_chg_irq[FASTCHG_IRQ]); |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4115 | /* |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 4116 | * if both the cool_temp_dc and warm_temp_dc are invalid device doesnt |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4117 | * care for jeita compliance |
| 4118 | */ |
Abhijeet Dharmapurikar | bc38f63 | 2012-01-10 09:30:11 -0800 | [diff] [blame] | 4119 | if (!(chip->cool_temp_dc == INT_MIN && chip->warm_temp_dc == INT_MIN)) { |
Abhijeet Dharmapurikar | 86eea30 | 2011-08-15 13:55:18 -0700 | [diff] [blame] | 4120 | rc = configure_btm(chip); |
| 4121 | if (rc) { |
| 4122 | pr_err("couldn't register with btm rc=%d\n", rc); |
| 4123 | goto free_irq; |
| 4124 | } |
| 4125 | } |
Abhijeet Dharmapurikar | e27d809 | 2011-08-12 17:16:29 -0700 | [diff] [blame] | 4126 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4127 | create_debugfs_entries(chip); |
| 4128 | |
| 4129 | INIT_WORK(&chip->bms_notify.work, bms_notify); |
Abhijeet Dharmapurikar | be6bd8c | 2011-08-19 12:15:06 -0700 | [diff] [blame] | 4130 | INIT_WORK(&chip->battery_id_valid_work, battery_id_valid); |
Abhijeet Dharmapurikar | 98738c5 | 2011-09-20 17:04:48 -0700 | [diff] [blame] | 4131 | |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4132 | /* determine what state the charger is in */ |
| 4133 | determine_initial_state(chip); |
| 4134 | |
Abhijeet Dharmapurikar | 33fe6fb | 2011-09-14 16:03:11 -0700 | [diff] [blame] | 4135 | if (chip->update_time) { |
| 4136 | INIT_DELAYED_WORK(&chip->update_heartbeat_work, |
| 4137 | update_heartbeat); |
| 4138 | schedule_delayed_work(&chip->update_heartbeat_work, |
| 4139 | round_jiffies_relative(msecs_to_jiffies |
| 4140 | (chip->update_time))); |
| 4141 | } |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4142 | return 0; |
| 4143 | |
| 4144 | free_irq: |
| 4145 | free_irqs(chip); |
| 4146 | unregister_batt: |
| 4147 | power_supply_unregister(&chip->batt_psy); |
David Keitel | 6ed71a5 | 2012-01-30 12:42:18 -0800 | [diff] [blame] | 4148 | unregister_dc: |
| 4149 | power_supply_unregister(&chip->dc_psy); |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4150 | unregister_usb: |
| 4151 | power_supply_unregister(&chip->usb_psy); |
| 4152 | free_chip: |
| 4153 | kfree(chip); |
| 4154 | return rc; |
| 4155 | } |
| 4156 | |
| 4157 | static int __devexit pm8921_charger_remove(struct platform_device *pdev) |
| 4158 | { |
| 4159 | struct pm8921_chg_chip *chip = platform_get_drvdata(pdev); |
| 4160 | |
| 4161 | free_irqs(chip); |
| 4162 | platform_set_drvdata(pdev, NULL); |
| 4163 | the_chip = NULL; |
| 4164 | kfree(chip); |
| 4165 | return 0; |
| 4166 | } |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 4167 | static const struct dev_pm_ops pm8921_pm_ops = { |
| 4168 | .suspend = pm8921_charger_suspend, |
Abhijeet Dharmapurikar | ccac695 | 2012-01-18 16:35:34 -0800 | [diff] [blame] | 4169 | .suspend_noirq = pm8921_charger_suspend_noirq, |
| 4170 | .resume_noirq = pm8921_charger_resume_noirq, |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 4171 | .resume = pm8921_charger_resume, |
| 4172 | }; |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4173 | static struct platform_driver pm8921_charger_driver = { |
David Keitel | f222602 | 2011-12-13 15:55:50 -0800 | [diff] [blame] | 4174 | .probe = pm8921_charger_probe, |
| 4175 | .remove = __devexit_p(pm8921_charger_remove), |
| 4176 | .driver = { |
| 4177 | .name = PM8921_CHARGER_DEV_NAME, |
| 4178 | .owner = THIS_MODULE, |
| 4179 | .pm = &pm8921_pm_ops, |
Bryan Huntsman | 3f2bc4d | 2011-08-16 17:27:22 -0700 | [diff] [blame] | 4180 | }, |
| 4181 | }; |
| 4182 | |
| 4183 | static int __init pm8921_charger_init(void) |
| 4184 | { |
| 4185 | return platform_driver_register(&pm8921_charger_driver); |
| 4186 | } |
| 4187 | |
| 4188 | static void __exit pm8921_charger_exit(void) |
| 4189 | { |
| 4190 | platform_driver_unregister(&pm8921_charger_driver); |
| 4191 | } |
| 4192 | |
| 4193 | late_initcall(pm8921_charger_init); |
| 4194 | module_exit(pm8921_charger_exit); |
| 4195 | |
| 4196 | MODULE_LICENSE("GPL v2"); |
| 4197 | MODULE_DESCRIPTION("PMIC8921 charger/battery driver"); |
| 4198 | MODULE_VERSION("1.0"); |
| 4199 | MODULE_ALIAS("platform:" PM8921_CHARGER_DEV_NAME); |