?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/intel_rdt: Fix incorrect returned value when creating rdgroup sub-directory in...
[cris-mirror.git] / drivers / power / supply / ab8500_fg.c
blobc569f82a007182b25531213e6d8cb84094e9a53e
1 /*
2 * Copyright (C) ST-Ericsson AB 2012
3 *
4 * Main and Back-up battery management driver.
5 *
6 * Note: Backup battery management is required in case of Li-Ion battery and not
7 * for capacitive battery. HREF boards have capacitive battery and hence backup
8 * battery management is not used and the supported code is available in this
9 * driver.
10 *
11 * License Terms: GNU General Public License v2
12 * Author:
13 * Johan Palsson <johan.palsson@stericsson.com>
14 * Karl Komierowski <karl.komierowski@stericsson.com>
15 * Arun R Murthy <arun.murthy@stericsson.com>
16 */
17
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/interrupt.h>
22 #include <linux/platform_device.h>
23 #include <linux/power_supply.h>
24 #include <linux/kobject.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h>
27 #include <linux/time.h>
28 #include <linux/time64.h>
29 #include <linux/of.h>
30 #include <linux/completion.h>
31 #include <linux/mfd/core.h>
32 #include <linux/mfd/abx500.h>
33 #include <linux/mfd/abx500/ab8500.h>
34 #include <linux/mfd/abx500/ab8500-bm.h>
35 #include <linux/mfd/abx500/ab8500-gpadc.h>
36 #include <linux/kernel.h>
37
38 #define MILLI_TO_MICRO 1000
39 #define FG_LSB_IN_MA 1627
40 #define QLSB_NANO_AMP_HOURS_X10 1071
41 #define INS_CURR_TIMEOUT (3 * HZ)
42
43 #define SEC_TO_SAMPLE(S) (S * 4)
44
45 #define NBR_AVG_SAMPLES 20
46
47 #define LOW_BAT_CHECK_INTERVAL (HZ / 16) /* 62.5 ms */
48
49 #define VALID_CAPACITY_SEC (45 * 60) /* 45 minutes */
50 #define BATT_OK_MIN 2360 /* mV */
51 #define BATT_OK_INCREMENT 50 /* mV */
52 #define BATT_OK_MAX_NR_INCREMENTS 0xE
53
54 /* FG constants */
55 #define BATT_OVV 0x01
56
57 #define interpolate(x, x1, y1, x2, y2) \
58 ((y1) + ((((y2) - (y1)) * ((x) - (x1))) / ((x2) - (x1))));
59
60 /**
61 * struct ab8500_fg_interrupts - ab8500 fg interupts
62 * @name: name of the interrupt
63 * @isr function pointer to the isr
64 */
65 struct ab8500_fg_interrupts {
66 char *name;
67 irqreturn_t (*isr)(int irq, void *data);
68 };
69
70 enum ab8500_fg_discharge_state {
71 AB8500_FG_DISCHARGE_INIT,
72 AB8500_FG_DISCHARGE_INITMEASURING,
73 AB8500_FG_DISCHARGE_INIT_RECOVERY,
74 AB8500_FG_DISCHARGE_RECOVERY,
75 AB8500_FG_DISCHARGE_READOUT_INIT,
76 AB8500_FG_DISCHARGE_READOUT,
77 AB8500_FG_DISCHARGE_WAKEUP,
78 };
79
80 static char *discharge_state[] = {
81 "DISCHARGE_INIT",
82 "DISCHARGE_INITMEASURING",
83 "DISCHARGE_INIT_RECOVERY",
84 "DISCHARGE_RECOVERY",
85 "DISCHARGE_READOUT_INIT",
86 "DISCHARGE_READOUT",
87 "DISCHARGE_WAKEUP",
88 };
89
90 enum ab8500_fg_charge_state {
91 AB8500_FG_CHARGE_INIT,
92 AB8500_FG_CHARGE_READOUT,
93 };
94
95 static char *charge_state[] = {
96 "CHARGE_INIT",
97 "CHARGE_READOUT",
98 };
99
100 enum ab8500_fg_calibration_state {
101 AB8500_FG_CALIB_INIT,
102 AB8500_FG_CALIB_WAIT,
103 AB8500_FG_CALIB_END,
104 };
105
106 struct ab8500_fg_avg_cap {
107 int avg;
108 int samples[NBR_AVG_SAMPLES];
109 time64_t time_stamps[NBR_AVG_SAMPLES];
110 int pos;
111 int nbr_samples;
112 int sum;
113 };
114
115 struct ab8500_fg_cap_scaling {
116 bool enable;
117 int cap_to_scale[2];
118 int disable_cap_level;
119 int scaled_cap;
120 };
121
122 struct ab8500_fg_battery_capacity {
123 int max_mah_design;
124 int max_mah;
125 int mah;
126 int permille;
127 int level;
128 int prev_mah;
129 int prev_percent;
130 int prev_level;
131 int user_mah;
132 struct ab8500_fg_cap_scaling cap_scale;
133 };
134
135 struct ab8500_fg_flags {
136 bool fg_enabled;
137 bool conv_done;
138 bool charging;
139 bool fully_charged;
140 bool force_full;
141 bool low_bat_delay;
142 bool low_bat;
143 bool bat_ovv;
144 bool batt_unknown;
145 bool calibrate;
146 bool user_cap;
147 bool batt_id_received;
148 };
149
150 struct inst_curr_result_list {
151 struct list_head list;
152 int *result;
153 };
154
155 /**
156 * struct ab8500_fg - ab8500 FG device information
157 * @dev: Pointer to the structure device
158 * @node: a list of AB8500 FGs, hence prepared for reentrance
159 * @irq holds the CCEOC interrupt number
160 * @vbat: Battery voltage in mV
161 * @vbat_nom: Nominal battery voltage in mV
162 * @inst_curr: Instantenous battery current in mA
163 * @avg_curr: Average battery current in mA
164 * @bat_temp battery temperature
165 * @fg_samples: Number of samples used in the FG accumulation
166 * @accu_charge: Accumulated charge from the last conversion
167 * @recovery_cnt: Counter for recovery mode
168 * @high_curr_cnt: Counter for high current mode
169 * @init_cnt: Counter for init mode
170 * @low_bat_cnt Counter for number of consecutive low battery measures
171 * @nbr_cceoc_irq_cnt Counter for number of CCEOC irqs received since enabled
172 * @recovery_needed: Indicate if recovery is needed
173 * @high_curr_mode: Indicate if we're in high current mode
174 * @init_capacity: Indicate if initial capacity measuring should be done
175 * @turn_off_fg: True if fg was off before current measurement
176 * @calib_state State during offset calibration
177 * @discharge_state: Current discharge state
178 * @charge_state: Current charge state
179 * @ab8500_fg_started Completion struct used for the instant current start
180 * @ab8500_fg_complete Completion struct used for the instant current reading
181 * @flags: Structure for information about events triggered
182 * @bat_cap: Structure for battery capacity specific parameters
183 * @avg_cap: Average capacity filter
184 * @parent: Pointer to the struct ab8500
185 * @gpadc: Pointer to the struct gpadc
186 * @bm: Platform specific battery management information
187 * @fg_psy: Structure that holds the FG specific battery properties
188 * @fg_wq: Work queue for running the FG algorithm
189 * @fg_periodic_work: Work to run the FG algorithm periodically
190 * @fg_low_bat_work: Work to check low bat condition
191 * @fg_reinit_work Work used to reset and reinitialise the FG algorithm
192 * @fg_work: Work to run the FG algorithm instantly
193 * @fg_acc_cur_work: Work to read the FG accumulator
194 * @fg_check_hw_failure_work: Work for checking HW state
195 * @cc_lock: Mutex for locking the CC
196 * @fg_kobject: Structure of type kobject
197 */
198 struct ab8500_fg {
199 struct device *dev;
200 struct list_head node;
201 int irq;
202 int vbat;
203 int vbat_nom;
204 int inst_curr;
205 int avg_curr;
206 int bat_temp;
207 int fg_samples;
208 int accu_charge;
209 int recovery_cnt;
210 int high_curr_cnt;
211 int init_cnt;
212 int low_bat_cnt;
213 int nbr_cceoc_irq_cnt;
214 bool recovery_needed;
215 bool high_curr_mode;
216 bool init_capacity;
217 bool turn_off_fg;
218 enum ab8500_fg_calibration_state calib_state;
219 enum ab8500_fg_discharge_state discharge_state;
220 enum ab8500_fg_charge_state charge_state;
221 struct completion ab8500_fg_started;
222 struct completion ab8500_fg_complete;
223 struct ab8500_fg_flags flags;
224 struct ab8500_fg_battery_capacity bat_cap;
225 struct ab8500_fg_avg_cap avg_cap;
226 struct ab8500 *parent;
227 struct ab8500_gpadc *gpadc;
228 struct abx500_bm_data *bm;
229 struct power_supply *fg_psy;
230 struct workqueue_struct *fg_wq;
231 struct delayed_work fg_periodic_work;
232 struct delayed_work fg_low_bat_work;
233 struct delayed_work fg_reinit_work;
234 struct work_struct fg_work;
235 struct work_struct fg_acc_cur_work;
236 struct delayed_work fg_check_hw_failure_work;
237 struct mutex cc_lock;
238 struct kobject fg_kobject;
239 };
240 static LIST_HEAD(ab8500_fg_list);
241
242 /**
243 * ab8500_fg_get() - returns a reference to the primary AB8500 fuel gauge
244 * (i.e. the first fuel gauge in the instance list)
245 */
246 struct ab8500_fg *ab8500_fg_get(void)
247 {
248 return list_first_entry_or_null(&ab8500_fg_list, struct ab8500_fg,
249 node);
250 }
251
252 /* Main battery properties */
253 static enum power_supply_property ab8500_fg_props[] = {
254 POWER_SUPPLY_PROP_VOLTAGE_NOW,
255 POWER_SUPPLY_PROP_CURRENT_NOW,
256 POWER_SUPPLY_PROP_CURRENT_AVG,
257 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
258 POWER_SUPPLY_PROP_ENERGY_FULL,
259 POWER_SUPPLY_PROP_ENERGY_NOW,
260 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
261 POWER_SUPPLY_PROP_CHARGE_FULL,
262 POWER_SUPPLY_PROP_CHARGE_NOW,
263 POWER_SUPPLY_PROP_CAPACITY,
264 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
265 };
266
267 /*
268 * This array maps the raw hex value to lowbat voltage used by the AB8500
269 * Values taken from the UM0836
270 */
271 static int ab8500_fg_lowbat_voltage_map[] = {
272 2300 ,
273 2325 ,
274 2350 ,
275 2375 ,
276 2400 ,
277 2425 ,
278 2450 ,
279 2475 ,
280 2500 ,
281 2525 ,
282 2550 ,
283 2575 ,
284 2600 ,
285 2625 ,
286 2650 ,
287 2675 ,
288 2700 ,
289 2725 ,
290 2750 ,
291 2775 ,
292 2800 ,
293 2825 ,
294 2850 ,
295 2875 ,
296 2900 ,
297 2925 ,
298 2950 ,
299 2975 ,
300 3000 ,
301 3025 ,
302 3050 ,
303 3075 ,
304 3100 ,
305 3125 ,
306 3150 ,
307 3175 ,
308 3200 ,
309 3225 ,
310 3250 ,
311 3275 ,
312 3300 ,
313 3325 ,
314 3350 ,
315 3375 ,
316 3400 ,
317 3425 ,
318 3450 ,
319 3475 ,
320 3500 ,
321 3525 ,
322 3550 ,
323 3575 ,
324 3600 ,
325 3625 ,
326 3650 ,
327 3675 ,
328 3700 ,
329 3725 ,
330 3750 ,
331 3775 ,
332 3800 ,
333 3825 ,
334 3850 ,
335 3850 ,
336 };
337
338 static u8 ab8500_volt_to_regval(int voltage)
339 {
340 int i;
341
342 if (voltage < ab8500_fg_lowbat_voltage_map[0])
343 return 0;
344
345 for (i = 0; i < ARRAY_SIZE(ab8500_fg_lowbat_voltage_map); i++) {
346 if (voltage < ab8500_fg_lowbat_voltage_map[i])
347 return (u8) i - 1;
348 }
349
350 /* If not captured above, return index of last element */
351 return (u8) ARRAY_SIZE(ab8500_fg_lowbat_voltage_map) - 1;
352 }
353
354 /**
355 * ab8500_fg_is_low_curr() - Low or high current mode
356 * @di: pointer to the ab8500_fg structure
357 * @curr: the current to base or our decision on
358 *
359 * Low current mode if the current consumption is below a certain threshold
360 */
361 static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr)
362 {
363 /*
364 * We want to know if we're in low current mode
365 */
366 if (curr > -di->bm->fg_params->high_curr_threshold)
367 return true;
368 else
369 return false;
370 }
371
372 /**
373 * ab8500_fg_add_cap_sample() - Add capacity to average filter
374 * @di: pointer to the ab8500_fg structure
375 * @sample: the capacity in mAh to add to the filter
376 *
377 * A capacity is added to the filter and a new mean capacity is calculated and
378 * returned
379 */
380 static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
381 {
382 struct timespec64 ts64;
383 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
384
385 getnstimeofday64(&ts64);
386
387 do {
388 avg->sum += sample - avg->samples[avg->pos];
389 avg->samples[avg->pos] = sample;
390 avg->time_stamps[avg->pos] = ts64.tv_sec;
391 avg->pos++;
392
393 if (avg->pos == NBR_AVG_SAMPLES)
394 avg->pos = 0;
395
396 if (avg->nbr_samples < NBR_AVG_SAMPLES)
397 avg->nbr_samples++;
398
399 /*
400 * Check the time stamp for each sample. If too old,
401 * replace with latest sample
402 */
403 } while (ts64.tv_sec - VALID_CAPACITY_SEC > avg->time_stamps[avg->pos]);
404
405 avg->avg = avg->sum / avg->nbr_samples;
406
407 return avg->avg;
408 }
409
410 /**
411 * ab8500_fg_clear_cap_samples() - Clear average filter
412 * @di: pointer to the ab8500_fg structure
413 *
414 * The capacity filter is is reset to zero.
415 */
416 static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
417 {
418 int i;
419 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
420
421 avg->pos = 0;
422 avg->nbr_samples = 0;
423 avg->sum = 0;
424 avg->avg = 0;
425
426 for (i = 0; i < NBR_AVG_SAMPLES; i++) {
427 avg->samples[i] = 0;
428 avg->time_stamps[i] = 0;
429 }
430 }
431
432 /**
433 * ab8500_fg_fill_cap_sample() - Fill average filter
434 * @di: pointer to the ab8500_fg structure
435 * @sample: the capacity in mAh to fill the filter with
436 *
437 * The capacity filter is filled with a capacity in mAh
438 */
439 static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
440 {
441 int i;
442 struct timespec64 ts64;
443 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
444
445 getnstimeofday64(&ts64);
446
447 for (i = 0; i < NBR_AVG_SAMPLES; i++) {
448 avg->samples[i] = sample;
449 avg->time_stamps[i] = ts64.tv_sec;
450 }
451
452 avg->pos = 0;
453 avg->nbr_samples = NBR_AVG_SAMPLES;
454 avg->sum = sample * NBR_AVG_SAMPLES;
455 avg->avg = sample;
456 }
457
458 /**
459 * ab8500_fg_coulomb_counter() - enable coulomb counter
460 * @di: pointer to the ab8500_fg structure
461 * @enable: enable/disable
462 *
463 * Enable/Disable coulomb counter.
464 * On failure returns negative value.
465 */
466 static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
467 {
468 int ret = 0;
469 mutex_lock(&di->cc_lock);
470 if (enable) {
471 /* To be able to reprogram the number of samples, we have to
472 * first stop the CC and then enable it again */
473 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
474 AB8500_RTC_CC_CONF_REG, 0x00);
475 if (ret)
476 goto cc_err;
477
478 /* Program the samples */
479 ret = abx500_set_register_interruptible(di->dev,
480 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
481 di->fg_samples);
482 if (ret)
483 goto cc_err;
484
485 /* Start the CC */
486 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
487 AB8500_RTC_CC_CONF_REG,
488 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
489 if (ret)
490 goto cc_err;
491
492 di->flags.fg_enabled = true;
493 } else {
494 /* Clear any pending read requests */
495 ret = abx500_mask_and_set_register_interruptible(di->dev,
496 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
497 (RESET_ACCU | READ_REQ), 0);
498 if (ret)
499 goto cc_err;
500
501 ret = abx500_set_register_interruptible(di->dev,
502 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU_CTRL, 0);
503 if (ret)
504 goto cc_err;
505
506 /* Stop the CC */
507 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
508 AB8500_RTC_CC_CONF_REG, 0);
509 if (ret)
510 goto cc_err;
511
512 di->flags.fg_enabled = false;
513
514 }
515 dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
516 enable, di->fg_samples);
517
518 mutex_unlock(&di->cc_lock);
519
520 return ret;
521 cc_err:
522 dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__);
523 mutex_unlock(&di->cc_lock);
524 return ret;
525 }
526
527 /**
528 * ab8500_fg_inst_curr_start() - start battery instantaneous current
529 * @di: pointer to the ab8500_fg structure
530 *
531 * Returns 0 or error code
532 * Note: This is part "one" and has to be called before
533 * ab8500_fg_inst_curr_finalize()
534 */
535 int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
536 {
537 u8 reg_val;
538 int ret;
539
540 mutex_lock(&di->cc_lock);
541
542 di->nbr_cceoc_irq_cnt = 0;
543 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
544 AB8500_RTC_CC_CONF_REG, &reg_val);
545 if (ret < 0)
546 goto fail;
547
548 if (!(reg_val & CC_PWR_UP_ENA)) {
549 dev_dbg(di->dev, "%s Enable FG\n", __func__);
550 di->turn_off_fg = true;
551
552 /* Program the samples */
553 ret = abx500_set_register_interruptible(di->dev,
554 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
555 SEC_TO_SAMPLE(10));
556 if (ret)
557 goto fail;
558
559 /* Start the CC */
560 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
561 AB8500_RTC_CC_CONF_REG,
562 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
563 if (ret)
564 goto fail;
565 } else {
566 di->turn_off_fg = false;
567 }
568
569 /* Return and WFI */
570 reinit_completion(&di->ab8500_fg_started);
571 reinit_completion(&di->ab8500_fg_complete);
572 enable_irq(di->irq);
573
574 /* Note: cc_lock is still locked */
575 return 0;
576 fail:
577 mutex_unlock(&di->cc_lock);
578 return ret;
579 }
580
581 /**
582 * ab8500_fg_inst_curr_started() - check if fg conversion has started
583 * @di: pointer to the ab8500_fg structure
584 *
585 * Returns 1 if conversion started, 0 if still waiting
586 */
587 int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
588 {
589 return completion_done(&di->ab8500_fg_started);
590 }
591
592 /**
593 * ab8500_fg_inst_curr_done() - check if fg conversion is done
594 * @di: pointer to the ab8500_fg structure
595 *
596 * Returns 1 if conversion done, 0 if still waiting
597 */
598 int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
599 {
600 return completion_done(&di->ab8500_fg_complete);
601 }
602
603 /**
604 * ab8500_fg_inst_curr_finalize() - battery instantaneous current
605 * @di: pointer to the ab8500_fg structure
606 * @res: battery instantenous current(on success)
607 *
608 * Returns 0 or an error code
609 * Note: This is part "two" and has to be called at earliest 250 ms
610 * after ab8500_fg_inst_curr_start()
611 */
612 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *res)
613 {
614 u8 low, high;
615 int val;
616 int ret;
617 unsigned long timeout;
618
619 if (!completion_done(&di->ab8500_fg_complete)) {
620 timeout = wait_for_completion_timeout(
621 &di->ab8500_fg_complete,
622 INS_CURR_TIMEOUT);
623 dev_dbg(di->dev, "Finalize time: %d ms\n",
624 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
625 if (!timeout) {
626 ret = -ETIME;
627 disable_irq(di->irq);
628 di->nbr_cceoc_irq_cnt = 0;
629 dev_err(di->dev, "completion timed out [%d]\n",
630 __LINE__);
631 goto fail;
632 }
633 }
634
635 disable_irq(di->irq);
636 di->nbr_cceoc_irq_cnt = 0;
637
638 ret = abx500_mask_and_set_register_interruptible(di->dev,
639 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
640 READ_REQ, READ_REQ);
641
642 /* 100uS between read request and read is needed */
643 usleep_range(100, 100);
644
645 /* Read CC Sample conversion value Low and high */
646 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
647 AB8500_GASG_CC_SMPL_CNVL_REG, &low);
648 if (ret < 0)
649 goto fail;
650
651 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
652 AB8500_GASG_CC_SMPL_CNVH_REG, &high);
653 if (ret < 0)
654 goto fail;
655
656 /*
657 * negative value for Discharging
658 * convert 2's compliment into decimal
659 */
660 if (high & 0x10)
661 val = (low | (high << 8) | 0xFFFFE000);
662 else
663 val = (low | (high << 8));
664
665 /*
666 * Convert to unit value in mA
667 * Full scale input voltage is
668 * 63.160mV => LSB = 63.160mV/(4096*res) = 1.542mA
669 * Given a 250ms conversion cycle time the LSB corresponds
670 * to 107.1 nAh. Convert to current by dividing by the conversion
671 * time in hours (250ms = 1 / (3600 * 4)h)
672 * 107.1nAh assumes 10mOhm, but fg_res is in 0.1mOhm
673 */
674 val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) /
675 (1000 * di->bm->fg_res);
676
677 if (di->turn_off_fg) {
678 dev_dbg(di->dev, "%s Disable FG\n", __func__);
679
680 /* Clear any pending read requests */
681 ret = abx500_set_register_interruptible(di->dev,
682 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 0);
683 if (ret)
684 goto fail;
685
686 /* Stop the CC */
687 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
688 AB8500_RTC_CC_CONF_REG, 0);
689 if (ret)
690 goto fail;
691 }
692 mutex_unlock(&di->cc_lock);
693 (*res) = val;
694
695 return 0;
696 fail:
697 mutex_unlock(&di->cc_lock);
698 return ret;
699 }
700
701 /**
702 * ab8500_fg_inst_curr_blocking() - battery instantaneous current
703 * @di: pointer to the ab8500_fg structure
704 * @res: battery instantenous current(on success)
705 *
706 * Returns 0 else error code
707 */
708 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
709 {
710 int ret;
711 unsigned long timeout;
712 int res = 0;
713
714 ret = ab8500_fg_inst_curr_start(di);
715 if (ret) {
716 dev_err(di->dev, "Failed to initialize fg_inst\n");
717 return 0;
718 }
719
720 /* Wait for CC to actually start */
721 if (!completion_done(&di->ab8500_fg_started)) {
722 timeout = wait_for_completion_timeout(
723 &di->ab8500_fg_started,
724 INS_CURR_TIMEOUT);
725 dev_dbg(di->dev, "Start time: %d ms\n",
726 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
727 if (!timeout) {
728 ret = -ETIME;
729 dev_err(di->dev, "completion timed out [%d]\n",
730 __LINE__);
731 goto fail;
732 }
733 }
734
735 ret = ab8500_fg_inst_curr_finalize(di, &res);
736 if (ret) {
737 dev_err(di->dev, "Failed to finalize fg_inst\n");
738 return 0;
739 }
740
741 dev_dbg(di->dev, "%s instant current: %d", __func__, res);
742 return res;
743 fail:
744 disable_irq(di->irq);
745 mutex_unlock(&di->cc_lock);
746 return ret;
747 }
748
749 /**
750 * ab8500_fg_acc_cur_work() - average battery current
751 * @work: pointer to the work_struct structure
752 *
753 * Updated the average battery current obtained from the
754 * coulomb counter.
755 */
756 static void ab8500_fg_acc_cur_work(struct work_struct *work)
757 {
758 int val;
759 int ret;
760 u8 low, med, high;
761
762 struct ab8500_fg *di = container_of(work,
763 struct ab8500_fg, fg_acc_cur_work);
764
765 mutex_lock(&di->cc_lock);
766 ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
767 AB8500_GASG_CC_NCOV_ACCU_CTRL, RD_NCONV_ACCU_REQ);
768 if (ret)
769 goto exit;
770
771 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
772 AB8500_GASG_CC_NCOV_ACCU_LOW, &low);
773 if (ret < 0)
774 goto exit;
775
776 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
777 AB8500_GASG_CC_NCOV_ACCU_MED, &med);
778 if (ret < 0)
779 goto exit;
780
781 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
782 AB8500_GASG_CC_NCOV_ACCU_HIGH, &high);
783 if (ret < 0)
784 goto exit;
785
786 /* Check for sign bit in case of negative value, 2's compliment */
787 if (high & 0x10)
788 val = (low | (med << 8) | (high << 16) | 0xFFE00000);
789 else
790 val = (low | (med << 8) | (high << 16));
791
792 /*
793 * Convert to uAh
794 * Given a 250ms conversion cycle time the LSB corresponds
795 * to 112.9 nAh.
796 * 112.9nAh assumes 10mOhm, but fg_res is in 0.1mOhm
797 */
798 di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
799 (100 * di->bm->fg_res);
800
801 /*
802 * Convert to unit value in mA
803 * by dividing by the conversion
804 * time in hours (= samples / (3600 * 4)h)
805 * and multiply with 1000
806 */
807 di->avg_curr = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
808 (1000 * di->bm->fg_res * (di->fg_samples / 4));
809
810 di->flags.conv_done = true;
811
812 mutex_unlock(&di->cc_lock);
813
814 queue_work(di->fg_wq, &di->fg_work);
815
816 dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
817 di->bm->fg_res, di->fg_samples, val, di->accu_charge);
818 return;
819 exit:
820 dev_err(di->dev,
821 "Failed to read or write gas gauge registers\n");
822 mutex_unlock(&di->cc_lock);
823 queue_work(di->fg_wq, &di->fg_work);
824 }
825
826 /**
827 * ab8500_fg_bat_voltage() - get battery voltage
828 * @di: pointer to the ab8500_fg structure
829 *
830 * Returns battery voltage(on success) else error code
831 */
832 static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
833 {
834 int vbat;
835 static int prev;
836
837 vbat = ab8500_gpadc_convert(di->gpadc, MAIN_BAT_V);
838 if (vbat < 0) {
839 dev_err(di->dev,
840 "%s gpadc conversion failed, using previous value\n",
841 __func__);
842 return prev;
843 }
844
845 prev = vbat;
846 return vbat;
847 }
848
849 /**
850 * ab8500_fg_volt_to_capacity() - Voltage based capacity
851 * @di: pointer to the ab8500_fg structure
852 * @voltage: The voltage to convert to a capacity
853 *
854 * Returns battery capacity in per mille based on voltage
855 */
856 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage)
857 {
858 int i, tbl_size;
859 const struct abx500_v_to_cap *tbl;
860 int cap = 0;
861
862 tbl = di->bm->bat_type[di->bm->batt_id].v_to_cap_tbl,
863 tbl_size = di->bm->bat_type[di->bm->batt_id].n_v_cap_tbl_elements;
864
865 for (i = 0; i < tbl_size; ++i) {
866 if (voltage > tbl[i].voltage)
867 break;
868 }
869
870 if ((i > 0) && (i < tbl_size)) {
871 cap = interpolate(voltage,
872 tbl[i].voltage,
873 tbl[i].capacity * 10,
874 tbl[i-1].voltage,
875 tbl[i-1].capacity * 10);
876 } else if (i == 0) {
877 cap = 1000;
878 } else {
879 cap = 0;
880 }
881
882 dev_dbg(di->dev, "%s Vbat: %d, Cap: %d per mille",
883 __func__, voltage, cap);
884
885 return cap;
886 }
887
888 /**
889 * ab8500_fg_uncomp_volt_to_capacity() - Uncompensated voltage based capacity
890 * @di: pointer to the ab8500_fg structure
891 *
892 * Returns battery capacity based on battery voltage that is not compensated
893 * for the voltage drop due to the load
894 */
895 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
896 {
897 di->vbat = ab8500_fg_bat_voltage(di);
898 return ab8500_fg_volt_to_capacity(di, di->vbat);
899 }
900
901 /**
902 * ab8500_fg_battery_resistance() - Returns the battery inner resistance
903 * @di: pointer to the ab8500_fg structure
904 *
905 * Returns battery inner resistance added with the fuel gauge resistor value
906 * to get the total resistance in the whole link from gnd to bat+ node.
907 */
908 static int ab8500_fg_battery_resistance(struct ab8500_fg *di)
909 {
910 int i, tbl_size;
911 const struct batres_vs_temp *tbl;
912 int resist = 0;
913
914 tbl = di->bm->bat_type[di->bm->batt_id].batres_tbl;
915 tbl_size = di->bm->bat_type[di->bm->batt_id].n_batres_tbl_elements;
916
917 for (i = 0; i < tbl_size; ++i) {
918 if (di->bat_temp / 10 > tbl[i].temp)
919 break;
920 }
921
922 if ((i > 0) && (i < tbl_size)) {
923 resist = interpolate(di->bat_temp / 10,
924 tbl[i].temp,
925 tbl[i].resist,
926 tbl[i-1].temp,
927 tbl[i-1].resist);
928 } else if (i == 0) {
929 resist = tbl[0].resist;
930 } else {
931 resist = tbl[tbl_size - 1].resist;
932 }
933
934 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
935 " fg resistance %d, total: %d (mOhm)\n",
936 __func__, di->bat_temp, resist, di->bm->fg_res / 10,
937 (di->bm->fg_res / 10) + resist);
938
939 /* fg_res variable is in 0.1mOhm */
940 resist += di->bm->fg_res / 10;
941
942 return resist;
943 }
944
945 /**
946 * ab8500_fg_load_comp_volt_to_capacity() - Load compensated voltage based capacity
947 * @di: pointer to the ab8500_fg structure
948 *
949 * Returns battery capacity based on battery voltage that is load compensated
950 * for the voltage drop
951 */
952 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
953 {
954 int vbat_comp, res;
955 int i = 0;
956 int vbat = 0;
957
958 ab8500_fg_inst_curr_start(di);
959
960 do {
961 vbat += ab8500_fg_bat_voltage(di);
962 i++;
963 usleep_range(5000, 6000);
964 } while (!ab8500_fg_inst_curr_done(di));
965
966 ab8500_fg_inst_curr_finalize(di, &di->inst_curr);
967
968 di->vbat = vbat / i;
969 res = ab8500_fg_battery_resistance(di);
970
971 /* Use Ohms law to get the load compensated voltage */
972 vbat_comp = di->vbat - (di->inst_curr * res) / 1000;
973
974 dev_dbg(di->dev, "%s Measured Vbat: %dmV,Compensated Vbat %dmV, "
975 "R: %dmOhm, Current: %dmA Vbat Samples: %d\n",
976 __func__, di->vbat, vbat_comp, res, di->inst_curr, i);
977
978 return ab8500_fg_volt_to_capacity(di, vbat_comp);
979 }
980
981 /**
982 * ab8500_fg_convert_mah_to_permille() - Capacity in mAh to permille
983 * @di: pointer to the ab8500_fg structure
984 * @cap_mah: capacity in mAh
985 *
986 * Converts capacity in mAh to capacity in permille
987 */
988 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
989 {
990 return (cap_mah * 1000) / di->bat_cap.max_mah_design;
991 }
992
993 /**
994 * ab8500_fg_convert_permille_to_mah() - Capacity in permille to mAh
995 * @di: pointer to the ab8500_fg structure
996 * @cap_pm: capacity in permille
997 *
998 * Converts capacity in permille to capacity in mAh
999 */
1000 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
1001 {
1002 return cap_pm * di->bat_cap.max_mah_design / 1000;
1003 }
1004
1005 /**
1006 * ab8500_fg_convert_mah_to_uwh() - Capacity in mAh to uWh
1007 * @di: pointer to the ab8500_fg structure
1008 * @cap_mah: capacity in mAh
1009 *
1010 * Converts capacity in mAh to capacity in uWh
1011 */
1012 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
1013 {
1014 u64 div_res;
1015 u32 div_rem;
1016
1017 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom);
1018 div_rem = do_div(div_res, 1000);
1019
1020 /* Make sure to round upwards if necessary */
1021 if (div_rem >= 1000 / 2)
1022 div_res++;
1023
1024 return (int) div_res;
1025 }
1026
1027 /**
1028 * ab8500_fg_calc_cap_charging() - Calculate remaining capacity while charging
1029 * @di: pointer to the ab8500_fg structure
1030 *
1031 * Return the capacity in mAh based on previous calculated capcity and the FG
1032 * accumulator register value. The filter is filled with this capacity
1033 */
1034 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
1035 {
1036 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1037 __func__,
1038 di->bat_cap.mah,
1039 di->accu_charge);
1040
1041 /* Capacity should not be less than 0 */
1042 if (di->bat_cap.mah + di->accu_charge > 0)
1043 di->bat_cap.mah += di->accu_charge;
1044 else
1045 di->bat_cap.mah = 0;
1046 /*
1047 * We force capacity to 100% once when the algorithm
1048 * reports that it's full.
1049 */
1050 if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
1051 di->flags.force_full) {
1052 di->bat_cap.mah = di->bat_cap.max_mah_design;
1053 }
1054
1055 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1056 di->bat_cap.permille =
1057 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1058
1059 /* We need to update battery voltage and inst current when charging */
1060 di->vbat = ab8500_fg_bat_voltage(di);
1061 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1062
1063 return di->bat_cap.mah;
1064 }
1065
1066 /**
1067 * ab8500_fg_calc_cap_discharge_voltage() - Capacity in discharge with voltage
1068 * @di: pointer to the ab8500_fg structure
1069 * @comp: if voltage should be load compensated before capacity calc
1070 *
1071 * Return the capacity in mAh based on the battery voltage. The voltage can
1072 * either be load compensated or not. This value is added to the filter and a
1073 * new mean value is calculated and returned.
1074 */
1075 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di, bool comp)
1076 {
1077 int permille, mah;
1078
1079 if (comp)
1080 permille = ab8500_fg_load_comp_volt_to_capacity(di);
1081 else
1082 permille = ab8500_fg_uncomp_volt_to_capacity(di);
1083
1084 mah = ab8500_fg_convert_permille_to_mah(di, permille);
1085
1086 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
1087 di->bat_cap.permille =
1088 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1089
1090 return di->bat_cap.mah;
1091 }
1092
1093 /**
1094 * ab8500_fg_calc_cap_discharge_fg() - Capacity in discharge with FG
1095 * @di: pointer to the ab8500_fg structure
1096 *
1097 * Return the capacity in mAh based on previous calculated capcity and the FG
1098 * accumulator register value. This value is added to the filter and a
1099 * new mean value is calculated and returned.
1100 */
1101 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
1102 {
1103 int permille_volt, permille;
1104
1105 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1106 __func__,
1107 di->bat_cap.mah,
1108 di->accu_charge);
1109
1110 /* Capacity should not be less than 0 */
1111 if (di->bat_cap.mah + di->accu_charge > 0)
1112 di->bat_cap.mah += di->accu_charge;
1113 else
1114 di->bat_cap.mah = 0;
1115
1116 if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
1117 di->bat_cap.mah = di->bat_cap.max_mah_design;
1118
1119 /*
1120 * Check against voltage based capacity. It can not be lower
1121 * than what the uncompensated voltage says
1122 */
1123 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1124 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
1125
1126 if (permille < permille_volt) {
1127 di->bat_cap.permille = permille_volt;
1128 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
1129 di->bat_cap.permille);
1130
1131 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
1132 __func__,
1133 permille,
1134 permille_volt);
1135
1136 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1137 } else {
1138 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1139 di->bat_cap.permille =
1140 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1141 }
1142
1143 return di->bat_cap.mah;
1144 }
1145
1146 /**
1147 * ab8500_fg_capacity_level() - Get the battery capacity level
1148 * @di: pointer to the ab8500_fg structure
1149 *
1150 * Get the battery capacity level based on the capacity in percent
1151 */
1152 static int ab8500_fg_capacity_level(struct ab8500_fg *di)
1153 {
1154 int ret, percent;
1155
1156 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1157
1158 if (percent <= di->bm->cap_levels->critical ||
1159 di->flags.low_bat)
1160 ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1161 else if (percent <= di->bm->cap_levels->low)
1162 ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1163 else if (percent <= di->bm->cap_levels->normal)
1164 ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1165 else if (percent <= di->bm->cap_levels->high)
1166 ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
1167 else
1168 ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1169
1170 return ret;
1171 }
1172
1173 /**
1174 * ab8500_fg_calculate_scaled_capacity() - Capacity scaling
1175 * @di: pointer to the ab8500_fg structure
1176 *
1177 * Calculates the capacity to be shown to upper layers. Scales the capacity
1178 * to have 100% as a reference from the actual capacity upon removal of charger
1179 * when charging is in maintenance mode.
1180 */
1181 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
1182 {
1183 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1184 int capacity = di->bat_cap.prev_percent;
1185
1186 if (!cs->enable)
1187 return capacity;
1188
1189 /*
1190 * As long as we are in fully charge mode scale the capacity
1191 * to show 100%.
1192 */
1193 if (di->flags.fully_charged) {
1194 cs->cap_to_scale[0] = 100;
1195 cs->cap_to_scale[1] =
1196 max(capacity, di->bm->fg_params->maint_thres);
1197 dev_dbg(di->dev, "Scale cap with %d/%d\n",
1198 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1199 }
1200
1201 /* Calculates the scaled capacity. */
1202 if ((cs->cap_to_scale[0] != cs->cap_to_scale[1])
1203 && (cs->cap_to_scale[1] > 0))
1204 capacity = min(100,
1205 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
1206 cs->cap_to_scale[0],
1207 cs->cap_to_scale[1]));
1208
1209 if (di->flags.charging) {
1210 if (capacity < cs->disable_cap_level) {
1211 cs->disable_cap_level = capacity;
1212 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
1213 cs->disable_cap_level);
1214 } else if (!di->flags.fully_charged) {
1215 if (di->bat_cap.prev_percent >=
1216 cs->disable_cap_level) {
1217 dev_dbg(di->dev, "Disabling scaled capacity\n");
1218 cs->enable = false;
1219 capacity = di->bat_cap.prev_percent;
1220 } else {
1221 dev_dbg(di->dev,
1222 "Waiting in cap to level %d%%\n",
1223 cs->disable_cap_level);
1224 capacity = cs->disable_cap_level;
1225 }
1226 }
1227 }
1228
1229 return capacity;
1230 }
1231
1232 /**
1233 * ab8500_fg_update_cap_scalers() - Capacity scaling
1234 * @di: pointer to the ab8500_fg structure
1235 *
1236 * To be called when state change from charge<->discharge to update
1237 * the capacity scalers.
1238 */
1239 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
1240 {
1241 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1242
1243 if (!cs->enable)
1244 return;
1245 if (di->flags.charging) {
1246 di->bat_cap.cap_scale.disable_cap_level =
1247 di->bat_cap.cap_scale.scaled_cap;
1248 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
1249 di->bat_cap.cap_scale.disable_cap_level);
1250 } else {
1251 if (cs->scaled_cap != 100) {
1252 cs->cap_to_scale[0] = cs->scaled_cap;
1253 cs->cap_to_scale[1] = di->bat_cap.prev_percent;
1254 } else {
1255 cs->cap_to_scale[0] = 100;
1256 cs->cap_to_scale[1] =
1257 max(di->bat_cap.prev_percent,
1258 di->bm->fg_params->maint_thres);
1259 }
1260
1261 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
1262 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1263 }
1264 }
1265
1266 /**
1267 * ab8500_fg_check_capacity_limits() - Check if capacity has changed
1268 * @di: pointer to the ab8500_fg structure
1269 * @init: capacity is allowed to go up in init mode
1270 *
1271 * Check if capacity or capacity limit has changed and notify the system
1272 * about it using the power_supply framework
1273 */
1274 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
1275 {
1276 bool changed = false;
1277 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1278
1279 di->bat_cap.level = ab8500_fg_capacity_level(di);
1280
1281 if (di->bat_cap.level != di->bat_cap.prev_level) {
1282 /*
1283 * We do not allow reported capacity level to go up
1284 * unless we're charging or if we're in init
1285 */
1286 if (!(!di->flags.charging && di->bat_cap.level >
1287 di->bat_cap.prev_level) || init) {
1288 dev_dbg(di->dev, "level changed from %d to %d\n",
1289 di->bat_cap.prev_level,
1290 di->bat_cap.level);
1291 di->bat_cap.prev_level = di->bat_cap.level;
1292 changed = true;
1293 } else {
1294 dev_dbg(di->dev, "level not allowed to go up "
1295 "since no charger is connected: %d to %d\n",
1296 di->bat_cap.prev_level,
1297 di->bat_cap.level);
1298 }
1299 }
1300
1301 /*
1302 * If we have received the LOW_BAT IRQ, set capacity to 0 to initiate
1303 * shutdown
1304 */
1305 if (di->flags.low_bat) {
1306 dev_dbg(di->dev, "Battery low, set capacity to 0\n");
1307 di->bat_cap.prev_percent = 0;
1308 di->bat_cap.permille = 0;
1309 percent = 0;
1310 di->bat_cap.prev_mah = 0;
1311 di->bat_cap.mah = 0;
1312 changed = true;
1313 } else if (di->flags.fully_charged) {
1314 /*
1315 * We report 100% if algorithm reported fully charged
1316 * and show 100% during maintenance charging (scaling).
1317 */
1318 if (di->flags.force_full) {
1319 di->bat_cap.prev_percent = percent;
1320 di->bat_cap.prev_mah = di->bat_cap.mah;
1321
1322 changed = true;
1323
1324 if (!di->bat_cap.cap_scale.enable &&
1325 di->bm->capacity_scaling) {
1326 di->bat_cap.cap_scale.enable = true;
1327 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
1328 di->bat_cap.cap_scale.cap_to_scale[1] =
1329 di->bat_cap.prev_percent;
1330 di->bat_cap.cap_scale.disable_cap_level = 100;
1331 }
1332 } else if (di->bat_cap.prev_percent != percent) {
1333 dev_dbg(di->dev,
1334 "battery reported full "
1335 "but capacity dropping: %d\n",
1336 percent);
1337 di->bat_cap.prev_percent = percent;
1338 di->bat_cap.prev_mah = di->bat_cap.mah;
1339
1340 changed = true;
1341 }
1342 } else if (di->bat_cap.prev_percent != percent) {
1343 if (percent == 0) {
1344 /*
1345 * We will not report 0% unless we've got
1346 * the LOW_BAT IRQ, no matter what the FG
1347 * algorithm says.
1348 */
1349 di->bat_cap.prev_percent = 1;
1350 percent = 1;
1351
1352 changed = true;
1353 } else if (!(!di->flags.charging &&
1354 percent > di->bat_cap.prev_percent) || init) {
1355 /*
1356 * We do not allow reported capacity to go up
1357 * unless we're charging or if we're in init
1358 */
1359 dev_dbg(di->dev,
1360 "capacity changed from %d to %d (%d)\n",
1361 di->bat_cap.prev_percent,
1362 percent,
1363 di->bat_cap.permille);
1364 di->bat_cap.prev_percent = percent;
1365 di->bat_cap.prev_mah = di->bat_cap.mah;
1366
1367 changed = true;
1368 } else {
1369 dev_dbg(di->dev, "capacity not allowed to go up since "
1370 "no charger is connected: %d to %d (%d)\n",
1371 di->bat_cap.prev_percent,
1372 percent,
1373 di->bat_cap.permille);
1374 }
1375 }
1376
1377 if (changed) {
1378 if (di->bm->capacity_scaling) {
1379 di->bat_cap.cap_scale.scaled_cap =
1380 ab8500_fg_calculate_scaled_capacity(di);
1381
1382 dev_info(di->dev, "capacity=%d (%d)\n",
1383 di->bat_cap.prev_percent,
1384 di->bat_cap.cap_scale.scaled_cap);
1385 }
1386 power_supply_changed(di->fg_psy);
1387 if (di->flags.fully_charged && di->flags.force_full) {
1388 dev_dbg(di->dev, "Battery full, notifying.\n");
1389 di->flags.force_full = false;
1390 sysfs_notify(&di->fg_kobject, NULL, "charge_full");
1391 }
1392 sysfs_notify(&di->fg_kobject, NULL, "charge_now");
1393 }
1394 }
1395
1396 static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
1397 enum ab8500_fg_charge_state new_state)
1398 {
1399 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
1400 di->charge_state,
1401 charge_state[di->charge_state],
1402 new_state,
1403 charge_state[new_state]);
1404
1405 di->charge_state = new_state;
1406 }
1407
1408 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
1409 enum ab8500_fg_discharge_state new_state)
1410 {
1411 dev_dbg(di->dev, "Disharge state from %d [%s] to %d [%s]\n",
1412 di->discharge_state,
1413 discharge_state[di->discharge_state],
1414 new_state,
1415 discharge_state[new_state]);
1416
1417 di->discharge_state = new_state;
1418 }
1419
1420 /**
1421 * ab8500_fg_algorithm_charging() - FG algorithm for when charging
1422 * @di: pointer to the ab8500_fg structure
1423 *
1424 * Battery capacity calculation state machine for when we're charging
1425 */
1426 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
1427 {
1428 /*
1429 * If we change to discharge mode
1430 * we should start with recovery
1431 */
1432 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
1433 ab8500_fg_discharge_state_to(di,
1434 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1435
1436 switch (di->charge_state) {
1437 case AB8500_FG_CHARGE_INIT:
1438 di->fg_samples = SEC_TO_SAMPLE(
1439 di->bm->fg_params->accu_charging);
1440
1441 ab8500_fg_coulomb_counter(di, true);
1442 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
1443
1444 break;
1445
1446 case AB8500_FG_CHARGE_READOUT:
1447 /*
1448 * Read the FG and calculate the new capacity
1449 */
1450 mutex_lock(&di->cc_lock);
1451 if (!di->flags.conv_done && !di->flags.force_full) {
1452 /* Wasn't the CC IRQ that got us here */
1453 mutex_unlock(&di->cc_lock);
1454 dev_dbg(di->dev, "%s CC conv not done\n",
1455 __func__);
1456
1457 break;
1458 }
1459 di->flags.conv_done = false;
1460 mutex_unlock(&di->cc_lock);
1461
1462 ab8500_fg_calc_cap_charging(di);
1463
1464 break;
1465
1466 default:
1467 break;
1468 }
1469
1470 /* Check capacity limits */
1471 ab8500_fg_check_capacity_limits(di, false);
1472 }
1473
1474 static void force_capacity(struct ab8500_fg *di)
1475 {
1476 int cap;
1477
1478 ab8500_fg_clear_cap_samples(di);
1479 cap = di->bat_cap.user_mah;
1480 if (cap > di->bat_cap.max_mah_design) {
1481 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
1482 " %d\n", cap, di->bat_cap.max_mah_design);
1483 cap = di->bat_cap.max_mah_design;
1484 }
1485 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
1486 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
1487 di->bat_cap.mah = cap;
1488 ab8500_fg_check_capacity_limits(di, true);
1489 }
1490
1491 static bool check_sysfs_capacity(struct ab8500_fg *di)
1492 {
1493 int cap, lower, upper;
1494 int cap_permille;
1495
1496 cap = di->bat_cap.user_mah;
1497
1498 cap_permille = ab8500_fg_convert_mah_to_permille(di,
1499 di->bat_cap.user_mah);
1500
1501 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
1502 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
1503
1504 if (lower < 0)
1505 lower = 0;
1506 /* 1000 is permille, -> 100 percent */
1507 if (upper > 1000)
1508 upper = 1000;
1509
1510 dev_dbg(di->dev, "Capacity limits:"
1511 " (Lower: %d User: %d Upper: %d) [user: %d, was: %d]\n",
1512 lower, cap_permille, upper, cap, di->bat_cap.mah);
1513
1514 /* If within limits, use the saved capacity and exit estimation...*/
1515 if (cap_permille > lower && cap_permille < upper) {
1516 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
1517 force_capacity(di);
1518 return true;
1519 }
1520 dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
1521 return false;
1522 }
1523
1524 /**
1525 * ab8500_fg_algorithm_discharging() - FG algorithm for when discharging
1526 * @di: pointer to the ab8500_fg structure
1527 *
1528 * Battery capacity calculation state machine for when we're discharging
1529 */
1530 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
1531 {
1532 int sleep_time;
1533
1534 /* If we change to charge mode we should start with init */
1535 if (di->charge_state != AB8500_FG_CHARGE_INIT)
1536 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
1537
1538 switch (di->discharge_state) {
1539 case AB8500_FG_DISCHARGE_INIT:
1540 /* We use the FG IRQ to work on */
1541 di->init_cnt = 0;
1542 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
1543 ab8500_fg_coulomb_counter(di, true);
1544 ab8500_fg_discharge_state_to(di,
1545 AB8500_FG_DISCHARGE_INITMEASURING);
1546
1547 /* Intentional fallthrough */
1548 case AB8500_FG_DISCHARGE_INITMEASURING:
1549 /*
1550 * Discard a number of samples during startup.
1551 * After that, use compensated voltage for a few
1552 * samples to get an initial capacity.
1553 * Then go to READOUT
1554 */
1555 sleep_time = di->bm->fg_params->init_timer;
1556
1557 /* Discard the first [x] seconds */
1558 if (di->init_cnt > di->bm->fg_params->init_discard_time) {
1559 ab8500_fg_calc_cap_discharge_voltage(di, true);
1560
1561 ab8500_fg_check_capacity_limits(di, true);
1562 }
1563
1564 di->init_cnt += sleep_time;
1565 if (di->init_cnt > di->bm->fg_params->init_total_time)
1566 ab8500_fg_discharge_state_to(di,
1567 AB8500_FG_DISCHARGE_READOUT_INIT);
1568
1569 break;
1570
1571 case AB8500_FG_DISCHARGE_INIT_RECOVERY:
1572 di->recovery_cnt = 0;
1573 di->recovery_needed = true;
1574 ab8500_fg_discharge_state_to(di,
1575 AB8500_FG_DISCHARGE_RECOVERY);
1576
1577 /* Intentional fallthrough */
1578
1579 case AB8500_FG_DISCHARGE_RECOVERY:
1580 sleep_time = di->bm->fg_params->recovery_sleep_timer;
1581
1582 /*
1583 * We should check the power consumption
1584 * If low, go to READOUT (after x min) or
1585 * RECOVERY_SLEEP if time left.
1586 * If high, go to READOUT
1587 */
1588 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1589
1590 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1591 if (di->recovery_cnt >
1592 di->bm->fg_params->recovery_total_time) {
1593 di->fg_samples = SEC_TO_SAMPLE(
1594 di->bm->fg_params->accu_high_curr);
1595 ab8500_fg_coulomb_counter(di, true);
1596 ab8500_fg_discharge_state_to(di,
1597 AB8500_FG_DISCHARGE_READOUT);
1598 di->recovery_needed = false;
1599 } else {
1600 queue_delayed_work(di->fg_wq,
1601 &di->fg_periodic_work,
1602 sleep_time * HZ);
1603 }
1604 di->recovery_cnt += sleep_time;
1605 } else {
1606 di->fg_samples = SEC_TO_SAMPLE(
1607 di->bm->fg_params->accu_high_curr);
1608 ab8500_fg_coulomb_counter(di, true);
1609 ab8500_fg_discharge_state_to(di,
1610 AB8500_FG_DISCHARGE_READOUT);
1611 }
1612 break;
1613
1614 case AB8500_FG_DISCHARGE_READOUT_INIT:
1615 di->fg_samples = SEC_TO_SAMPLE(
1616 di->bm->fg_params->accu_high_curr);
1617 ab8500_fg_coulomb_counter(di, true);
1618 ab8500_fg_discharge_state_to(di,
1619 AB8500_FG_DISCHARGE_READOUT);
1620 break;
1621
1622 case AB8500_FG_DISCHARGE_READOUT:
1623 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1624
1625 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1626 /* Detect mode change */
1627 if (di->high_curr_mode) {
1628 di->high_curr_mode = false;
1629 di->high_curr_cnt = 0;
1630 }
1631
1632 if (di->recovery_needed) {
1633 ab8500_fg_discharge_state_to(di,
1634 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1635
1636 queue_delayed_work(di->fg_wq,
1637 &di->fg_periodic_work, 0);
1638
1639 break;
1640 }
1641
1642 ab8500_fg_calc_cap_discharge_voltage(di, true);
1643 } else {
1644 mutex_lock(&di->cc_lock);
1645 if (!di->flags.conv_done) {
1646 /* Wasn't the CC IRQ that got us here */
1647 mutex_unlock(&di->cc_lock);
1648 dev_dbg(di->dev, "%s CC conv not done\n",
1649 __func__);
1650
1651 break;
1652 }
1653 di->flags.conv_done = false;
1654 mutex_unlock(&di->cc_lock);
1655
1656 /* Detect mode change */
1657 if (!di->high_curr_mode) {
1658 di->high_curr_mode = true;
1659 di->high_curr_cnt = 0;
1660 }
1661
1662 di->high_curr_cnt +=
1663 di->bm->fg_params->accu_high_curr;
1664 if (di->high_curr_cnt >
1665 di->bm->fg_params->high_curr_time)
1666 di->recovery_needed = true;
1667
1668 ab8500_fg_calc_cap_discharge_fg(di);
1669 }
1670
1671 ab8500_fg_check_capacity_limits(di, false);
1672
1673 break;
1674
1675 case AB8500_FG_DISCHARGE_WAKEUP:
1676 ab8500_fg_calc_cap_discharge_voltage(di, true);
1677
1678 di->fg_samples = SEC_TO_SAMPLE(
1679 di->bm->fg_params->accu_high_curr);
1680 ab8500_fg_coulomb_counter(di, true);
1681 ab8500_fg_discharge_state_to(di,
1682 AB8500_FG_DISCHARGE_READOUT);
1683
1684 ab8500_fg_check_capacity_limits(di, false);
1685
1686 break;
1687
1688 default:
1689 break;
1690 }
1691 }
1692
1693 /**
1694 * ab8500_fg_algorithm_calibrate() - Internal columb counter offset calibration
1695 * @di: pointer to the ab8500_fg structure
1696 *
1697 */
1698 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
1699 {
1700 int ret;
1701
1702 switch (di->calib_state) {
1703 case AB8500_FG_CALIB_INIT:
1704 dev_dbg(di->dev, "Calibration ongoing...\n");
1705
1706 ret = abx500_mask_and_set_register_interruptible(di->dev,
1707 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1708 CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8);
1709 if (ret < 0)
1710 goto err;
1711
1712 ret = abx500_mask_and_set_register_interruptible(di->dev,
1713 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1714 CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA);
1715 if (ret < 0)
1716 goto err;
1717 di->calib_state = AB8500_FG_CALIB_WAIT;
1718 break;
1719 case AB8500_FG_CALIB_END:
1720 ret = abx500_mask_and_set_register_interruptible(di->dev,
1721 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1722 CC_MUXOFFSET, CC_MUXOFFSET);
1723 if (ret < 0)
1724 goto err;
1725 di->flags.calibrate = false;
1726 dev_dbg(di->dev, "Calibration done...\n");
1727 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1728 break;
1729 case AB8500_FG_CALIB_WAIT:
1730 dev_dbg(di->dev, "Calibration WFI\n");
1731 default:
1732 break;
1733 }
1734 return;
1735 err:
1736 /* Something went wrong, don't calibrate then */
1737 dev_err(di->dev, "failed to calibrate the CC\n");
1738 di->flags.calibrate = false;
1739 di->calib_state = AB8500_FG_CALIB_INIT;
1740 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1741 }
1742
1743 /**
1744 * ab8500_fg_algorithm() - Entry point for the FG algorithm
1745 * @di: pointer to the ab8500_fg structure
1746 *
1747 * Entry point for the battery capacity calculation state machine
1748 */
1749 static void ab8500_fg_algorithm(struct ab8500_fg *di)
1750 {
1751 if (di->flags.calibrate)
1752 ab8500_fg_algorithm_calibrate(di);
1753 else {
1754 if (di->flags.charging)
1755 ab8500_fg_algorithm_charging(di);
1756 else
1757 ab8500_fg_algorithm_discharging(di);
1758 }
1759
1760 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
1761 "%d %d %d %d %d %d %d\n",
1762 di->bat_cap.max_mah_design,
1763 di->bat_cap.max_mah,
1764 di->bat_cap.mah,
1765 di->bat_cap.permille,
1766 di->bat_cap.level,
1767 di->bat_cap.prev_mah,
1768 di->bat_cap.prev_percent,
1769 di->bat_cap.prev_level,
1770 di->vbat,
1771 di->inst_curr,
1772 di->avg_curr,
1773 di->accu_charge,
1774 di->flags.charging,
1775 di->charge_state,
1776 di->discharge_state,
1777 di->high_curr_mode,
1778 di->recovery_needed);
1779 }
1780
1781 /**
1782 * ab8500_fg_periodic_work() - Run the FG state machine periodically
1783 * @work: pointer to the work_struct structure
1784 *
1785 * Work queue function for periodic work
1786 */
1787 static void ab8500_fg_periodic_work(struct work_struct *work)
1788 {
1789 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1790 fg_periodic_work.work);
1791
1792 if (di->init_capacity) {
1793 /* Get an initial capacity calculation */
1794 ab8500_fg_calc_cap_discharge_voltage(di, true);
1795 ab8500_fg_check_capacity_limits(di, true);
1796 di->init_capacity = false;
1797
1798 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1799 } else if (di->flags.user_cap) {
1800 if (check_sysfs_capacity(di)) {
1801 ab8500_fg_check_capacity_limits(di, true);
1802 if (di->flags.charging)
1803 ab8500_fg_charge_state_to(di,
1804 AB8500_FG_CHARGE_INIT);
1805 else
1806 ab8500_fg_discharge_state_to(di,
1807 AB8500_FG_DISCHARGE_READOUT_INIT);
1808 }
1809 di->flags.user_cap = false;
1810 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1811 } else
1812 ab8500_fg_algorithm(di);
1813
1814 }
1815
1816 /**
1817 * ab8500_fg_check_hw_failure_work() - Check OVV_BAT condition
1818 * @work: pointer to the work_struct structure
1819 *
1820 * Work queue function for checking the OVV_BAT condition
1821 */
1822 static void ab8500_fg_check_hw_failure_work(struct work_struct *work)
1823 {
1824 int ret;
1825 u8 reg_value;
1826
1827 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1828 fg_check_hw_failure_work.work);
1829
1830 /*
1831 * If we have had a battery over-voltage situation,
1832 * check ovv-bit to see if it should be reset.
1833 */
1834 ret = abx500_get_register_interruptible(di->dev,
1835 AB8500_CHARGER, AB8500_CH_STAT_REG,
1836 &reg_value);
1837 if (ret < 0) {
1838 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1839 return;
1840 }
1841 if ((reg_value & BATT_OVV) == BATT_OVV) {
1842 if (!di->flags.bat_ovv) {
1843 dev_dbg(di->dev, "Battery OVV\n");
1844 di->flags.bat_ovv = true;
1845 power_supply_changed(di->fg_psy);
1846 }
1847 /* Not yet recovered from ovv, reschedule this test */
1848 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
1849 HZ);
1850 } else {
1851 dev_dbg(di->dev, "Battery recovered from OVV\n");
1852 di->flags.bat_ovv = false;
1853 power_supply_changed(di->fg_psy);
1854 }
1855 }
1856
1857 /**
1858 * ab8500_fg_low_bat_work() - Check LOW_BAT condition
1859 * @work: pointer to the work_struct structure
1860 *
1861 * Work queue function for checking the LOW_BAT condition
1862 */
1863 static void ab8500_fg_low_bat_work(struct work_struct *work)
1864 {
1865 int vbat;
1866
1867 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1868 fg_low_bat_work.work);
1869
1870 vbat = ab8500_fg_bat_voltage(di);
1871
1872 /* Check if LOW_BAT still fulfilled */
1873 if (vbat < di->bm->fg_params->lowbat_threshold) {
1874 /* Is it time to shut down? */
1875 if (di->low_bat_cnt < 1) {
1876 di->flags.low_bat = true;
1877 dev_warn(di->dev, "Shut down pending...\n");
1878 } else {
1879 /*
1880 * Else we need to re-schedule this check to be able to detect
1881 * if the voltage increases again during charging or
1882 * due to decreasing load.
1883 */
1884 di->low_bat_cnt--;
1885 dev_warn(di->dev, "Battery voltage still LOW\n");
1886 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
1887 round_jiffies(LOW_BAT_CHECK_INTERVAL));
1888 }
1889 } else {
1890 di->flags.low_bat_delay = false;
1891 di->low_bat_cnt = 10;
1892 dev_warn(di->dev, "Battery voltage OK again\n");
1893 }
1894
1895 /* This is needed to dispatch LOW_BAT */
1896 ab8500_fg_check_capacity_limits(di, false);
1897 }
1898
1899 /**
1900 * ab8500_fg_battok_calc - calculate the bit pattern corresponding
1901 * to the target voltage.
1902 * @di: pointer to the ab8500_fg structure
1903 * @target: target voltage
1904 *
1905 * Returns bit pattern closest to the target voltage
1906 * valid return values are 0-14. (0-BATT_OK_MAX_NR_INCREMENTS)
1907 */
1908
1909 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
1910 {
1911 if (target > BATT_OK_MIN +
1912 (BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS))
1913 return BATT_OK_MAX_NR_INCREMENTS;
1914 if (target < BATT_OK_MIN)
1915 return 0;
1916 return (target - BATT_OK_MIN) / BATT_OK_INCREMENT;
1917 }
1918
1919 /**
1920 * ab8500_fg_battok_init_hw_register - init battok levels
1921 * @di: pointer to the ab8500_fg structure
1922 *
1923 */
1924
1925 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
1926 {
1927 int selected;
1928 int sel0;
1929 int sel1;
1930 int cbp_sel0;
1931 int cbp_sel1;
1932 int ret;
1933 int new_val;
1934
1935 sel0 = di->bm->fg_params->battok_falling_th_sel0;
1936 sel1 = di->bm->fg_params->battok_raising_th_sel1;
1937
1938 cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
1939 cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
1940
1941 selected = BATT_OK_MIN + cbp_sel0 * BATT_OK_INCREMENT;
1942
1943 if (selected != sel0)
1944 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1945 sel0, selected, cbp_sel0);
1946
1947 selected = BATT_OK_MIN + cbp_sel1 * BATT_OK_INCREMENT;
1948
1949 if (selected != sel1)
1950 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1951 sel1, selected, cbp_sel1);
1952
1953 new_val = cbp_sel0 | (cbp_sel1 << 4);
1954
1955 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
1956 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
1957 AB8500_BATT_OK_REG, new_val);
1958 return ret;
1959 }
1960
1961 /**
1962 * ab8500_fg_instant_work() - Run the FG state machine instantly
1963 * @work: pointer to the work_struct structure
1964 *
1965 * Work queue function for instant work
1966 */
1967 static void ab8500_fg_instant_work(struct work_struct *work)
1968 {
1969 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
1970
1971 ab8500_fg_algorithm(di);
1972 }
1973
1974 /**
1975 * ab8500_fg_cc_data_end_handler() - end of data conversion isr.
1976 * @irq: interrupt number
1977 * @_di: pointer to the ab8500_fg structure
1978 *
1979 * Returns IRQ status(IRQ_HANDLED)
1980 */
1981 static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di)
1982 {
1983 struct ab8500_fg *di = _di;
1984 if (!di->nbr_cceoc_irq_cnt) {
1985 di->nbr_cceoc_irq_cnt++;
1986 complete(&di->ab8500_fg_started);
1987 } else {
1988 di->nbr_cceoc_irq_cnt = 0;
1989 complete(&di->ab8500_fg_complete);
1990 }
1991 return IRQ_HANDLED;
1992 }
1993
1994 /**
1995 * ab8500_fg_cc_int_calib_handler () - end of calibration isr.
1996 * @irq: interrupt number
1997 * @_di: pointer to the ab8500_fg structure
1998 *
1999 * Returns IRQ status(IRQ_HANDLED)
2000 */
2001 static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di)
2002 {
2003 struct ab8500_fg *di = _di;
2004 di->calib_state = AB8500_FG_CALIB_END;
2005 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2006 return IRQ_HANDLED;
2007 }
2008
2009 /**
2010 * ab8500_fg_cc_convend_handler() - isr to get battery avg current.
2011 * @irq: interrupt number
2012 * @_di: pointer to the ab8500_fg structure
2013 *
2014 * Returns IRQ status(IRQ_HANDLED)
2015 */
2016 static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di)
2017 {
2018 struct ab8500_fg *di = _di;
2019
2020 queue_work(di->fg_wq, &di->fg_acc_cur_work);
2021
2022 return IRQ_HANDLED;
2023 }
2024
2025 /**
2026 * ab8500_fg_batt_ovv_handler() - Battery OVV occured
2027 * @irq: interrupt number
2028 * @_di: pointer to the ab8500_fg structure
2029 *
2030 * Returns IRQ status(IRQ_HANDLED)
2031 */
2032 static irqreturn_t ab8500_fg_batt_ovv_handler(int irq, void *_di)
2033 {
2034 struct ab8500_fg *di = _di;
2035
2036 dev_dbg(di->dev, "Battery OVV\n");
2037
2038 /* Schedule a new HW failure check */
2039 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
2040
2041 return IRQ_HANDLED;
2042 }
2043
2044 /**
2045 * ab8500_fg_lowbatf_handler() - Battery voltage is below LOW threshold
2046 * @irq: interrupt number
2047 * @_di: pointer to the ab8500_fg structure
2048 *
2049 * Returns IRQ status(IRQ_HANDLED)
2050 */
2051 static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di)
2052 {
2053 struct ab8500_fg *di = _di;
2054
2055 /* Initiate handling in ab8500_fg_low_bat_work() if not already initiated. */
2056 if (!di->flags.low_bat_delay) {
2057 dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
2058 di->flags.low_bat_delay = true;
2059 /*
2060 * Start a timer to check LOW_BAT again after some time
2061 * This is done to avoid shutdown on single voltage dips
2062 */
2063 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
2064 round_jiffies(LOW_BAT_CHECK_INTERVAL));
2065 }
2066 return IRQ_HANDLED;
2067 }
2068
2069 /**
2070 * ab8500_fg_get_property() - get the fg properties
2071 * @psy: pointer to the power_supply structure
2072 * @psp: pointer to the power_supply_property structure
2073 * @val: pointer to the power_supply_propval union
2074 *
2075 * This function gets called when an application tries to get the
2076 * fg properties by reading the sysfs files.
2077 * voltage_now: battery voltage
2078 * current_now: battery instant current
2079 * current_avg: battery average current
2080 * charge_full_design: capacity where battery is considered full
2081 * charge_now: battery capacity in nAh
2082 * capacity: capacity in percent
2083 * capacity_level: capacity level
2084 *
2085 * Returns error code in case of failure else 0 on success
2086 */
2087 static int ab8500_fg_get_property(struct power_supply *psy,
2088 enum power_supply_property psp,
2089 union power_supply_propval *val)
2090 {
2091 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2092
2093 /*
2094 * If battery is identified as unknown and charging of unknown
2095 * batteries is disabled, we always report 100% capacity and
2096 * capacity level UNKNOWN, since we can't calculate
2097 * remaining capacity
2098 */
2099
2100 switch (psp) {
2101 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2102 if (di->flags.bat_ovv)
2103 val->intval = BATT_OVV_VALUE * 1000;
2104 else
2105 val->intval = di->vbat * 1000;
2106 break;
2107 case POWER_SUPPLY_PROP_CURRENT_NOW:
2108 val->intval = di->inst_curr * 1000;
2109 break;
2110 case POWER_SUPPLY_PROP_CURRENT_AVG:
2111 val->intval = di->avg_curr * 1000;
2112 break;
2113 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
2114 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2115 di->bat_cap.max_mah_design);
2116 break;
2117 case POWER_SUPPLY_PROP_ENERGY_FULL:
2118 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2119 di->bat_cap.max_mah);
2120 break;
2121 case POWER_SUPPLY_PROP_ENERGY_NOW:
2122 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2123 di->flags.batt_id_received)
2124 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2125 di->bat_cap.max_mah);
2126 else
2127 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2128 di->bat_cap.prev_mah);
2129 break;
2130 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
2131 val->intval = di->bat_cap.max_mah_design;
2132 break;
2133 case POWER_SUPPLY_PROP_CHARGE_FULL:
2134 val->intval = di->bat_cap.max_mah;
2135 break;
2136 case POWER_SUPPLY_PROP_CHARGE_NOW:
2137 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2138 di->flags.batt_id_received)
2139 val->intval = di->bat_cap.max_mah;
2140 else
2141 val->intval = di->bat_cap.prev_mah;
2142 break;
2143 case POWER_SUPPLY_PROP_CAPACITY:
2144 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2145 di->flags.batt_id_received)
2146 val->intval = 100;
2147 else
2148 val->intval = di->bat_cap.prev_percent;
2149 break;
2150 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
2151 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2152 di->flags.batt_id_received)
2153 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
2154 else
2155 val->intval = di->bat_cap.prev_level;
2156 break;
2157 default:
2158 return -EINVAL;
2159 }
2160 return 0;
2161 }
2162
2163 static int ab8500_fg_get_ext_psy_data(struct device *dev, void *data)
2164 {
2165 struct power_supply *psy;
2166 struct power_supply *ext = dev_get_drvdata(dev);
2167 const char **supplicants = (const char **)ext->supplied_to;
2168 struct ab8500_fg *di;
2169 union power_supply_propval ret;
2170 int j;
2171
2172 psy = (struct power_supply *)data;
2173 di = power_supply_get_drvdata(psy);
2174
2175 /*
2176 * For all psy where the name of your driver
2177 * appears in any supplied_to
2178 */
2179 j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
2180 if (j < 0)
2181 return 0;
2182
2183 /* Go through all properties for the psy */
2184 for (j = 0; j < ext->desc->num_properties; j++) {
2185 enum power_supply_property prop;
2186 prop = ext->desc->properties[j];
2187
2188 if (power_supply_get_property(ext, prop, &ret))
2189 continue;
2190
2191 switch (prop) {
2192 case POWER_SUPPLY_PROP_STATUS:
2193 switch (ext->desc->type) {
2194 case POWER_SUPPLY_TYPE_BATTERY:
2195 switch (ret.intval) {
2196 case POWER_SUPPLY_STATUS_UNKNOWN:
2197 case POWER_SUPPLY_STATUS_DISCHARGING:
2198 case POWER_SUPPLY_STATUS_NOT_CHARGING:
2199 if (!di->flags.charging)
2200 break;
2201 di->flags.charging = false;
2202 di->flags.fully_charged = false;
2203 if (di->bm->capacity_scaling)
2204 ab8500_fg_update_cap_scalers(di);
2205 queue_work(di->fg_wq, &di->fg_work);
2206 break;
2207 case POWER_SUPPLY_STATUS_FULL:
2208 if (di->flags.fully_charged)
2209 break;
2210 di->flags.fully_charged = true;
2211 di->flags.force_full = true;
2212 /* Save current capacity as maximum */
2213 di->bat_cap.max_mah = di->bat_cap.mah;
2214 queue_work(di->fg_wq, &di->fg_work);
2215 break;
2216 case POWER_SUPPLY_STATUS_CHARGING:
2217 if (di->flags.charging &&
2218 !di->flags.fully_charged)
2219 break;
2220 di->flags.charging = true;
2221 di->flags.fully_charged = false;
2222 if (di->bm->capacity_scaling)
2223 ab8500_fg_update_cap_scalers(di);
2224 queue_work(di->fg_wq, &di->fg_work);
2225 break;
2226 };
2227 default:
2228 break;
2229 };
2230 break;
2231 case POWER_SUPPLY_PROP_TECHNOLOGY:
2232 switch (ext->desc->type) {
2233 case POWER_SUPPLY_TYPE_BATTERY:
2234 if (!di->flags.batt_id_received &&
2235 di->bm->batt_id != BATTERY_UNKNOWN) {
2236 const struct abx500_battery_type *b;
2237
2238 b = &(di->bm->bat_type[di->bm->batt_id]);
2239
2240 di->flags.batt_id_received = true;
2241
2242 di->bat_cap.max_mah_design =
2243 MILLI_TO_MICRO *
2244 b->charge_full_design;
2245
2246 di->bat_cap.max_mah =
2247 di->bat_cap.max_mah_design;
2248
2249 di->vbat_nom = b->nominal_voltage;
2250 }
2251
2252 if (ret.intval)
2253 di->flags.batt_unknown = false;
2254 else
2255 di->flags.batt_unknown = true;
2256 break;
2257 default:
2258 break;
2259 }
2260 break;
2261 case POWER_SUPPLY_PROP_TEMP:
2262 switch (ext->desc->type) {
2263 case POWER_SUPPLY_TYPE_BATTERY:
2264 if (di->flags.batt_id_received)
2265 di->bat_temp = ret.intval;
2266 break;
2267 default:
2268 break;
2269 }
2270 break;
2271 default:
2272 break;
2273 }
2274 }
2275 return 0;
2276 }
2277
2278 /**
2279 * ab8500_fg_init_hw_registers() - Set up FG related registers
2280 * @di: pointer to the ab8500_fg structure
2281 *
2282 * Set up battery OVV, low battery voltage registers
2283 */
2284 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
2285 {
2286 int ret;
2287
2288 /* Set VBAT OVV threshold */
2289 ret = abx500_mask_and_set_register_interruptible(di->dev,
2290 AB8500_CHARGER,
2291 AB8500_BATT_OVV,
2292 BATT_OVV_TH_4P75,
2293 BATT_OVV_TH_4P75);
2294 if (ret) {
2295 dev_err(di->dev, "failed to set BATT_OVV\n");
2296 goto out;
2297 }
2298
2299 /* Enable VBAT OVV detection */
2300 ret = abx500_mask_and_set_register_interruptible(di->dev,
2301 AB8500_CHARGER,
2302 AB8500_BATT_OVV,
2303 BATT_OVV_ENA,
2304 BATT_OVV_ENA);
2305 if (ret) {
2306 dev_err(di->dev, "failed to enable BATT_OVV\n");
2307 goto out;
2308 }
2309
2310 /* Low Battery Voltage */
2311 ret = abx500_set_register_interruptible(di->dev,
2312 AB8500_SYS_CTRL2_BLOCK,
2313 AB8500_LOW_BAT_REG,
2314 ab8500_volt_to_regval(
2315 di->bm->fg_params->lowbat_threshold) << 1 |
2316 LOW_BAT_ENABLE);
2317 if (ret) {
2318 dev_err(di->dev, "%s write failed\n", __func__);
2319 goto out;
2320 }
2321
2322 /* Battery OK threshold */
2323 ret = ab8500_fg_battok_init_hw_register(di);
2324 if (ret) {
2325 dev_err(di->dev, "BattOk init write failed.\n");
2326 goto out;
2327 }
2328
2329 if (((is_ab8505(di->parent) || is_ab9540(di->parent)) &&
2330 abx500_get_chip_id(di->dev) >= AB8500_CUT2P0)
2331 || is_ab8540(di->parent)) {
2332 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2333 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
2334
2335 if (ret) {
2336 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
2337 goto out;
2338 };
2339
2340 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2341 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
2342
2343 if (ret) {
2344 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
2345 goto out;
2346 };
2347
2348 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2349 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
2350
2351 if (ret) {
2352 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
2353 goto out;
2354 };
2355
2356 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2357 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
2358
2359 if (ret) {
2360 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
2361 goto out;
2362 };
2363
2364 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2365 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
2366
2367 if (ret) {
2368 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
2369 goto out;
2370 };
2371 }
2372 out:
2373 return ret;
2374 }
2375
2376 /**
2377 * ab8500_fg_external_power_changed() - callback for power supply changes
2378 * @psy: pointer to the structure power_supply
2379 *
2380 * This function is the entry point of the pointer external_power_changed
2381 * of the structure power_supply.
2382 * This function gets executed when there is a change in any external power
2383 * supply that this driver needs to be notified of.
2384 */
2385 static void ab8500_fg_external_power_changed(struct power_supply *psy)
2386 {
2387 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2388
2389 class_for_each_device(power_supply_class, NULL,
2390 di->fg_psy, ab8500_fg_get_ext_psy_data);
2391 }
2392
2393 /**
2394 * ab8500_fg_reinit_work() - work to reset the FG algorithm
2395 * @work: pointer to the work_struct structure
2396 *
2397 * Used to reset the current battery capacity to be able to
2398 * retrigger a new voltage base capacity calculation. For
2399 * test and verification purpose.
2400 */
2401 static void ab8500_fg_reinit_work(struct work_struct *work)
2402 {
2403 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
2404 fg_reinit_work.work);
2405
2406 if (di->flags.calibrate == false) {
2407 dev_dbg(di->dev, "Resetting FG state machine to init.\n");
2408 ab8500_fg_clear_cap_samples(di);
2409 ab8500_fg_calc_cap_discharge_voltage(di, true);
2410 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
2411 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
2412 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2413
2414 } else {
2415 dev_err(di->dev, "Residual offset calibration ongoing "
2416 "retrying..\n");
2417 /* Wait one second until next try*/
2418 queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
2419 round_jiffies(1));
2420 }
2421 }
2422
2423 /* Exposure to the sysfs interface */
2424
2425 struct ab8500_fg_sysfs_entry {
2426 struct attribute attr;
2427 ssize_t (*show)(struct ab8500_fg *, char *);
2428 ssize_t (*store)(struct ab8500_fg *, const char *, size_t);
2429 };
2430
2431 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
2432 {
2433 return sprintf(buf, "%d\n", di->bat_cap.max_mah);
2434 }
2435
2436 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
2437 size_t count)
2438 {
2439 unsigned long charge_full;
2440 ssize_t ret;
2441
2442 ret = kstrtoul(buf, 10, &charge_full);
2443
2444 dev_dbg(di->dev, "Ret %zd charge_full %lu", ret, charge_full);
2445
2446 if (!ret) {
2447 di->bat_cap.max_mah = (int) charge_full;
2448 ret = count;
2449 }
2450 return ret;
2451 }
2452
2453 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
2454 {
2455 return sprintf(buf, "%d\n", di->bat_cap.prev_mah);
2456 }
2457
2458 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
2459 size_t count)
2460 {
2461 unsigned long charge_now;
2462 ssize_t ret;
2463
2464 ret = kstrtoul(buf, 10, &charge_now);
2465
2466 dev_dbg(di->dev, "Ret %zd charge_now %lu was %d",
2467 ret, charge_now, di->bat_cap.prev_mah);
2468
2469 if (!ret) {
2470 di->bat_cap.user_mah = (int) charge_now;
2471 di->flags.user_cap = true;
2472 ret = count;
2473 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2474 }
2475 return ret;
2476 }
2477
2478 static struct ab8500_fg_sysfs_entry charge_full_attr =
2479 __ATTR(charge_full, 0644, charge_full_show, charge_full_store);
2480
2481 static struct ab8500_fg_sysfs_entry charge_now_attr =
2482 __ATTR(charge_now, 0644, charge_now_show, charge_now_store);
2483
2484 static ssize_t
2485 ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf)
2486 {
2487 struct ab8500_fg_sysfs_entry *entry;
2488 struct ab8500_fg *di;
2489
2490 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2491 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2492
2493 if (!entry->show)
2494 return -EIO;
2495
2496 return entry->show(di, buf);
2497 }
2498 static ssize_t
2499 ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf,
2500 size_t count)
2501 {
2502 struct ab8500_fg_sysfs_entry *entry;
2503 struct ab8500_fg *di;
2504
2505 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2506 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2507
2508 if (!entry->store)
2509 return -EIO;
2510
2511 return entry->store(di, buf, count);
2512 }
2513
2514 static const struct sysfs_ops ab8500_fg_sysfs_ops = {
2515 .show = ab8500_fg_show,
2516 .store = ab8500_fg_store,
2517 };
2518
2519 static struct attribute *ab8500_fg_attrs[] = {
2520 &charge_full_attr.attr,
2521 &charge_now_attr.attr,
2522 NULL,
2523 };
2524
2525 static struct kobj_type ab8500_fg_ktype = {
2526 .sysfs_ops = &ab8500_fg_sysfs_ops,
2527 .default_attrs = ab8500_fg_attrs,
2528 };
2529
2530 /**
2531 * ab8500_fg_sysfs_exit() - de-init of sysfs entry
2532 * @di: pointer to the struct ab8500_chargalg
2533 *
2534 * This function removes the entry in sysfs.
2535 */
2536 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
2537 {
2538 kobject_del(&di->fg_kobject);
2539 }
2540
2541 /**
2542 * ab8500_fg_sysfs_init() - init of sysfs entry
2543 * @di: pointer to the struct ab8500_chargalg
2544 *
2545 * This function adds an entry in sysfs.
2546 * Returns error code in case of failure else 0(on success)
2547 */
2548 static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
2549 {
2550 int ret = 0;
2551
2552 ret = kobject_init_and_add(&di->fg_kobject,
2553 &ab8500_fg_ktype,
2554 NULL, "battery");
2555 if (ret < 0)
2556 dev_err(di->dev, "failed to create sysfs entry\n");
2557
2558 return ret;
2559 }
2560
2561 static ssize_t ab8505_powercut_flagtime_read(struct device *dev,
2562 struct device_attribute *attr,
2563 char *buf)
2564 {
2565 int ret;
2566 u8 reg_value;
2567 struct power_supply *psy = dev_get_drvdata(dev);
2568 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2569
2570 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2571 AB8505_RTC_PCUT_FLAG_TIME_REG, &reg_value);
2572
2573 if (ret < 0) {
2574 dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2575 goto fail;
2576 }
2577
2578 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2579
2580 fail:
2581 return ret;
2582 }
2583
2584 static ssize_t ab8505_powercut_flagtime_write(struct device *dev,
2585 struct device_attribute *attr,
2586 const char *buf, size_t count)
2587 {
2588 int ret;
2589 long unsigned reg_value;
2590 struct power_supply *psy = dev_get_drvdata(dev);
2591 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2592
2593 reg_value = simple_strtoul(buf, NULL, 10);
2594
2595 if (reg_value > 0x7F) {
2596 dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n");
2597 goto fail;
2598 }
2599
2600 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2601 AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value);
2602
2603 if (ret < 0)
2604 dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2605
2606 fail:
2607 return count;
2608 }
2609
2610 static ssize_t ab8505_powercut_maxtime_read(struct device *dev,
2611 struct device_attribute *attr,
2612 char *buf)
2613 {
2614 int ret;
2615 u8 reg_value;
2616 struct power_supply *psy = dev_get_drvdata(dev);
2617 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2618
2619 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2620 AB8505_RTC_PCUT_MAX_TIME_REG, &reg_value);
2621
2622 if (ret < 0) {
2623 dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n");
2624 goto fail;
2625 }
2626
2627 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2628
2629 fail:
2630 return ret;
2631
2632 }
2633
2634 static ssize_t ab8505_powercut_maxtime_write(struct device *dev,
2635 struct device_attribute *attr,
2636 const char *buf, size_t count)
2637 {
2638 int ret;
2639 int reg_value;
2640 struct power_supply *psy = dev_get_drvdata(dev);
2641 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2642
2643 reg_value = simple_strtoul(buf, NULL, 10);
2644 if (reg_value > 0x7F) {
2645 dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n");
2646 goto fail;
2647 }
2648
2649 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2650 AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value);
2651
2652 if (ret < 0)
2653 dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n");
2654
2655 fail:
2656 return count;
2657 }
2658
2659 static ssize_t ab8505_powercut_restart_read(struct device *dev,
2660 struct device_attribute *attr,
2661 char *buf)
2662 {
2663 int ret;
2664 u8 reg_value;
2665 struct power_supply *psy = dev_get_drvdata(dev);
2666 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2667
2668 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2669 AB8505_RTC_PCUT_RESTART_REG, &reg_value);
2670
2671 if (ret < 0) {
2672 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2673 goto fail;
2674 }
2675
2676 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF));
2677
2678 fail:
2679 return ret;
2680 }
2681
2682 static ssize_t ab8505_powercut_restart_write(struct device *dev,
2683 struct device_attribute *attr,
2684 const char *buf, size_t count)
2685 {
2686 int ret;
2687 int reg_value;
2688 struct power_supply *psy = dev_get_drvdata(dev);
2689 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2690
2691 reg_value = simple_strtoul(buf, NULL, 10);
2692 if (reg_value > 0xF) {
2693 dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n");
2694 goto fail;
2695 }
2696
2697 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2698 AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value);
2699
2700 if (ret < 0)
2701 dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n");
2702
2703 fail:
2704 return count;
2705
2706 }
2707
2708 static ssize_t ab8505_powercut_timer_read(struct device *dev,
2709 struct device_attribute *attr,
2710 char *buf)
2711 {
2712 int ret;
2713 u8 reg_value;
2714 struct power_supply *psy = dev_get_drvdata(dev);
2715 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2716
2717 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2718 AB8505_RTC_PCUT_TIME_REG, &reg_value);
2719
2720 if (ret < 0) {
2721 dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n");
2722 goto fail;
2723 }
2724
2725 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2726
2727 fail:
2728 return ret;
2729 }
2730
2731 static ssize_t ab8505_powercut_restart_counter_read(struct device *dev,
2732 struct device_attribute *attr,
2733 char *buf)
2734 {
2735 int ret;
2736 u8 reg_value;
2737 struct power_supply *psy = dev_get_drvdata(dev);
2738 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2739
2740 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2741 AB8505_RTC_PCUT_RESTART_REG, &reg_value);
2742
2743 if (ret < 0) {
2744 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2745 goto fail;
2746 }
2747
2748 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4);
2749
2750 fail:
2751 return ret;
2752 }
2753
2754 static ssize_t ab8505_powercut_read(struct device *dev,
2755 struct device_attribute *attr,
2756 char *buf)
2757 {
2758 int ret;
2759 u8 reg_value;
2760 struct power_supply *psy = dev_get_drvdata(dev);
2761 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2762
2763 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2764 AB8505_RTC_PCUT_CTL_STATUS_REG, &reg_value);
2765
2766 if (ret < 0)
2767 goto fail;
2768
2769 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1));
2770
2771 fail:
2772 return ret;
2773 }
2774
2775 static ssize_t ab8505_powercut_write(struct device *dev,
2776 struct device_attribute *attr,
2777 const char *buf, size_t count)
2778 {
2779 int ret;
2780 int reg_value;
2781 struct power_supply *psy = dev_get_drvdata(dev);
2782 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2783
2784 reg_value = simple_strtoul(buf, NULL, 10);
2785 if (reg_value > 0x1) {
2786 dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n");
2787 goto fail;
2788 }
2789
2790 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2791 AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value);
2792
2793 if (ret < 0)
2794 dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2795
2796 fail:
2797 return count;
2798 }
2799
2800 static ssize_t ab8505_powercut_flag_read(struct device *dev,
2801 struct device_attribute *attr,
2802 char *buf)
2803 {
2804
2805 int ret;
2806 u8 reg_value;
2807 struct power_supply *psy = dev_get_drvdata(dev);
2808 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2809
2810 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2811 AB8505_RTC_PCUT_CTL_STATUS_REG, &reg_value);
2812
2813 if (ret < 0) {
2814 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2815 goto fail;
2816 }
2817
2818 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4));
2819
2820 fail:
2821 return ret;
2822 }
2823
2824 static ssize_t ab8505_powercut_debounce_read(struct device *dev,
2825 struct device_attribute *attr,
2826 char *buf)
2827 {
2828 int ret;
2829 u8 reg_value;
2830 struct power_supply *psy = dev_get_drvdata(dev);
2831 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2832
2833 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2834 AB8505_RTC_PCUT_DEBOUNCE_REG, &reg_value);
2835
2836 if (ret < 0) {
2837 dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2838 goto fail;
2839 }
2840
2841 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7));
2842
2843 fail:
2844 return ret;
2845 }
2846
2847 static ssize_t ab8505_powercut_debounce_write(struct device *dev,
2848 struct device_attribute *attr,
2849 const char *buf, size_t count)
2850 {
2851 int ret;
2852 int reg_value;
2853 struct power_supply *psy = dev_get_drvdata(dev);
2854 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2855
2856 reg_value = simple_strtoul(buf, NULL, 10);
2857 if (reg_value > 0x7) {
2858 dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n");
2859 goto fail;
2860 }
2861
2862 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2863 AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value);
2864
2865 if (ret < 0)
2866 dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2867
2868 fail:
2869 return count;
2870 }
2871
2872 static ssize_t ab8505_powercut_enable_status_read(struct device *dev,
2873 struct device_attribute *attr,
2874 char *buf)
2875 {
2876 int ret;
2877 u8 reg_value;
2878 struct power_supply *psy = dev_get_drvdata(dev);
2879 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2880
2881 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2882 AB8505_RTC_PCUT_CTL_STATUS_REG, &reg_value);
2883
2884 if (ret < 0) {
2885 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2886 goto fail;
2887 }
2888
2889 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5));
2890
2891 fail:
2892 return ret;
2893 }
2894
2895 static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = {
2896 __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2897 ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write),
2898 __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2899 ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write),
2900 __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP),
2901 ab8505_powercut_restart_read, ab8505_powercut_restart_write),
2902 __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL),
2903 __ATTR(powercut_restart_counter, S_IRUGO,
2904 ab8505_powercut_restart_counter_read, NULL),
2905 __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP),
2906 ab8505_powercut_read, ab8505_powercut_write),
2907 __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL),
2908 __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP),
2909 ab8505_powercut_debounce_read, ab8505_powercut_debounce_write),
2910 __ATTR(powercut_enable_status, S_IRUGO,
2911 ab8505_powercut_enable_status_read, NULL),
2912 };
2913
2914 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
2915 {
2916 unsigned int i;
2917
2918 if (((is_ab8505(di->parent) || is_ab9540(di->parent)) &&
2919 abx500_get_chip_id(di->dev) >= AB8500_CUT2P0)
2920 || is_ab8540(di->parent)) {
2921 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2922 if (device_create_file(&di->fg_psy->dev,
2923 &ab8505_fg_sysfs_psy_attrs[i]))
2924 goto sysfs_psy_create_attrs_failed_ab8505;
2925 }
2926 return 0;
2927 sysfs_psy_create_attrs_failed_ab8505:
2928 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
2929 while (i--)
2930 device_remove_file(&di->fg_psy->dev,
2931 &ab8505_fg_sysfs_psy_attrs[i]);
2932
2933 return -EIO;
2934 }
2935
2936 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
2937 {
2938 unsigned int i;
2939
2940 if (((is_ab8505(di->parent) || is_ab9540(di->parent)) &&
2941 abx500_get_chip_id(di->dev) >= AB8500_CUT2P0)
2942 || is_ab8540(di->parent)) {
2943 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2944 (void)device_remove_file(&di->fg_psy->dev,
2945 &ab8505_fg_sysfs_psy_attrs[i]);
2946 }
2947 }
2948
2949 /* Exposure to the sysfs interface <<END>> */
2950
2951 #if defined(CONFIG_PM)
2952 static int ab8500_fg_resume(struct platform_device *pdev)
2953 {
2954 struct ab8500_fg *di = platform_get_drvdata(pdev);
2955
2956 /*
2957 * Change state if we're not charging. If we're charging we will wake
2958 * up on the FG IRQ
2959 */
2960 if (!di->flags.charging) {
2961 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
2962 queue_work(di->fg_wq, &di->fg_work);
2963 }
2964
2965 return 0;
2966 }
2967
2968 static int ab8500_fg_suspend(struct platform_device *pdev,
2969 pm_message_t state)
2970 {
2971 struct ab8500_fg *di = platform_get_drvdata(pdev);
2972
2973 flush_delayed_work(&di->fg_periodic_work);
2974 flush_work(&di->fg_work);
2975 flush_work(&di->fg_acc_cur_work);
2976 flush_delayed_work(&di->fg_reinit_work);
2977 flush_delayed_work(&di->fg_low_bat_work);
2978 flush_delayed_work(&di->fg_check_hw_failure_work);
2979
2980 /*
2981 * If the FG is enabled we will disable it before going to suspend
2982 * only if we're not charging
2983 */
2984 if (di->flags.fg_enabled && !di->flags.charging)
2985 ab8500_fg_coulomb_counter(di, false);
2986
2987 return 0;
2988 }
2989 #else
2990 #define ab8500_fg_suspend NULL
2991 #define ab8500_fg_resume NULL
2992 #endif
2993
2994 static int ab8500_fg_remove(struct platform_device *pdev)
2995 {
2996 int ret = 0;
2997 struct ab8500_fg *di = platform_get_drvdata(pdev);
2998
2999 list_del(&di->node);
3000
3001 /* Disable coulomb counter */
3002 ret = ab8500_fg_coulomb_counter(di, false);
3003 if (ret)
3004 dev_err(di->dev, "failed to disable coulomb counter\n");
3005
3006 destroy_workqueue(di->fg_wq);
3007 ab8500_fg_sysfs_exit(di);
3008
3009 flush_scheduled_work();
3010 ab8500_fg_sysfs_psy_remove_attrs(di);
3011 power_supply_unregister(di->fg_psy);
3012 return ret;
3013 }
3014
3015 /* ab8500 fg driver interrupts and their respective isr */
3016 static struct ab8500_fg_interrupts ab8500_fg_irq_th[] = {
3017 {"NCONV_ACCU", ab8500_fg_cc_convend_handler},
3018 {"BATT_OVV", ab8500_fg_batt_ovv_handler},
3019 {"LOW_BAT_F", ab8500_fg_lowbatf_handler},
3020 {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler},
3021 };
3022
3023 static struct ab8500_fg_interrupts ab8500_fg_irq_bh[] = {
3024 {"CCEOC", ab8500_fg_cc_data_end_handler},
3025 };
3026
3027 static char *supply_interface[] = {
3028 "ab8500_chargalg",
3029 "ab8500_usb",
3030 };
3031
3032 static const struct power_supply_desc ab8500_fg_desc = {
3033 .name = "ab8500_fg",
3034 .type = POWER_SUPPLY_TYPE_BATTERY,
3035 .properties = ab8500_fg_props,
3036 .num_properties = ARRAY_SIZE(ab8500_fg_props),
3037 .get_property = ab8500_fg_get_property,
3038 .external_power_changed = ab8500_fg_external_power_changed,
3039 };
3040
3041 static int ab8500_fg_probe(struct platform_device *pdev)
3042 {
3043 struct device_node *np = pdev->dev.of_node;
3044 struct abx500_bm_data *plat = pdev->dev.platform_data;
3045 struct power_supply_config psy_cfg = {};
3046 struct ab8500_fg *di;
3047 int i, irq;
3048 int ret = 0;
3049
3050 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
3051 if (!di) {
3052 dev_err(&pdev->dev, "%s no mem for ab8500_fg\n", __func__);
3053 return -ENOMEM;
3054 }
3055
3056 if (!plat) {
3057 dev_err(&pdev->dev, "no battery management data supplied\n");
3058 return -EINVAL;
3059 }
3060 di->bm = plat;
3061
3062 if (np) {
3063 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
3064 if (ret) {
3065 dev_err(&pdev->dev, "failed to get battery information\n");
3066 return ret;
3067 }
3068 }
3069
3070 mutex_init(&di->cc_lock);
3071
3072 /* get parent data */
3073 di->dev = &pdev->dev;
3074 di->parent = dev_get_drvdata(pdev->dev.parent);
3075 di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
3076
3077 psy_cfg.supplied_to = supply_interface;
3078 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3079 psy_cfg.drv_data = di;
3080
3081 di->bat_cap.max_mah_design = MILLI_TO_MICRO *
3082 di->bm->bat_type[di->bm->batt_id].charge_full_design;
3083
3084 di->bat_cap.max_mah = di->bat_cap.max_mah_design;
3085
3086 di->vbat_nom = di->bm->bat_type[di->bm->batt_id].nominal_voltage;
3087
3088 di->init_capacity = true;
3089
3090 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
3091 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
3092
3093 /* Create a work queue for running the FG algorithm */
3094 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
3095 if (di->fg_wq == NULL) {
3096 dev_err(di->dev, "failed to create work queue\n");
3097 return -ENOMEM;
3098 }
3099
3100 /* Init work for running the fg algorithm instantly */
3101 INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
3102
3103 /* Init work for getting the battery accumulated current */
3104 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
3105
3106 /* Init work for reinitialising the fg algorithm */
3107 INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
3108 ab8500_fg_reinit_work);
3109
3110 /* Work delayed Queue to run the state machine */
3111 INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
3112 ab8500_fg_periodic_work);
3113
3114 /* Work to check low battery condition */
3115 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
3116 ab8500_fg_low_bat_work);
3117
3118 /* Init work for HW failure check */
3119 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
3120 ab8500_fg_check_hw_failure_work);
3121
3122 /* Reset battery low voltage flag */
3123 di->flags.low_bat = false;
3124
3125 /* Initialize low battery counter */
3126 di->low_bat_cnt = 10;
3127
3128 /* Initialize OVV, and other registers */
3129 ret = ab8500_fg_init_hw_registers(di);
3130 if (ret) {
3131 dev_err(di->dev, "failed to initialize registers\n");
3132 goto free_inst_curr_wq;
3133 }
3134
3135 /* Consider battery unknown until we're informed otherwise */
3136 di->flags.batt_unknown = true;
3137 di->flags.batt_id_received = false;
3138
3139 /* Register FG power supply class */
3140 di->fg_psy = power_supply_register(di->dev, &ab8500_fg_desc, &psy_cfg);
3141 if (IS_ERR(di->fg_psy)) {
3142 dev_err(di->dev, "failed to register FG psy\n");
3143 ret = PTR_ERR(di->fg_psy);
3144 goto free_inst_curr_wq;
3145 }
3146
3147 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
3148 ab8500_fg_coulomb_counter(di, true);
3149
3150 /*
3151 * Initialize completion used to notify completion and start
3152 * of inst current
3153 */
3154 init_completion(&di->ab8500_fg_started);
3155 init_completion(&di->ab8500_fg_complete);
3156
3157 /* Register primary interrupt handlers */
3158 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq_th); i++) {
3159 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_th[i].name);
3160 ret = request_irq(irq, ab8500_fg_irq_th[i].isr,
3161 IRQF_SHARED | IRQF_NO_SUSPEND,
3162 ab8500_fg_irq_th[i].name, di);
3163
3164 if (ret != 0) {
3165 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3166 ab8500_fg_irq_th[i].name, irq, ret);
3167 goto free_irq;
3168 }
3169 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3170 ab8500_fg_irq_th[i].name, irq, ret);
3171 }
3172
3173 /* Register threaded interrupt handler */
3174 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_bh[0].name);
3175 ret = request_threaded_irq(irq, NULL, ab8500_fg_irq_bh[0].isr,
3176 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3177 ab8500_fg_irq_bh[0].name, di);
3178
3179 if (ret != 0) {
3180 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3181 ab8500_fg_irq_bh[0].name, irq, ret);
3182 goto free_irq;
3183 }
3184 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3185 ab8500_fg_irq_bh[0].name, irq, ret);
3186
3187 di->irq = platform_get_irq_byname(pdev, "CCEOC");
3188 disable_irq(di->irq);
3189 di->nbr_cceoc_irq_cnt = 0;
3190
3191 platform_set_drvdata(pdev, di);
3192
3193 ret = ab8500_fg_sysfs_init(di);
3194 if (ret) {
3195 dev_err(di->dev, "failed to create sysfs entry\n");
3196 goto free_irq;
3197 }
3198
3199 ret = ab8500_fg_sysfs_psy_create_attrs(di);
3200 if (ret) {
3201 dev_err(di->dev, "failed to create FG psy\n");
3202 ab8500_fg_sysfs_exit(di);
3203 goto free_irq;
3204 }
3205
3206 /* Calibrate the fg first time */
3207 di->flags.calibrate = true;
3208 di->calib_state = AB8500_FG_CALIB_INIT;
3209
3210 /* Use room temp as default value until we get an update from driver. */
3211 di->bat_temp = 210;
3212
3213 /* Run the FG algorithm */
3214 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
3215
3216 list_add_tail(&di->node, &ab8500_fg_list);
3217
3218 return ret;
3219
3220 free_irq:
3221 power_supply_unregister(di->fg_psy);
3222
3223 /* We also have to free all registered irqs */
3224 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq_th); i++) {
3225 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_th[i].name);
3226 free_irq(irq, di);
3227 }
3228 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_bh[0].name);
3229 free_irq(irq, di);
3230 free_inst_curr_wq:
3231 destroy_workqueue(di->fg_wq);
3232 return ret;
3233 }
3234
3235 static const struct of_device_id ab8500_fg_match[] = {
3236 { .compatible = "stericsson,ab8500-fg", },
3237 { },
3238 };
3239
3240 static struct platform_driver ab8500_fg_driver = {
3241 .probe = ab8500_fg_probe,
3242 .remove = ab8500_fg_remove,
3243 .suspend = ab8500_fg_suspend,
3244 .resume = ab8500_fg_resume,
3245 .driver = {
3246 .name = "ab8500-fg",
3247 .of_match_table = ab8500_fg_match,
3248 },
3249 };
3250
3251 static int __init ab8500_fg_init(void)
3252 {
3253 return platform_driver_register(&ab8500_fg_driver);
3254 }
3255
3256 static void __exit ab8500_fg_exit(void)
3257 {
3258 platform_driver_unregister(&ab8500_fg_driver);
3259 }
3260
3261 subsys_initcall_sync(ab8500_fg_init);
3262 module_exit(ab8500_fg_exit);
3263
3264 MODULE_LICENSE("GPL v2");
3265 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
3266 MODULE_ALIAS("platform:ab8500-fg");
3267 MODULE_DESCRIPTION("AB8500 Fuel Gauge driver");
CRIS linux kernel tree