?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / power / supply / smb347-charger.c
blobc1d124b8be0c2d3fb7b6c6f067a81e30b1fcb456
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Summit Microelectronics SMB347 Battery Charger Driver
4 *
5 * Copyright (C) 2011, Intel Corporation
6 *
7 * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
8 * Mika Westerberg <mika.westerberg@linux.intel.com>
9 */
10
11 #include <linux/err.h>
12 #include <linux/gpio.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/i2c.h>
18 #include <linux/mutex.h>
19 #include <linux/power_supply.h>
20 #include <linux/power/smb347-charger.h>
21 #include <linux/regmap.h>
22
23 /*
24 * Configuration registers. These are mirrored to volatile RAM and can be
25 * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
26 * reloaded from non-volatile registers after POR.
27 */
28 #define CFG_CHARGE_CURRENT 0x00
29 #define CFG_CHARGE_CURRENT_FCC_MASK 0xe0
30 #define CFG_CHARGE_CURRENT_FCC_SHIFT 5
31 #define CFG_CHARGE_CURRENT_PCC_MASK 0x18
32 #define CFG_CHARGE_CURRENT_PCC_SHIFT 3
33 #define CFG_CHARGE_CURRENT_TC_MASK 0x07
34 #define CFG_CURRENT_LIMIT 0x01
35 #define CFG_CURRENT_LIMIT_DC_MASK 0xf0
36 #define CFG_CURRENT_LIMIT_DC_SHIFT 4
37 #define CFG_CURRENT_LIMIT_USB_MASK 0x0f
38 #define CFG_FLOAT_VOLTAGE 0x03
39 #define CFG_FLOAT_VOLTAGE_FLOAT_MASK 0x3f
40 #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0
41 #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
42 #define CFG_STAT 0x05
43 #define CFG_STAT_DISABLED BIT(5)
44 #define CFG_STAT_ACTIVE_HIGH BIT(7)
45 #define CFG_PIN 0x06
46 #define CFG_PIN_EN_CTRL_MASK 0x60
47 #define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40
48 #define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60
49 #define CFG_PIN_EN_APSD_IRQ BIT(1)
50 #define CFG_PIN_EN_CHARGER_ERROR BIT(2)
51 #define CFG_THERM 0x07
52 #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03
53 #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
54 #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c
55 #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
56 #define CFG_THERM_MONITOR_DISABLED BIT(4)
57 #define CFG_SYSOK 0x08
58 #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2)
59 #define CFG_OTHER 0x09
60 #define CFG_OTHER_RID_MASK 0xc0
61 #define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0
62 #define CFG_OTG 0x0a
63 #define CFG_OTG_TEMP_THRESHOLD_MASK 0x30
64 #define CFG_OTG_TEMP_THRESHOLD_SHIFT 4
65 #define CFG_OTG_CC_COMPENSATION_MASK 0xc0
66 #define CFG_OTG_CC_COMPENSATION_SHIFT 6
67 #define CFG_TEMP_LIMIT 0x0b
68 #define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03
69 #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
70 #define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c
71 #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
72 #define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30
73 #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
74 #define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0
75 #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
76 #define CFG_FAULT_IRQ 0x0c
77 #define CFG_FAULT_IRQ_DCIN_UV BIT(2)
78 #define CFG_STATUS_IRQ 0x0d
79 #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4)
80 #define CFG_STATUS_IRQ_CHARGE_TIMEOUT BIT(7)
81 #define CFG_ADDRESS 0x0e
82
83 /* Command registers */
84 #define CMD_A 0x30
85 #define CMD_A_CHG_ENABLED BIT(1)
86 #define CMD_A_SUSPEND_ENABLED BIT(2)
87 #define CMD_A_ALLOW_WRITE BIT(7)
88 #define CMD_B 0x31
89 #define CMD_C 0x33
90
91 /* Interrupt Status registers */
92 #define IRQSTAT_A 0x35
93 #define IRQSTAT_C 0x37
94 #define IRQSTAT_C_TERMINATION_STAT BIT(0)
95 #define IRQSTAT_C_TERMINATION_IRQ BIT(1)
96 #define IRQSTAT_C_TAPER_IRQ BIT(3)
97 #define IRQSTAT_D 0x38
98 #define IRQSTAT_D_CHARGE_TIMEOUT_STAT BIT(2)
99 #define IRQSTAT_D_CHARGE_TIMEOUT_IRQ BIT(3)
100 #define IRQSTAT_E 0x39
101 #define IRQSTAT_E_USBIN_UV_STAT BIT(0)
102 #define IRQSTAT_E_USBIN_UV_IRQ BIT(1)
103 #define IRQSTAT_E_DCIN_UV_STAT BIT(4)
104 #define IRQSTAT_E_DCIN_UV_IRQ BIT(5)
105 #define IRQSTAT_F 0x3a
106
107 /* Status registers */
108 #define STAT_A 0x3b
109 #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
110 #define STAT_B 0x3c
111 #define STAT_C 0x3d
112 #define STAT_C_CHG_ENABLED BIT(0)
113 #define STAT_C_HOLDOFF_STAT BIT(3)
114 #define STAT_C_CHG_MASK 0x06
115 #define STAT_C_CHG_SHIFT 1
116 #define STAT_C_CHG_TERM BIT(5)
117 #define STAT_C_CHARGER_ERROR BIT(6)
118 #define STAT_E 0x3f
119
120 #define SMB347_MAX_REGISTER 0x3f
121
122 /**
123 * struct smb347_charger - smb347 charger instance
124 * @lock: protects concurrent access to online variables
125 * @dev: pointer to device
126 * @regmap: pointer to driver regmap
127 * @mains: power_supply instance for AC/DC power
128 * @usb: power_supply instance for USB power
129 * @battery: power_supply instance for battery
130 * @mains_online: is AC/DC input connected
131 * @usb_online: is USB input connected
132 * @charging_enabled: is charging enabled
133 * @pdata: pointer to platform data
134 */
135 struct smb347_charger {
136 struct mutex lock;
137 struct device *dev;
138 struct regmap *regmap;
139 struct power_supply *mains;
140 struct power_supply *usb;
141 struct power_supply *battery;
142 bool mains_online;
143 bool usb_online;
144 bool charging_enabled;
145 const struct smb347_charger_platform_data *pdata;
146 };
147
148 /* Fast charge current in uA */
149 static const unsigned int fcc_tbl[] = {
150 700000,
151 900000,
152 1200000,
153 1500000,
154 1800000,
155 2000000,
156 2200000,
157 2500000,
158 };
159
160 /* Pre-charge current in uA */
161 static const unsigned int pcc_tbl[] = {
162 100000,
163 150000,
164 200000,
165 250000,
166 };
167
168 /* Termination current in uA */
169 static const unsigned int tc_tbl[] = {
170 37500,
171 50000,
172 100000,
173 150000,
174 200000,
175 250000,
176 500000,
177 600000,
178 };
179
180 /* Input current limit in uA */
181 static const unsigned int icl_tbl[] = {
182 300000,
183 500000,
184 700000,
185 900000,
186 1200000,
187 1500000,
188 1800000,
189 2000000,
190 2200000,
191 2500000,
192 };
193
194 /* Charge current compensation in uA */
195 static const unsigned int ccc_tbl[] = {
196 250000,
197 700000,
198 900000,
199 1200000,
200 };
201
202 /* Convert register value to current using lookup table */
203 static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
204 {
205 if (val >= size)
206 return -EINVAL;
207 return tbl[val];
208 }
209
210 /* Convert current to register value using lookup table */
211 static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
212 {
213 size_t i;
214
215 for (i = 0; i < size; i++)
216 if (val < tbl[i])
217 break;
218 return i > 0 ? i - 1 : -EINVAL;
219 }
220
221 /**
222 * smb347_update_ps_status - refreshes the power source status
223 * @smb: pointer to smb347 charger instance
224 *
225 * Function checks whether any power source is connected to the charger and
226 * updates internal state accordingly. If there is a change to previous state
227 * function returns %1, otherwise %0 and negative errno in case of errror.
228 */
229 static int smb347_update_ps_status(struct smb347_charger *smb)
230 {
231 bool usb = false;
232 bool dc = false;
233 unsigned int val;
234 int ret;
235
236 ret = regmap_read(smb->regmap, IRQSTAT_E, &val);
237 if (ret < 0)
238 return ret;
239
240 /*
241 * Dc and usb are set depending on whether they are enabled in
242 * platform data _and_ whether corresponding undervoltage is set.
243 */
244 if (smb->pdata->use_mains)
245 dc = !(val & IRQSTAT_E_DCIN_UV_STAT);
246 if (smb->pdata->use_usb)
247 usb = !(val & IRQSTAT_E_USBIN_UV_STAT);
248
249 mutex_lock(&smb->lock);
250 ret = smb->mains_online != dc || smb->usb_online != usb;
251 smb->mains_online = dc;
252 smb->usb_online = usb;
253 mutex_unlock(&smb->lock);
254
255 return ret;
256 }
257
258 /*
259 * smb347_is_ps_online - returns whether input power source is connected
260 * @smb: pointer to smb347 charger instance
261 *
262 * Returns %true if input power source is connected. Note that this is
263 * dependent on what platform has configured for usable power sources. For
264 * example if USB is disabled, this will return %false even if the USB cable
265 * is connected.
266 */
267 static bool smb347_is_ps_online(struct smb347_charger *smb)
268 {
269 bool ret;
270
271 mutex_lock(&smb->lock);
272 ret = smb->usb_online || smb->mains_online;
273 mutex_unlock(&smb->lock);
274
275 return ret;
276 }
277
278 /**
279 * smb347_charging_status - returns status of charging
280 * @smb: pointer to smb347 charger instance
281 *
282 * Function returns charging status. %0 means no charging is in progress,
283 * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
284 */
285 static int smb347_charging_status(struct smb347_charger *smb)
286 {
287 unsigned int val;
288 int ret;
289
290 if (!smb347_is_ps_online(smb))
291 return 0;
292
293 ret = regmap_read(smb->regmap, STAT_C, &val);
294 if (ret < 0)
295 return 0;
296
297 return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
298 }
299
300 static int smb347_charging_set(struct smb347_charger *smb, bool enable)
301 {
302 int ret = 0;
303
304 if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) {
305 dev_dbg(smb->dev, "charging enable/disable in SW disabled\n");
306 return 0;
307 }
308
309 mutex_lock(&smb->lock);
310 if (smb->charging_enabled != enable) {
311 ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED,
312 enable ? CMD_A_CHG_ENABLED : 0);
313 if (!ret)
314 smb->charging_enabled = enable;
315 }
316 mutex_unlock(&smb->lock);
317 return ret;
318 }
319
320 static inline int smb347_charging_enable(struct smb347_charger *smb)
321 {
322 return smb347_charging_set(smb, true);
323 }
324
325 static inline int smb347_charging_disable(struct smb347_charger *smb)
326 {
327 return smb347_charging_set(smb, false);
328 }
329
330 static int smb347_start_stop_charging(struct smb347_charger *smb)
331 {
332 int ret;
333
334 /*
335 * Depending on whether valid power source is connected or not, we
336 * disable or enable the charging. We do it manually because it
337 * depends on how the platform has configured the valid inputs.
338 */
339 if (smb347_is_ps_online(smb)) {
340 ret = smb347_charging_enable(smb);
341 if (ret < 0)
342 dev_err(smb->dev, "failed to enable charging\n");
343 } else {
344 ret = smb347_charging_disable(smb);
345 if (ret < 0)
346 dev_err(smb->dev, "failed to disable charging\n");
347 }
348
349 return ret;
350 }
351
352 static int smb347_set_charge_current(struct smb347_charger *smb)
353 {
354 int ret;
355
356 if (smb->pdata->max_charge_current) {
357 ret = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl),
358 smb->pdata->max_charge_current);
359 if (ret < 0)
360 return ret;
361
362 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
363 CFG_CHARGE_CURRENT_FCC_MASK,
364 ret << CFG_CHARGE_CURRENT_FCC_SHIFT);
365 if (ret < 0)
366 return ret;
367 }
368
369 if (smb->pdata->pre_charge_current) {
370 ret = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl),
371 smb->pdata->pre_charge_current);
372 if (ret < 0)
373 return ret;
374
375 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
376 CFG_CHARGE_CURRENT_PCC_MASK,
377 ret << CFG_CHARGE_CURRENT_PCC_SHIFT);
378 if (ret < 0)
379 return ret;
380 }
381
382 if (smb->pdata->termination_current) {
383 ret = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl),
384 smb->pdata->termination_current);
385 if (ret < 0)
386 return ret;
387
388 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
389 CFG_CHARGE_CURRENT_TC_MASK, ret);
390 if (ret < 0)
391 return ret;
392 }
393
394 return 0;
395 }
396
397 static int smb347_set_current_limits(struct smb347_charger *smb)
398 {
399 int ret;
400
401 if (smb->pdata->mains_current_limit) {
402 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
403 smb->pdata->mains_current_limit);
404 if (ret < 0)
405 return ret;
406
407 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
408 CFG_CURRENT_LIMIT_DC_MASK,
409 ret << CFG_CURRENT_LIMIT_DC_SHIFT);
410 if (ret < 0)
411 return ret;
412 }
413
414 if (smb->pdata->usb_hc_current_limit) {
415 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
416 smb->pdata->usb_hc_current_limit);
417 if (ret < 0)
418 return ret;
419
420 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
421 CFG_CURRENT_LIMIT_USB_MASK, ret);
422 if (ret < 0)
423 return ret;
424 }
425
426 return 0;
427 }
428
429 static int smb347_set_voltage_limits(struct smb347_charger *smb)
430 {
431 int ret;
432
433 if (smb->pdata->pre_to_fast_voltage) {
434 ret = smb->pdata->pre_to_fast_voltage;
435
436 /* uV */
437 ret = clamp_val(ret, 2400000, 3000000) - 2400000;
438 ret /= 200000;
439
440 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
441 CFG_FLOAT_VOLTAGE_THRESHOLD_MASK,
442 ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT);
443 if (ret < 0)
444 return ret;
445 }
446
447 if (smb->pdata->max_charge_voltage) {
448 ret = smb->pdata->max_charge_voltage;
449
450 /* uV */
451 ret = clamp_val(ret, 3500000, 4500000) - 3500000;
452 ret /= 20000;
453
454 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
455 CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret);
456 if (ret < 0)
457 return ret;
458 }
459
460 return 0;
461 }
462
463 static int smb347_set_temp_limits(struct smb347_charger *smb)
464 {
465 bool enable_therm_monitor = false;
466 int ret = 0;
467 int val;
468
469 if (smb->pdata->chip_temp_threshold) {
470 val = smb->pdata->chip_temp_threshold;
471
472 /* degree C */
473 val = clamp_val(val, 100, 130) - 100;
474 val /= 10;
475
476 ret = regmap_update_bits(smb->regmap, CFG_OTG,
477 CFG_OTG_TEMP_THRESHOLD_MASK,
478 val << CFG_OTG_TEMP_THRESHOLD_SHIFT);
479 if (ret < 0)
480 return ret;
481 }
482
483 if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
484 val = smb->pdata->soft_cold_temp_limit;
485
486 val = clamp_val(val, 0, 15);
487 val /= 5;
488 /* this goes from higher to lower so invert the value */
489 val = ~val & 0x3;
490
491 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
492 CFG_TEMP_LIMIT_SOFT_COLD_MASK,
493 val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT);
494 if (ret < 0)
495 return ret;
496
497 enable_therm_monitor = true;
498 }
499
500 if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
501 val = smb->pdata->soft_hot_temp_limit;
502
503 val = clamp_val(val, 40, 55) - 40;
504 val /= 5;
505
506 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
507 CFG_TEMP_LIMIT_SOFT_HOT_MASK,
508 val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT);
509 if (ret < 0)
510 return ret;
511
512 enable_therm_monitor = true;
513 }
514
515 if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
516 val = smb->pdata->hard_cold_temp_limit;
517
518 val = clamp_val(val, -5, 10) + 5;
519 val /= 5;
520 /* this goes from higher to lower so invert the value */
521 val = ~val & 0x3;
522
523 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
524 CFG_TEMP_LIMIT_HARD_COLD_MASK,
525 val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT);
526 if (ret < 0)
527 return ret;
528
529 enable_therm_monitor = true;
530 }
531
532 if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
533 val = smb->pdata->hard_hot_temp_limit;
534
535 val = clamp_val(val, 50, 65) - 50;
536 val /= 5;
537
538 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
539 CFG_TEMP_LIMIT_HARD_HOT_MASK,
540 val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT);
541 if (ret < 0)
542 return ret;
543
544 enable_therm_monitor = true;
545 }
546
547 /*
548 * If any of the temperature limits are set, we also enable the
549 * thermistor monitoring.
550 *
551 * When soft limits are hit, the device will start to compensate
552 * current and/or voltage depending on the configuration.
553 *
554 * When hard limit is hit, the device will suspend charging
555 * depending on the configuration.
556 */
557 if (enable_therm_monitor) {
558 ret = regmap_update_bits(smb->regmap, CFG_THERM,
559 CFG_THERM_MONITOR_DISABLED, 0);
560 if (ret < 0)
561 return ret;
562 }
563
564 if (smb->pdata->suspend_on_hard_temp_limit) {
565 ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
566 CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0);
567 if (ret < 0)
568 return ret;
569 }
570
571 if (smb->pdata->soft_temp_limit_compensation !=
572 SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) {
573 val = smb->pdata->soft_temp_limit_compensation & 0x3;
574
575 ret = regmap_update_bits(smb->regmap, CFG_THERM,
576 CFG_THERM_SOFT_HOT_COMPENSATION_MASK,
577 val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT);
578 if (ret < 0)
579 return ret;
580
581 ret = regmap_update_bits(smb->regmap, CFG_THERM,
582 CFG_THERM_SOFT_COLD_COMPENSATION_MASK,
583 val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT);
584 if (ret < 0)
585 return ret;
586 }
587
588 if (smb->pdata->charge_current_compensation) {
589 val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl),
590 smb->pdata->charge_current_compensation);
591 if (val < 0)
592 return val;
593
594 ret = regmap_update_bits(smb->regmap, CFG_OTG,
595 CFG_OTG_CC_COMPENSATION_MASK,
596 (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT);
597 if (ret < 0)
598 return ret;
599 }
600
601 return ret;
602 }
603
604 /*
605 * smb347_set_writable - enables/disables writing to non-volatile registers
606 * @smb: pointer to smb347 charger instance
607 *
608 * You can enable/disable writing to the non-volatile configuration
609 * registers by calling this function.
610 *
611 * Returns %0 on success and negative errno in case of failure.
612 */
613 static int smb347_set_writable(struct smb347_charger *smb, bool writable)
614 {
615 return regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE,
616 writable ? CMD_A_ALLOW_WRITE : 0);
617 }
618
619 static int smb347_hw_init(struct smb347_charger *smb)
620 {
621 unsigned int val;
622 int ret;
623
624 ret = smb347_set_writable(smb, true);
625 if (ret < 0)
626 return ret;
627
628 /*
629 * Program the platform specific configuration values to the device
630 * first.
631 */
632 ret = smb347_set_charge_current(smb);
633 if (ret < 0)
634 goto fail;
635
636 ret = smb347_set_current_limits(smb);
637 if (ret < 0)
638 goto fail;
639
640 ret = smb347_set_voltage_limits(smb);
641 if (ret < 0)
642 goto fail;
643
644 ret = smb347_set_temp_limits(smb);
645 if (ret < 0)
646 goto fail;
647
648 /* If USB charging is disabled we put the USB in suspend mode */
649 if (!smb->pdata->use_usb) {
650 ret = regmap_update_bits(smb->regmap, CMD_A,
651 CMD_A_SUSPEND_ENABLED,
652 CMD_A_SUSPEND_ENABLED);
653 if (ret < 0)
654 goto fail;
655 }
656
657 /*
658 * If configured by platform data, we enable hardware Auto-OTG
659 * support for driving VBUS. Otherwise we disable it.
660 */
661 ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK,
662 smb->pdata->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0);
663 if (ret < 0)
664 goto fail;
665
666 /*
667 * Make the charging functionality controllable by a write to the
668 * command register unless pin control is specified in the platform
669 * data.
670 */
671 switch (smb->pdata->enable_control) {
672 case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW:
673 val = CFG_PIN_EN_CTRL_ACTIVE_LOW;
674 break;
675 case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH:
676 val = CFG_PIN_EN_CTRL_ACTIVE_HIGH;
677 break;
678 default:
679 val = 0;
680 break;
681 }
682
683 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK,
684 val);
685 if (ret < 0)
686 goto fail;
687
688 /* Disable Automatic Power Source Detection (APSD) interrupt. */
689 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0);
690 if (ret < 0)
691 goto fail;
692
693 ret = smb347_update_ps_status(smb);
694 if (ret < 0)
695 goto fail;
696
697 ret = smb347_start_stop_charging(smb);
698
699 fail:
700 smb347_set_writable(smb, false);
701 return ret;
702 }
703
704 static irqreturn_t smb347_interrupt(int irq, void *data)
705 {
706 struct smb347_charger *smb = data;
707 unsigned int stat_c, irqstat_c, irqstat_d, irqstat_e;
708 bool handled = false;
709 int ret;
710
711 ret = regmap_read(smb->regmap, STAT_C, &stat_c);
712 if (ret < 0) {
713 dev_warn(smb->dev, "reading STAT_C failed\n");
714 return IRQ_NONE;
715 }
716
717 ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c);
718 if (ret < 0) {
719 dev_warn(smb->dev, "reading IRQSTAT_C failed\n");
720 return IRQ_NONE;
721 }
722
723 ret = regmap_read(smb->regmap, IRQSTAT_D, &irqstat_d);
724 if (ret < 0) {
725 dev_warn(smb->dev, "reading IRQSTAT_D failed\n");
726 return IRQ_NONE;
727 }
728
729 ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e);
730 if (ret < 0) {
731 dev_warn(smb->dev, "reading IRQSTAT_E failed\n");
732 return IRQ_NONE;
733 }
734
735 /*
736 * If we get charger error we report the error back to user.
737 * If the error is recovered charging will resume again.
738 */
739 if (stat_c & STAT_C_CHARGER_ERROR) {
740 dev_err(smb->dev, "charging stopped due to charger error\n");
741 power_supply_changed(smb->battery);
742 handled = true;
743 }
744
745 /*
746 * If we reached the termination current the battery is charged and
747 * we can update the status now. Charging is automatically
748 * disabled by the hardware.
749 */
750 if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
751 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT)
752 power_supply_changed(smb->battery);
753 dev_dbg(smb->dev, "going to HW maintenance mode\n");
754 handled = true;
755 }
756
757 /*
758 * If we got a charger timeout INT that means the charge
759 * full is not detected with in charge timeout value.
760 */
761 if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_IRQ) {
762 dev_dbg(smb->dev, "total Charge Timeout INT received\n");
763
764 if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_STAT)
765 dev_warn(smb->dev, "charging stopped due to timeout\n");
766 power_supply_changed(smb->battery);
767 handled = true;
768 }
769
770 /*
771 * If we got an under voltage interrupt it means that AC/USB input
772 * was connected or disconnected.
773 */
774 if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
775 if (smb347_update_ps_status(smb) > 0) {
776 smb347_start_stop_charging(smb);
777 if (smb->pdata->use_mains)
778 power_supply_changed(smb->mains);
779 if (smb->pdata->use_usb)
780 power_supply_changed(smb->usb);
781 }
782 handled = true;
783 }
784
785 return handled ? IRQ_HANDLED : IRQ_NONE;
786 }
787
788 static int smb347_irq_set(struct smb347_charger *smb, bool enable)
789 {
790 int ret;
791
792 ret = smb347_set_writable(smb, true);
793 if (ret < 0)
794 return ret;
795
796 /*
797 * Enable/disable interrupts for:
798 * - under voltage
799 * - termination current reached
800 * - charger timeout
801 * - charger error
802 */
803 ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff,
804 enable ? CFG_FAULT_IRQ_DCIN_UV : 0);
805 if (ret < 0)
806 goto fail;
807
808 ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff,
809 enable ? (CFG_STATUS_IRQ_TERMINATION_OR_TAPER |
810 CFG_STATUS_IRQ_CHARGE_TIMEOUT) : 0);
811 if (ret < 0)
812 goto fail;
813
814 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR,
815 enable ? CFG_PIN_EN_CHARGER_ERROR : 0);
816 fail:
817 smb347_set_writable(smb, false);
818 return ret;
819 }
820
821 static inline int smb347_irq_enable(struct smb347_charger *smb)
822 {
823 return smb347_irq_set(smb, true);
824 }
825
826 static inline int smb347_irq_disable(struct smb347_charger *smb)
827 {
828 return smb347_irq_set(smb, false);
829 }
830
831 static int smb347_irq_init(struct smb347_charger *smb,
832 struct i2c_client *client)
833 {
834 const struct smb347_charger_platform_data *pdata = smb->pdata;
835 int ret, irq = gpio_to_irq(pdata->irq_gpio);
836
837 ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name);
838 if (ret < 0)
839 goto fail;
840
841 ret = request_threaded_irq(irq, NULL, smb347_interrupt,
842 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
843 client->name, smb);
844 if (ret < 0)
845 goto fail_gpio;
846
847 ret = smb347_set_writable(smb, true);
848 if (ret < 0)
849 goto fail_irq;
850
851 /*
852 * Configure the STAT output to be suitable for interrupts: disable
853 * all other output (except interrupts) and make it active low.
854 */
855 ret = regmap_update_bits(smb->regmap, CFG_STAT,
856 CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED,
857 CFG_STAT_DISABLED);
858 if (ret < 0)
859 goto fail_readonly;
860
861 smb347_set_writable(smb, false);
862 client->irq = irq;
863 return 0;
864
865 fail_readonly:
866 smb347_set_writable(smb, false);
867 fail_irq:
868 free_irq(irq, smb);
869 fail_gpio:
870 gpio_free(pdata->irq_gpio);
871 fail:
872 client->irq = 0;
873 return ret;
874 }
875
876 /*
877 * Returns the constant charge current programmed
878 * into the charger in uA.
879 */
880 static int get_const_charge_current(struct smb347_charger *smb)
881 {
882 int ret, intval;
883 unsigned int v;
884
885 if (!smb347_is_ps_online(smb))
886 return -ENODATA;
887
888 ret = regmap_read(smb->regmap, STAT_B, &v);
889 if (ret < 0)
890 return ret;
891
892 /*
893 * The current value is composition of FCC and PCC values
894 * and we can detect which table to use from bit 5.
895 */
896 if (v & 0x20) {
897 intval = hw_to_current(fcc_tbl, ARRAY_SIZE(fcc_tbl), v & 7);
898 } else {
899 v >>= 3;
900 intval = hw_to_current(pcc_tbl, ARRAY_SIZE(pcc_tbl), v & 7);
901 }
902
903 return intval;
904 }
905
906 /*
907 * Returns the constant charge voltage programmed
908 * into the charger in uV.
909 */
910 static int get_const_charge_voltage(struct smb347_charger *smb)
911 {
912 int ret, intval;
913 unsigned int v;
914
915 if (!smb347_is_ps_online(smb))
916 return -ENODATA;
917
918 ret = regmap_read(smb->regmap, STAT_A, &v);
919 if (ret < 0)
920 return ret;
921
922 v &= STAT_A_FLOAT_VOLTAGE_MASK;
923 if (v > 0x3d)
924 v = 0x3d;
925
926 intval = 3500000 + v * 20000;
927
928 return intval;
929 }
930
931 static int smb347_mains_get_property(struct power_supply *psy,
932 enum power_supply_property prop,
933 union power_supply_propval *val)
934 {
935 struct smb347_charger *smb = power_supply_get_drvdata(psy);
936 int ret;
937
938 switch (prop) {
939 case POWER_SUPPLY_PROP_ONLINE:
940 val->intval = smb->mains_online;
941 break;
942
943 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
944 ret = get_const_charge_voltage(smb);
945 if (ret < 0)
946 return ret;
947 else
948 val->intval = ret;
949 break;
950
951 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
952 ret = get_const_charge_current(smb);
953 if (ret < 0)
954 return ret;
955 else
956 val->intval = ret;
957 break;
958
959 default:
960 return -EINVAL;
961 }
962
963 return 0;
964 }
965
966 static enum power_supply_property smb347_mains_properties[] = {
967 POWER_SUPPLY_PROP_ONLINE,
968 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
969 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
970 };
971
972 static int smb347_usb_get_property(struct power_supply *psy,
973 enum power_supply_property prop,
974 union power_supply_propval *val)
975 {
976 struct smb347_charger *smb = power_supply_get_drvdata(psy);
977 int ret;
978
979 switch (prop) {
980 case POWER_SUPPLY_PROP_ONLINE:
981 val->intval = smb->usb_online;
982 break;
983
984 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
985 ret = get_const_charge_voltage(smb);
986 if (ret < 0)
987 return ret;
988 else
989 val->intval = ret;
990 break;
991
992 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
993 ret = get_const_charge_current(smb);
994 if (ret < 0)
995 return ret;
996 else
997 val->intval = ret;
998 break;
999
1000 default:
1001 return -EINVAL;
1002 }
1003
1004 return 0;
1005 }
1006
1007 static enum power_supply_property smb347_usb_properties[] = {
1008 POWER_SUPPLY_PROP_ONLINE,
1009 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1010 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1011 };
1012
1013 static int smb347_get_charging_status(struct smb347_charger *smb)
1014 {
1015 int ret, status;
1016 unsigned int val;
1017
1018 if (!smb347_is_ps_online(smb))
1019 return POWER_SUPPLY_STATUS_DISCHARGING;
1020
1021 ret = regmap_read(smb->regmap, STAT_C, &val);
1022 if (ret < 0)
1023 return ret;
1024
1025 if ((val & STAT_C_CHARGER_ERROR) ||
1026 (val & STAT_C_HOLDOFF_STAT)) {
1027 /*
1028 * set to NOT CHARGING upon charger error
1029 * or charging has stopped.
1030 */
1031 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1032 } else {
1033 if ((val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT) {
1034 /*
1035 * set to charging if battery is in pre-charge,
1036 * fast charge or taper charging mode.
1037 */
1038 status = POWER_SUPPLY_STATUS_CHARGING;
1039 } else if (val & STAT_C_CHG_TERM) {
1040 /*
1041 * set the status to FULL if battery is not in pre
1042 * charge, fast charge or taper charging mode AND
1043 * charging is terminated at least once.
1044 */
1045 status = POWER_SUPPLY_STATUS_FULL;
1046 } else {
1047 /*
1048 * in this case no charger error or termination
1049 * occured but charging is not in progress!!!
1050 */
1051 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1052 }
1053 }
1054
1055 return status;
1056 }
1057
1058 static int smb347_battery_get_property(struct power_supply *psy,
1059 enum power_supply_property prop,
1060 union power_supply_propval *val)
1061 {
1062 struct smb347_charger *smb = power_supply_get_drvdata(psy);
1063 const struct smb347_charger_platform_data *pdata = smb->pdata;
1064 int ret;
1065
1066 ret = smb347_update_ps_status(smb);
1067 if (ret < 0)
1068 return ret;
1069
1070 switch (prop) {
1071 case POWER_SUPPLY_PROP_STATUS:
1072 ret = smb347_get_charging_status(smb);
1073 if (ret < 0)
1074 return ret;
1075 val->intval = ret;
1076 break;
1077
1078 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1079 if (!smb347_is_ps_online(smb))
1080 return -ENODATA;
1081
1082 /*
1083 * We handle trickle and pre-charging the same, and taper
1084 * and none the same.
1085 */
1086 switch (smb347_charging_status(smb)) {
1087 case 1:
1088 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1089 break;
1090 case 2:
1091 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1092 break;
1093 default:
1094 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1095 break;
1096 }
1097 break;
1098
1099 case POWER_SUPPLY_PROP_TECHNOLOGY:
1100 val->intval = pdata->battery_info.technology;
1101 break;
1102
1103 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1104 val->intval = pdata->battery_info.voltage_min_design;
1105 break;
1106
1107 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1108 val->intval = pdata->battery_info.voltage_max_design;
1109 break;
1110
1111 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1112 val->intval = pdata->battery_info.charge_full_design;
1113 break;
1114
1115 case POWER_SUPPLY_PROP_MODEL_NAME:
1116 val->strval = pdata->battery_info.name;
1117 break;
1118
1119 default:
1120 return -EINVAL;
1121 }
1122
1123 return 0;
1124 }
1125
1126 static enum power_supply_property smb347_battery_properties[] = {
1127 POWER_SUPPLY_PROP_STATUS,
1128 POWER_SUPPLY_PROP_CHARGE_TYPE,
1129 POWER_SUPPLY_PROP_TECHNOLOGY,
1130 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1131 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1132 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1133 POWER_SUPPLY_PROP_MODEL_NAME,
1134 };
1135
1136 static bool smb347_volatile_reg(struct device *dev, unsigned int reg)
1137 {
1138 switch (reg) {
1139 case IRQSTAT_A:
1140 case IRQSTAT_C:
1141 case IRQSTAT_E:
1142 case IRQSTAT_F:
1143 case STAT_A:
1144 case STAT_B:
1145 case STAT_C:
1146 case STAT_E:
1147 return true;
1148 }
1149
1150 return false;
1151 }
1152
1153 static bool smb347_readable_reg(struct device *dev, unsigned int reg)
1154 {
1155 switch (reg) {
1156 case CFG_CHARGE_CURRENT:
1157 case CFG_CURRENT_LIMIT:
1158 case CFG_FLOAT_VOLTAGE:
1159 case CFG_STAT:
1160 case CFG_PIN:
1161 case CFG_THERM:
1162 case CFG_SYSOK:
1163 case CFG_OTHER:
1164 case CFG_OTG:
1165 case CFG_TEMP_LIMIT:
1166 case CFG_FAULT_IRQ:
1167 case CFG_STATUS_IRQ:
1168 case CFG_ADDRESS:
1169 case CMD_A:
1170 case CMD_B:
1171 case CMD_C:
1172 return true;
1173 }
1174
1175 return smb347_volatile_reg(dev, reg);
1176 }
1177
1178 static const struct regmap_config smb347_regmap = {
1179 .reg_bits = 8,
1180 .val_bits = 8,
1181 .max_register = SMB347_MAX_REGISTER,
1182 .volatile_reg = smb347_volatile_reg,
1183 .readable_reg = smb347_readable_reg,
1184 };
1185
1186 static const struct power_supply_desc smb347_mains_desc = {
1187 .name = "smb347-mains",
1188 .type = POWER_SUPPLY_TYPE_MAINS,
1189 .get_property = smb347_mains_get_property,
1190 .properties = smb347_mains_properties,
1191 .num_properties = ARRAY_SIZE(smb347_mains_properties),
1192 };
1193
1194 static const struct power_supply_desc smb347_usb_desc = {
1195 .name = "smb347-usb",
1196 .type = POWER_SUPPLY_TYPE_USB,
1197 .get_property = smb347_usb_get_property,
1198 .properties = smb347_usb_properties,
1199 .num_properties = ARRAY_SIZE(smb347_usb_properties),
1200 };
1201
1202 static const struct power_supply_desc smb347_battery_desc = {
1203 .name = "smb347-battery",
1204 .type = POWER_SUPPLY_TYPE_BATTERY,
1205 .get_property = smb347_battery_get_property,
1206 .properties = smb347_battery_properties,
1207 .num_properties = ARRAY_SIZE(smb347_battery_properties),
1208 };
1209
1210 static int smb347_probe(struct i2c_client *client,
1211 const struct i2c_device_id *id)
1212 {
1213 static char *battery[] = { "smb347-battery" };
1214 const struct smb347_charger_platform_data *pdata;
1215 struct power_supply_config mains_usb_cfg = {}, battery_cfg = {};
1216 struct device *dev = &client->dev;
1217 struct smb347_charger *smb;
1218 int ret;
1219
1220 pdata = dev->platform_data;
1221 if (!pdata)
1222 return -EINVAL;
1223
1224 if (!pdata->use_mains && !pdata->use_usb)
1225 return -EINVAL;
1226
1227 smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1228 if (!smb)
1229 return -ENOMEM;
1230
1231 i2c_set_clientdata(client, smb);
1232
1233 mutex_init(&smb->lock);
1234 smb->dev = &client->dev;
1235 smb->pdata = pdata;
1236
1237 smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap);
1238 if (IS_ERR(smb->regmap))
1239 return PTR_ERR(smb->regmap);
1240
1241 ret = smb347_hw_init(smb);
1242 if (ret < 0)
1243 return ret;
1244
1245 mains_usb_cfg.supplied_to = battery;
1246 mains_usb_cfg.num_supplicants = ARRAY_SIZE(battery);
1247 mains_usb_cfg.drv_data = smb;
1248 if (smb->pdata->use_mains) {
1249 smb->mains = power_supply_register(dev, &smb347_mains_desc,
1250 &mains_usb_cfg);
1251 if (IS_ERR(smb->mains))
1252 return PTR_ERR(smb->mains);
1253 }
1254
1255 if (smb->pdata->use_usb) {
1256 smb->usb = power_supply_register(dev, &smb347_usb_desc,
1257 &mains_usb_cfg);
1258 if (IS_ERR(smb->usb)) {
1259 if (smb->pdata->use_mains)
1260 power_supply_unregister(smb->mains);
1261 return PTR_ERR(smb->usb);
1262 }
1263 }
1264
1265 battery_cfg.drv_data = smb;
1266 smb->battery = power_supply_register(dev, &smb347_battery_desc,
1267 &battery_cfg);
1268 if (IS_ERR(smb->battery)) {
1269 if (smb->pdata->use_usb)
1270 power_supply_unregister(smb->usb);
1271 if (smb->pdata->use_mains)
1272 power_supply_unregister(smb->mains);
1273 return PTR_ERR(smb->battery);
1274 }
1275
1276 /*
1277 * Interrupt pin is optional. If it is connected, we setup the
1278 * interrupt support here.
1279 */
1280 if (pdata->irq_gpio >= 0) {
1281 ret = smb347_irq_init(smb, client);
1282 if (ret < 0) {
1283 dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
1284 dev_warn(dev, "disabling IRQ support\n");
1285 } else {
1286 smb347_irq_enable(smb);
1287 }
1288 }
1289
1290 return 0;
1291 }
1292
1293 static int smb347_remove(struct i2c_client *client)
1294 {
1295 struct smb347_charger *smb = i2c_get_clientdata(client);
1296
1297 if (client->irq) {
1298 smb347_irq_disable(smb);
1299 free_irq(client->irq, smb);
1300 gpio_free(smb->pdata->irq_gpio);
1301 }
1302
1303 power_supply_unregister(smb->battery);
1304 if (smb->pdata->use_usb)
1305 power_supply_unregister(smb->usb);
1306 if (smb->pdata->use_mains)
1307 power_supply_unregister(smb->mains);
1308 return 0;
1309 }
1310
1311 static const struct i2c_device_id smb347_id[] = {
1312 { "smb347", 0 },
1313 { }
1314 };
1315 MODULE_DEVICE_TABLE(i2c, smb347_id);
1316
1317 static struct i2c_driver smb347_driver = {
1318 .driver = {
1319 .name = "smb347",
1320 },
1321 .probe = smb347_probe,
1322 .remove = smb347_remove,
1323 .id_table = smb347_id,
1324 };
1325
1326 module_i2c_driver(smb347_driver);
1327
1328 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1329 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1330 MODULE_DESCRIPTION("SMB347 battery charger driver");
1331 MODULE_LICENSE("GPL");
Linux with added FPC-III support