projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
twl4030_charger: distinguish between USB current and 'AC' current
[linux-2.6-block.git] / drivers / power / twl4030_charger.c
CommitLineData
2e727f17
GI		 1/*
2 * TWL4030/TPS65950 BCI (Battery Charger Interface) driver
3 *
4 * Copyright (C) 2010 Gražvydas Ignotas <notasas@gmail.com>
5 *
6 * based on twl4030_bci_battery.c by TI
7 * Copyright (C) 2008 Texas Instruments, Inc.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/slab.h>
ded017ee 18#include <linux/err.h>
2e727f17
GI		 19#include <linux/platform_device.h>
20#include <linux/interrupt.h>
21#include <linux/i2c/twl.h>
22#include <linux/power_supply.h>
23#include <linux/notifier.h>
24#include <linux/usb/otg.h>
e4ae537e 25#include <linux/i2c/twl4030-madc.h>
2e727f17
GI		 26
27#define TWL4030_BCIMSTATEC 0x02
28#define TWL4030_BCIICHG 0x08
29#define TWL4030_BCIVAC 0x0a
30#define TWL4030_BCIVBUS 0x0c
61a7784e 31#define TWL4030_BCIMFSTS3 0x0F
2e727f17
GI		 32#define TWL4030_BCIMFSTS4 0x10
33#define TWL4030_BCICTL1 0x23
210d4bc8 34#define TWL4030_BB_CFG 0x12
1098cb58
N		 35#define TWL4030_BCIIREF1 0x27
36#define TWL4030_BCIIREF2 0x28
37#define TWL4030_BCIMFKEY 0x11
38#define TWL4030_BCIMFTH8 0x1d
39#define TWL4030_BCIMFTH9 0x1e
2e727f17 40
61a7784e
NM		 41#define TWL4030_BCIMFSTS1 0x01
42
2e727f17
GI		 43#define TWL4030_BCIAUTOWEN BIT(5)
44#define TWL4030_CONFIG_DONE BIT(4)
45#define TWL4030_BCIAUTOUSB BIT(1)
46#define TWL4030_BCIAUTOAC BIT(0)
47#define TWL4030_CGAIN BIT(5)
48#define TWL4030_USBFASTMCHG BIT(2)
49#define TWL4030_STS_VBUS BIT(7)
50#define TWL4030_STS_USB_ID BIT(2)
210d4bc8 51#define TWL4030_BBCHEN BIT(4)
94b05cab
IH		 52#define TWL4030_BBSEL_MASK 0x0c
53#define TWL4030_BBSEL_2V5 0x00
54#define TWL4030_BBSEL_3V0 0x04
55#define TWL4030_BBSEL_3V1 0x08
56#define TWL4030_BBSEL_3V2 0x0c
57#define TWL4030_BBISEL_MASK 0x03
58#define TWL4030_BBISEL_25uA 0x00
59#define TWL4030_BBISEL_150uA 0x01
60#define TWL4030_BBISEL_500uA 0x02
61#define TWL4030_BBISEL_1000uA 0x03
2e727f17 62
61a7784e
NM		 63#define TWL4030_BATSTSPCHG BIT(2)
64#define TWL4030_BATSTSMCHG BIT(6)
65
2e727f17
GI		 66/* BCI interrupts */
67#define TWL4030_WOVF BIT(0) /* Watchdog overflow */
68#define TWL4030_TMOVF BIT(1) /* Timer overflow */
69#define TWL4030_ICHGHIGH BIT(2) /* Battery charge current high */
70#define TWL4030_ICHGLOW BIT(3) /* Battery cc. low / FSM state change */
71#define TWL4030_ICHGEOC BIT(4) /* Battery current end-of-charge */
72#define TWL4030_TBATOR2 BIT(5) /* Battery temperature out of range 2 */
73#define TWL4030_TBATOR1 BIT(6) /* Battery temperature out of range 1 */
74#define TWL4030_BATSTS BIT(7) /* Battery status */
75
76#define TWL4030_VBATLVL BIT(0) /* VBAT level */
77#define TWL4030_VBATOV BIT(1) /* VBAT overvoltage */
78#define TWL4030_VBUSOV BIT(2) /* VBUS overvoltage */
79#define TWL4030_ACCHGOV BIT(3) /* Ac charger overvoltage */
80
81#define TWL4030_MSTATEC_USB BIT(4)
82#define TWL4030_MSTATEC_AC BIT(5)
83#define TWL4030_MSTATEC_MASK 0x0f
84#define TWL4030_MSTATEC_QUICK1 0x02
85#define TWL4030_MSTATEC_QUICK7 0x07
86#define TWL4030_MSTATEC_COMPLETE1 0x0b
87#define TWL4030_MSTATEC_COMPLETE4 0x0e
88
89static bool allow_usb;
28d48f04 90module_param(allow_usb, bool, 0644);
2e727f17
GI		 91MODULE_PARM_DESC(allow_usb, "Allow USB charge drawing default current");
92
93struct twl4030_bci {
94 struct device *dev;
297d716f
KK		 95 struct power_supply *ac;
96 struct power_supply *usb;
86753811 97 struct usb_phy *transceiver;
fcc8ebc9 98 struct notifier_block usb_nb;
d6ccc442 99 struct work_struct work;
2e727f17
GI		 100 int irq_chg;
101 int irq_bci;
ab37813f 102 int usb_enabled;
d6ccc442 103
1098cb58 104 /*
e4ae537e
N		 105 * ichg_* and *_cur values in uA. If any are 'large', we set
106 * CGAIN to '1' which doubles the range for half the
107 * precision.
1098cb58 108 */
e4ae537e
N		 109 unsigned int ichg_eoc, ichg_lo, ichg_hi;
110 unsigned int usb_cur, ac_cur;
111 bool ac_is_active;
1098cb58 112
d6ccc442 113 unsigned long event;
2e727f17
GI		 114};
115
116/*
117 * clear and set bits on an given register on a given module
118 */
119static int twl4030_clear_set(u8 mod_no, u8 clear, u8 set, u8 reg)
120{
121 u8 val = 0;
122 int ret;
123
124 ret = twl_i2c_read_u8(mod_no, &val, reg);
125 if (ret)
126 return ret;
127
128 val &= ~clear;
129 val |= set;
130
131 return twl_i2c_write_u8(mod_no, val, reg);
132}
133
134static int twl4030_bci_read(u8 reg, u8 *val)
135{
e9f14c18 136 return twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, val, reg);
2e727f17
GI		 137}
138
139static int twl4030_clear_set_boot_bci(u8 clear, u8 set)
140{
e9f14c18 141 return twl4030_clear_set(TWL_MODULE_PM_MASTER, clear,
2e727f17
GI		 142 TWL4030_CONFIG_DONE | TWL4030_BCIAUTOWEN | set,
143 TWL4030_PM_MASTER_BOOT_BCI);
144}
145
146static int twl4030bci_read_adc_val(u8 reg)
147{
148 int ret, temp;
149 u8 val;
150
151 /* read MSB */
152 ret = twl4030_bci_read(reg + 1, &val);
153 if (ret)
154 return ret;
155
156 temp = (int)(val & 0x03) << 8;
157
158 /* read LSB */
159 ret = twl4030_bci_read(reg, &val);
160 if (ret)
161 return ret;
162
163 return temp | val;
164}
165
61a7784e
NM		 166/*
167 * Check if Battery Pack was present
168 */
169static int twl4030_is_battery_present(struct twl4030_bci *bci)
170{
171 int ret;
172 u8 val = 0;
173
174 /* Battery presence in Main charge? */
175 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val, TWL4030_BCIMFSTS3);
176 if (ret)
177 return ret;
178 if (val & TWL4030_BATSTSMCHG)
179 return 0;
180
181 /*
182 * OK, It could be that bootloader did not enable main charger,
183 * pre-charge is h/w auto. So, Battery presence in Pre-charge?
184 */
185 ret = twl_i2c_read_u8(TWL4030_MODULE_PRECHARGE, &val,
186 TWL4030_BCIMFSTS1);
187 if (ret)
188 return ret;
189 if (val & TWL4030_BATSTSPCHG)
190 return 0;
191
192 return -ENODEV;
193}
194
3b542f08
N		 195/*
196 * TI provided formulas:
197 * CGAIN == 0: ICHG = (BCIICHG * 1.7) / (2^10 - 1) - 0.85
198 * CGAIN == 1: ICHG = (BCIICHG * 3.4) / (2^10 - 1) - 1.7
199 * Here we use integer approximation of:
200 * CGAIN == 0: val * 1.6618 - 0.85 * 1000
201 * CGAIN == 1: (val * 1.6618 - 0.85 * 1000) * 2
202 */
203/*
204 * convert twl register value for currents into uA
205 */
206static int regval2ua(int regval, bool cgain)
207{
208 if (cgain)
209 return (regval * 16618 - 8500 * 1000) / 5;
210 else
211 return (regval * 16618 - 8500 * 1000) / 10;
212}
213
214/*
215 * convert uA currents into twl register value
216 */
217static int ua2regval(int ua, bool cgain)
218{
219 int ret;
220 if (cgain)
221 ua /= 2;
222 ret = (ua * 10 + 8500 * 1000) / 16618;
223 /* rounding problems */
224 if (ret < 512)
225 ret = 512;
226 return ret;
227}
228
1098cb58
N		 229static int twl4030_charger_update_current(struct twl4030_bci *bci)
230{
231 int status;
e4ae537e 232 int cur;
1098cb58
N		 233 unsigned reg, cur_reg;
234 u8 bcictl1, oldreg, fullreg;
235 bool cgain = false;
236 u8 boot_bci;
237
e4ae537e
N		 238 /*
239 * If AC (Accessory Charger) voltage exceeds 4.5V (MADC 11)
240 * and AC is enabled, set current for 'ac'
241 */
242 if (twl4030_get_madc_conversion(11) > 4500) {
243 cur = bci->ac_cur;
244 bci->ac_is_active = true;
245 } else {
246 cur = bci->usb_cur;
247 bci->ac_is_active = false;
248 }
249
1098cb58
N		 250 /* First, check thresholds and see if cgain is needed */
251 if (bci->ichg_eoc >= 200000)
252 cgain = true;
253 if (bci->ichg_lo >= 400000)
254 cgain = true;
255 if (bci->ichg_hi >= 820000)
256 cgain = true;
e4ae537e 257 if (cur > 852000)
1098cb58
N		 258 cgain = true;
259
260 status = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
261 if (status < 0)
262 return status;
263 if (twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &boot_bci,
264 TWL4030_PM_MASTER_BOOT_BCI) < 0)
265 boot_bci = 0;
266 boot_bci &= 7;
267
268 if ((!!cgain) != !!(bcictl1 & TWL4030_CGAIN))
269 /* Need to turn for charging while we change the
270 * CGAIN bit. Leave it off while everything is
271 * updated.
272 */
273 twl4030_clear_set_boot_bci(boot_bci, 0);
274
275 /*
276 * For ichg_eoc, the hardware only supports reg values matching
277 * 100XXXX000, and requires the XXXX be stored in the high nibble
278 * of TWL4030_BCIMFTH8.
279 */
280 reg = ua2regval(bci->ichg_eoc, cgain);
281 if (reg > 0x278)
282 reg = 0x278;
283 if (reg < 0x200)
284 reg = 0x200;
285 reg = (reg >> 3) & 0xf;
286 fullreg = reg << 4;
287
288 /*
289 * For ichg_lo, reg value must match 10XXXX0000.
290 * XXXX is stored in low nibble of TWL4030_BCIMFTH8.
291 */
292 reg = ua2regval(bci->ichg_lo, cgain);
293 if (reg > 0x2F0)
294 reg = 0x2F0;
295 if (reg < 0x200)
296 reg = 0x200;
297 reg = (reg >> 4) & 0xf;
298 fullreg |= reg;
299
300 /* ichg_eoc and ichg_lo live in same register */
301 status = twl4030_bci_read(TWL4030_BCIMFTH8, &oldreg);
302 if (status < 0)
303 return status;
304 if (oldreg != fullreg) {
305 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xF4,
306 TWL4030_BCIMFKEY);
307 if (status < 0)
308 return status;
309 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
310 fullreg, TWL4030_BCIMFTH8);
311 }
312
313 /* ichg_hi threshold must be 1XXXX01100 (I think) */
314 reg = ua2regval(bci->ichg_hi, cgain);
315 if (reg > 0x3E0)
316 reg = 0x3E0;
317 if (reg < 0x200)
318 reg = 0x200;
319 fullreg = (reg >> 5) & 0xF;
320 fullreg <<= 4;
321 status = twl4030_bci_read(TWL4030_BCIMFTH9, &oldreg);
322 if (status < 0)
323 return status;
324 if ((oldreg & 0xF0) != fullreg) {
325 fullreg |= (oldreg & 0x0F);
326 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
327 TWL4030_BCIMFKEY);
328 if (status < 0)
329 return status;
330 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
331 fullreg, TWL4030_BCIMFTH9);
332 }
333
334 /*
335 * And finally, set the current. This is stored in
336 * two registers.
337 */
e4ae537e 338 reg = ua2regval(cur, cgain);
1098cb58
N		 339 /* we have only 10 bits */
340 if (reg > 0x3ff)
341 reg = 0x3ff;
342 status = twl4030_bci_read(TWL4030_BCIIREF1, &oldreg);
343 if (status < 0)
344 return status;
345 cur_reg = oldreg;
346 status = twl4030_bci_read(TWL4030_BCIIREF2, &oldreg);
347 if (status < 0)
348 return status;
349 cur_reg |= oldreg << 8;
350 if (reg != oldreg) {
351 /* disable write protection for one write access for
352 * BCIIREF */
353 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
354 TWL4030_BCIMFKEY);
355 if (status < 0)
356 return status;
357 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
358 (reg & 0x100) ? 3 : 2,
359 TWL4030_BCIIREF2);
360 if (status < 0)
361 return status;
362 /* disable write protection for one write access for
363 * BCIIREF */
364 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
365 TWL4030_BCIMFKEY);
366 if (status < 0)
367 return status;
368 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
369 reg & 0xff,
370 TWL4030_BCIIREF1);
371 }
372 if ((!!cgain) != !!(bcictl1 & TWL4030_CGAIN)) {
373 /* Flip CGAIN and re-enable charging */
374 bcictl1 ^= TWL4030_CGAIN;
375 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
376 bcictl1, TWL4030_BCICTL1);
377 twl4030_clear_set_boot_bci(0, boot_bci);
378 }
379 return 0;
380}
381
2e727f17 382/*
9c645d2f 383 * Enable/Disable USB Charge functionality.
2e727f17
GI		 384 */
385static int twl4030_charger_enable_usb(struct twl4030_bci *bci, bool enable)
386{
387 int ret;
388
e57c4a67 389 if (enable && !IS_ERR_OR_NULL(bci->transceiver)) {
2e727f17 390
e4ae537e
N		 391 twl4030_charger_update_current(bci);
392
e57c4a67 393 /* Need to keep phy powered */
ab37813f 394 if (!bci->usb_enabled) {
e57c4a67 395 pm_runtime_get_sync(bci->transceiver->dev);
ab37813f
N		 396 bci->usb_enabled = 1;
397 }
398
2e727f17
GI		 399 /* forcing the field BCIAUTOUSB (BOOT_BCI[1]) to 1 */
400 ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOUSB);
401 if (ret < 0)
402 return ret;
403
404 /* forcing USBFASTMCHG(BCIMFSTS4[2]) to 1 */
e9f14c18 405 ret = twl4030_clear_set(TWL_MODULE_MAIN_CHARGE, 0,
2e727f17
GI		 406 TWL4030_USBFASTMCHG, TWL4030_BCIMFSTS4);
407 } else {
408 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOUSB, 0);
ab37813f 409 if (bci->usb_enabled) {
e57c4a67
N		 410 pm_runtime_mark_last_busy(bci->transceiver->dev);
411 pm_runtime_put_autosuspend(bci->transceiver->dev);
ab37813f
N		 412 bci->usb_enabled = 0;
413 }
2e727f17
GI		 414 }
415
416 return ret;
417}
418
419/*
420 * Enable/Disable AC Charge funtionality.
421 */
422static int twl4030_charger_enable_ac(bool enable)
423{
424 int ret;
425
426 if (enable)
427 ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOAC);
428 else
429 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOAC, 0);
430
431 return ret;
432}
433
210d4bc8
N		 434/*
435 * Enable/Disable charging of Backup Battery.
436 */
437static int twl4030_charger_enable_backup(int uvolt, int uamp)
438{
439 int ret;
440 u8 flags;
441
442 if (uvolt < 2500000 ||
443 uamp < 25) {
444 /* disable charging of backup battery */
e9f14c18 445 ret = twl4030_clear_set(TWL_MODULE_PM_RECEIVER,
210d4bc8
N		 446 TWL4030_BBCHEN, 0, TWL4030_BB_CFG);
447 return ret;
448 }
449
450 flags = TWL4030_BBCHEN;
451 if (uvolt >= 3200000)
452 flags |= TWL4030_BBSEL_3V2;
453 else if (uvolt >= 3100000)
454 flags |= TWL4030_BBSEL_3V1;
455 else if (uvolt >= 3000000)
456 flags |= TWL4030_BBSEL_3V0;
457 else
458 flags |= TWL4030_BBSEL_2V5;
459
460 if (uamp >= 1000)
461 flags |= TWL4030_BBISEL_1000uA;
462 else if (uamp >= 500)
463 flags |= TWL4030_BBISEL_500uA;
464 else if (uamp >= 150)
465 flags |= TWL4030_BBISEL_150uA;
466 else
467 flags |= TWL4030_BBISEL_25uA;
468
e9f14c18 469 ret = twl4030_clear_set(TWL_MODULE_PM_RECEIVER,
210d4bc8
N		 470 TWL4030_BBSEL_MASK | TWL4030_BBISEL_MASK,
471 flags,
472 TWL4030_BB_CFG);
473
474 return ret;
475}
476
2e727f17
GI		 477/*
478 * TWL4030 CHG_PRES (AC charger presence) events
479 */
480static irqreturn_t twl4030_charger_interrupt(int irq, void *arg)
481{
482 struct twl4030_bci *bci = arg;
483
484 dev_dbg(bci->dev, "CHG_PRES irq\n");
e4ae537e 485 twl4030_charger_update_current(bci);
297d716f
KK		 486 power_supply_changed(bci->ac);
487 power_supply_changed(bci->usb);
2e727f17
GI		 488
489 return IRQ_HANDLED;
490}
491
492/*
493 * TWL4030 BCI monitoring events
494 */
495static irqreturn_t twl4030_bci_interrupt(int irq, void *arg)
496{
497 struct twl4030_bci *bci = arg;
498 u8 irqs1, irqs2;
499 int ret;
500
501 ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs1,
502 TWL4030_INTERRUPTS_BCIISR1A);
503 if (ret < 0)
504 return IRQ_HANDLED;
505
506 ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs2,
507 TWL4030_INTERRUPTS_BCIISR2A);
508 if (ret < 0)
509 return IRQ_HANDLED;
510
511 dev_dbg(bci->dev, "BCI irq %02x %02x\n", irqs2, irqs1);
512
513 if (irqs1 & (TWL4030_ICHGLOW | TWL4030_ICHGEOC)) {
514 /* charger state change, inform the core */
297d716f
KK		 515 power_supply_changed(bci->ac);
516 power_supply_changed(bci->usb);
2e727f17 517 }
e4ae537e 518 twl4030_charger_update_current(bci);
2e727f17
GI		 519
520 /* various monitoring events, for now we just log them here */
521 if (irqs1 & (TWL4030_TBATOR2 | TWL4030_TBATOR1))
522 dev_warn(bci->dev, "battery temperature out of range\n");
523
524 if (irqs1 & TWL4030_BATSTS)
525 dev_crit(bci->dev, "battery disconnected\n");
526
527 if (irqs2 & TWL4030_VBATOV)
528 dev_crit(bci->dev, "VBAT overvoltage\n");
529
530 if (irqs2 & TWL4030_VBUSOV)
531 dev_crit(bci->dev, "VBUS overvoltage\n");
532
533 if (irqs2 & TWL4030_ACCHGOV)
534 dev_crit(bci->dev, "Ac charger overvoltage\n");
535
536 return IRQ_HANDLED;
537}
538
d6ccc442 539static void twl4030_bci_usb_work(struct work_struct *data)
2e727f17 540{
d6ccc442 541 struct twl4030_bci *bci = container_of(data, struct twl4030_bci, work);
2e727f17 542
d6ccc442 543 switch (bci->event) {
2e727f17
GI		 544 case USB_EVENT_VBUS:
545 case USB_EVENT_CHARGER:
546 twl4030_charger_enable_usb(bci, true);
547 break;
548 case USB_EVENT_NONE:
549 twl4030_charger_enable_usb(bci, false);
550 break;
551 }
d6ccc442
HK		 552}
553
554static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
555 void *priv)
556{
fcc8ebc9 557 struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, usb_nb);
d6ccc442
HK		 558
559 dev_dbg(bci->dev, "OTG notify %lu\n", val);
560
561 bci->event = val;
562 schedule_work(&bci->work);
2e727f17
GI		 563
564 return NOTIFY_OK;
565}
566
2e727f17
GI		 567static int twl4030_charger_get_current(void)
568{
569 int curr;
570 int ret;
571 u8 bcictl1;
572
573 curr = twl4030bci_read_adc_val(TWL4030_BCIICHG);
574 if (curr < 0)
575 return curr;
576
577 ret = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
578 if (ret)
579 return ret;
580
3b542f08 581 return regval2ua(curr, bcictl1 & TWL4030_CGAIN);
2e727f17
GI		 582}
583
584/*
585 * Returns the main charge FSM state
586 * Or < 0 on failure.
587 */
588static int twl4030bci_state(struct twl4030_bci *bci)
589{
590 int ret;
591 u8 state;
592
593 ret = twl4030_bci_read(TWL4030_BCIMSTATEC, &state);
594 if (ret) {
595 pr_err("twl4030_bci: error reading BCIMSTATEC\n");
596 return ret;
597 }
598
599 dev_dbg(bci->dev, "state: %02x\n", state);
600
601 return state;
602}
603
604static int twl4030_bci_state_to_status(int state)
605{
606 state &= TWL4030_MSTATEC_MASK;
607 if (TWL4030_MSTATEC_QUICK1 <= state && state <= TWL4030_MSTATEC_QUICK7)
608 return POWER_SUPPLY_STATUS_CHARGING;
609 else if (TWL4030_MSTATEC_COMPLETE1 <= state &&
610 state <= TWL4030_MSTATEC_COMPLETE4)
611 return POWER_SUPPLY_STATUS_FULL;
612 else
613 return POWER_SUPPLY_STATUS_NOT_CHARGING;
614}
615
616static int twl4030_bci_get_property(struct power_supply *psy,
617 enum power_supply_property psp,
618 union power_supply_propval *val)
619{
297d716f 620 struct twl4030_bci *bci = dev_get_drvdata(psy->dev.parent);
2e727f17
GI		 621 int is_charging;
622 int state;
623 int ret;
624
625 state = twl4030bci_state(bci);
626 if (state < 0)
627 return state;
628
297d716f 629 if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
2e727f17
GI		 630 is_charging = state & TWL4030_MSTATEC_USB;
631 else
632 is_charging = state & TWL4030_MSTATEC_AC;
633
634 switch (psp) {
635 case POWER_SUPPLY_PROP_STATUS:
636 if (is_charging)
637 val->intval = twl4030_bci_state_to_status(state);
638 else
639 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
640 break;
641 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
642 /* charging must be active for meaningful result */
643 if (!is_charging)
644 return -ENODATA;
297d716f 645 if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
2e727f17
GI		 646 ret = twl4030bci_read_adc_val(TWL4030_BCIVBUS);
647 if (ret < 0)
648 return ret;
649 /* BCIVBUS uses ADCIN8, 7/1023 V/step */
650 val->intval = ret * 6843;
651 } else {
652 ret = twl4030bci_read_adc_val(TWL4030_BCIVAC);
653 if (ret < 0)
654 return ret;
655 /* BCIVAC uses ADCIN11, 10/1023 V/step */
656 val->intval = ret * 9775;
657 }
658 break;
659 case POWER_SUPPLY_PROP_CURRENT_NOW:
660 if (!is_charging)
661 return -ENODATA;
662 /* current measurement is shared between AC and USB */
663 ret = twl4030_charger_get_current();
664 if (ret < 0)
665 return ret;
666 val->intval = ret;
667 break;
668 case POWER_SUPPLY_PROP_ONLINE:
669 val->intval = is_charging &&
670 twl4030_bci_state_to_status(state) !=
671 POWER_SUPPLY_STATUS_NOT_CHARGING;
672 break;
673 default:
674 return -EINVAL;
675 }
676
677 return 0;
678}
679
680static enum power_supply_property twl4030_charger_props[] = {
681 POWER_SUPPLY_PROP_STATUS,
682 POWER_SUPPLY_PROP_ONLINE,
683 POWER_SUPPLY_PROP_VOLTAGE_NOW,
684 POWER_SUPPLY_PROP_CURRENT_NOW,
685};
686
ec0b3802
N		 687#ifdef CONFIG_OF
688static const struct twl4030_bci_platform_data *
689twl4030_bci_parse_dt(struct device *dev)
690{
691 struct device_node *np = dev->of_node;
692 struct twl4030_bci_platform_data *pdata;
693 u32 num;
694
695 if (!np)
696 return NULL;
697 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
698 if (!pdata)
699 return pdata;
700
701 if (of_property_read_u32(np, "ti,bb-uvolt", &num) == 0)
702 pdata->bb_uvolt = num;
703 if (of_property_read_u32(np, "ti,bb-uamp", &num) == 0)
704 pdata->bb_uamp = num;
705 return pdata;
706}
707#else
708static inline const struct twl4030_bci_platform_data *
709twl4030_bci_parse_dt(struct device *dev)
710{
711 return NULL;
712}
713#endif
714
297d716f
KK		 715static const struct power_supply_desc twl4030_bci_ac_desc = {
716 .name = "twl4030_ac",
717 .type = POWER_SUPPLY_TYPE_MAINS,
718 .properties = twl4030_charger_props,
719 .num_properties = ARRAY_SIZE(twl4030_charger_props),
720 .get_property = twl4030_bci_get_property,
721};
722
723static const struct power_supply_desc twl4030_bci_usb_desc = {
724 .name = "twl4030_usb",
725 .type = POWER_SUPPLY_TYPE_USB,
726 .properties = twl4030_charger_props,
727 .num_properties = ARRAY_SIZE(twl4030_charger_props),
728 .get_property = twl4030_bci_get_property,
729};
730
7396f708 731static int twl4030_bci_probe(struct platform_device *pdev)
2e727f17
GI		 732{
733 struct twl4030_bci *bci;
ec0b3802 734 const struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
2e727f17 735 int ret;
28d48f04 736 u32 reg;
2e727f17 737
325b50aa 738 bci = devm_kzalloc(&pdev->dev, sizeof(*bci), GFP_KERNEL);
2e727f17
GI		 739 if (bci == NULL)
740 return -ENOMEM;
741
ec0b3802
N		 742 if (!pdata)
743 pdata = twl4030_bci_parse_dt(&pdev->dev);
744
1098cb58
N		 745 bci->ichg_eoc = 80100; /* Stop charging when current drops to here */
746 bci->ichg_lo = 241000; /* Low threshold */
747 bci->ichg_hi = 500000; /* High threshold */
e4ae537e 748 bci->ac_cur = 500000; /* 500mA */
1098cb58 749 if (allow_usb)
e4ae537e 750 bci->usb_cur = 500000; /* 500mA */
1098cb58 751 else
e4ae537e 752 bci->usb_cur = 100000; /* 100mA */
1098cb58 753
2e727f17
GI		 754 bci->dev = &pdev->dev;
755 bci->irq_chg = platform_get_irq(pdev, 0);
756 bci->irq_bci = platform_get_irq(pdev, 1);
757
61a7784e
NM		 758 /* Only proceed further *IF* battery is physically present */
759 ret = twl4030_is_battery_present(bci);
760 if (ret) {
761 dev_crit(&pdev->dev, "Battery was not detected:%d\n", ret);
325b50aa 762 return ret;
61a7784e 763 }
2e727f17 764
61a7784e 765 platform_set_drvdata(pdev, bci);
2e727f17 766
325b50aa
N		 767 bci->ac = devm_power_supply_register(&pdev->dev, &twl4030_bci_ac_desc,
768 NULL);
297d716f
KK		 769 if (IS_ERR(bci->ac)) {
770 ret = PTR_ERR(bci->ac);
2e727f17 771 dev_err(&pdev->dev, "failed to register ac: %d\n", ret);
325b50aa 772 return ret;
2e727f17
GI		 773 }
774
325b50aa
N		 775 bci->usb = devm_power_supply_register(&pdev->dev, &twl4030_bci_usb_desc,
776 NULL);
297d716f
KK		 777 if (IS_ERR(bci->usb)) {
778 ret = PTR_ERR(bci->usb);
2e727f17 779 dev_err(&pdev->dev, "failed to register usb: %d\n", ret);
325b50aa 780 return ret;
2e727f17
GI		 781 }
782
1b7cac23 783 ret = devm_request_threaded_irq(&pdev->dev, bci->irq_chg, NULL,
a2778b0f
FW		 784 twl4030_charger_interrupt, IRQF_ONESHOT, pdev->name,
785 bci);
2e727f17
GI		 786 if (ret < 0) {
787 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
788 bci->irq_chg, ret);
325b50aa 789 return ret;
2e727f17
GI		 790 }
791
1b7cac23 792 ret = devm_request_threaded_irq(&pdev->dev, bci->irq_bci, NULL,
a2778b0f 793 twl4030_bci_interrupt, IRQF_ONESHOT, pdev->name, bci);
2e727f17
GI		 794 if (ret < 0) {
795 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
796 bci->irq_bci, ret);
325b50aa 797 return ret;
2e727f17
GI		 798 }
799
d6ccc442
HK		 800 INIT_WORK(&bci->work, twl4030_bci_usb_work);
801
f5e4edb8
N		 802 bci->usb_nb.notifier_call = twl4030_bci_usb_ncb;
803 if (bci->dev->of_node) {
804 struct device_node *phynode;
805
806 phynode = of_find_compatible_node(bci->dev->of_node->parent,
807 NULL, "ti,twl4030-usb");
3fc3895e 808 if (phynode) {
f5e4edb8
N		 809 bci->transceiver = devm_usb_get_phy_by_node(
810 bci->dev, phynode, &bci->usb_nb);
3fc3895e
N		 811 if (IS_ERR(bci->transceiver) &&
812 PTR_ERR(bci->transceiver) == -EPROBE_DEFER)
813 return -EPROBE_DEFER;
814 }
2e727f17
GI		 815 }
816
817 /* Enable interrupts now. */
28d48f04 818 reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
2e727f17
GI		 819 TWL4030_TBATOR1 | TWL4030_BATSTS);
820 ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
821 TWL4030_INTERRUPTS_BCIIMR1A);
822 if (ret < 0) {
823 dev_err(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
325b50aa 824 return ret;
2e727f17
GI		 825 }
826
28d48f04 827 reg = ~(u32)(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
2e727f17
GI		 828 ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
829 TWL4030_INTERRUPTS_BCIIMR2A);
830 if (ret < 0)
831 dev_warn(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
832
1098cb58 833 twl4030_charger_update_current(bci);
2e727f17 834 twl4030_charger_enable_ac(true);
6e37ec8c
N		 835 if (!IS_ERR_OR_NULL(bci->transceiver))
836 twl4030_bci_usb_ncb(&bci->usb_nb,
837 bci->transceiver->last_event,
838 NULL);
839 else
840 twl4030_charger_enable_usb(bci, false);
ec0b3802
N		 841 if (pdata)
842 twl4030_charger_enable_backup(pdata->bb_uvolt,
843 pdata->bb_uamp);
844 else
845 twl4030_charger_enable_backup(0, 0);
2e727f17
GI		 846
847 return 0;
2e727f17
GI		 848}
849
850static int __exit twl4030_bci_remove(struct platform_device *pdev)
851{
852 struct twl4030_bci *bci = platform_get_drvdata(pdev);
853
854 twl4030_charger_enable_ac(false);
855 twl4030_charger_enable_usb(bci, false);
210d4bc8 856 twl4030_charger_enable_backup(0, 0);
2e727f17
GI		 857
858 /* mask interrupts */
859 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
860 TWL4030_INTERRUPTS_BCIIMR1A);
861 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
862 TWL4030_INTERRUPTS_BCIIMR2A);
863
2e727f17
GI		 864 return 0;
865}
866
ec0b3802
N		 867static const struct of_device_id twl_bci_of_match[] = {
868 {.compatible = "ti,twl4030-bci", },
869 { }
870};
871MODULE_DEVICE_TABLE(of, twl_bci_of_match);
872
2e727f17 873static struct platform_driver twl4030_bci_driver = {
7396f708 874 .probe = twl4030_bci_probe,
2e727f17
GI		 875 .driver = {
876 .name = "twl4030_bci",
ec0b3802 877 .of_match_table = of_match_ptr(twl_bci_of_match),
2e727f17
GI		 878 },
879 .remove = __exit_p(twl4030_bci_remove),
880};
7396f708 881module_platform_driver(twl4030_bci_driver);
2e727f17 882
28d48f04 883MODULE_AUTHOR("Gražvydas Ignotas");
2e727f17
GI		 884MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
885MODULE_LICENSE("GPL");
886MODULE_ALIAS("platform:twl4030_bci");
Linux 6.x block layer and io_uring tree(s)