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