projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
twl4030_charger: allow max_current to be managed via sysfs.
[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");
aca3c354
N		 485 /* reset current on each 'plug' event */
486 bci->ac_cur = 500000;
e4ae537e 487 twl4030_charger_update_current(bci);
297d716f
KK		 488 power_supply_changed(bci->ac);
489 power_supply_changed(bci->usb);
2e727f17
GI		 490
491 return IRQ_HANDLED;
492}
493
494/*
495 * TWL4030 BCI monitoring events
496 */
497static irqreturn_t twl4030_bci_interrupt(int irq, void *arg)
498{
499 struct twl4030_bci *bci = arg;
500 u8 irqs1, irqs2;
501 int ret;
502
503 ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs1,
504 TWL4030_INTERRUPTS_BCIISR1A);
505 if (ret < 0)
506 return IRQ_HANDLED;
507
508 ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs2,
509 TWL4030_INTERRUPTS_BCIISR2A);
510 if (ret < 0)
511 return IRQ_HANDLED;
512
513 dev_dbg(bci->dev, "BCI irq %02x %02x\n", irqs2, irqs1);
514
515 if (irqs1 & (TWL4030_ICHGLOW | TWL4030_ICHGEOC)) {
516 /* charger state change, inform the core */
297d716f
KK		 517 power_supply_changed(bci->ac);
518 power_supply_changed(bci->usb);
2e727f17 519 }
e4ae537e 520 twl4030_charger_update_current(bci);
2e727f17
GI		 521
522 /* various monitoring events, for now we just log them here */
523 if (irqs1 & (TWL4030_TBATOR2 | TWL4030_TBATOR1))
524 dev_warn(bci->dev, "battery temperature out of range\n");
525
526 if (irqs1 & TWL4030_BATSTS)
527 dev_crit(bci->dev, "battery disconnected\n");
528
529 if (irqs2 & TWL4030_VBATOV)
530 dev_crit(bci->dev, "VBAT overvoltage\n");
531
532 if (irqs2 & TWL4030_VBUSOV)
533 dev_crit(bci->dev, "VBUS overvoltage\n");
534
535 if (irqs2 & TWL4030_ACCHGOV)
536 dev_crit(bci->dev, "Ac charger overvoltage\n");
537
538 return IRQ_HANDLED;
539}
540
aca3c354
N		 541/*
542 * Provide "max_current" attribute in sysfs.
543 */
544static ssize_t
545twl4030_bci_max_current_store(struct device *dev, struct device_attribute *attr,
546 const char *buf, size_t n)
547{
548 struct twl4030_bci *bci = dev_get_drvdata(dev->parent);
549 int cur = 0;
550 int status = 0;
551 status = kstrtoint(buf, 10, &cur);
552 if (status)
553 return status;
554 if (cur < 0)
555 return -EINVAL;
556 if (dev == &bci->ac->dev)
557 bci->ac_cur = cur;
558 else
559 bci->usb_cur = cur;
560
561 twl4030_charger_update_current(bci);
562 return n;
563}
564
565/*
566 * sysfs max_current show
567 */
568static ssize_t twl4030_bci_max_current_show(struct device *dev,
569 struct device_attribute *attr, char *buf)
570{
571 int status = 0;
572 int cur = -1;
573 u8 bcictl1;
574 struct twl4030_bci *bci = dev_get_drvdata(dev->parent);
575
576 if (dev == &bci->ac->dev) {
577 if (!bci->ac_is_active)
578 cur = bci->ac_cur;
579 } else {
580 if (bci->ac_is_active)
581 cur = bci->usb_cur;
582 }
583 if (cur < 0) {
584 cur = twl4030bci_read_adc_val(TWL4030_BCIIREF1);
585 if (cur < 0)
586 return cur;
587 status = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
588 if (status < 0)
589 return status;
590 cur = regval2ua(cur, bcictl1 & TWL4030_CGAIN);
591 }
592 return scnprintf(buf, PAGE_SIZE, "%u\n", cur);
593}
594
595static DEVICE_ATTR(max_current, 0644, twl4030_bci_max_current_show,
596 twl4030_bci_max_current_store);
597
d6ccc442 598static void twl4030_bci_usb_work(struct work_struct *data)
2e727f17 599{
d6ccc442 600 struct twl4030_bci *bci = container_of(data, struct twl4030_bci, work);
2e727f17 601
d6ccc442 602 switch (bci->event) {
2e727f17
GI		 603 case USB_EVENT_VBUS:
604 case USB_EVENT_CHARGER:
605 twl4030_charger_enable_usb(bci, true);
606 break;
607 case USB_EVENT_NONE:
608 twl4030_charger_enable_usb(bci, false);
609 break;
610 }
d6ccc442
HK		 611}
612
613static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
614 void *priv)
615{
fcc8ebc9 616 struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, usb_nb);
d6ccc442
HK		 617
618 dev_dbg(bci->dev, "OTG notify %lu\n", val);
619
aca3c354
N		 620 /* reset current on each 'plug' event */
621 if (allow_usb)
622 bci->usb_cur = 500000;
623 else
624 bci->usb_cur = 100000;
625
d6ccc442
HK		 626 bci->event = val;
627 schedule_work(&bci->work);
2e727f17
GI		 628
629 return NOTIFY_OK;
630}
631
2e727f17
GI		 632static int twl4030_charger_get_current(void)
633{
634 int curr;
635 int ret;
636 u8 bcictl1;
637
638 curr = twl4030bci_read_adc_val(TWL4030_BCIICHG);
639 if (curr < 0)
640 return curr;
641
642 ret = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
643 if (ret)
644 return ret;
645
3b542f08 646 return regval2ua(curr, bcictl1 & TWL4030_CGAIN);
2e727f17
GI		 647}
648
649/*
650 * Returns the main charge FSM state
651 * Or < 0 on failure.
652 */
653static int twl4030bci_state(struct twl4030_bci *bci)
654{
655 int ret;
656 u8 state;
657
658 ret = twl4030_bci_read(TWL4030_BCIMSTATEC, &state);
659 if (ret) {
660 pr_err("twl4030_bci: error reading BCIMSTATEC\n");
661 return ret;
662 }
663
664 dev_dbg(bci->dev, "state: %02x\n", state);
665
666 return state;
667}
668
669static int twl4030_bci_state_to_status(int state)
670{
671 state &= TWL4030_MSTATEC_MASK;
672 if (TWL4030_MSTATEC_QUICK1 <= state && state <= TWL4030_MSTATEC_QUICK7)
673 return POWER_SUPPLY_STATUS_CHARGING;
674 else if (TWL4030_MSTATEC_COMPLETE1 <= state &&
675 state <= TWL4030_MSTATEC_COMPLETE4)
676 return POWER_SUPPLY_STATUS_FULL;
677 else
678 return POWER_SUPPLY_STATUS_NOT_CHARGING;
679}
680
681static int twl4030_bci_get_property(struct power_supply *psy,
682 enum power_supply_property psp,
683 union power_supply_propval *val)
684{
297d716f 685 struct twl4030_bci *bci = dev_get_drvdata(psy->dev.parent);
2e727f17
GI		 686 int is_charging;
687 int state;
688 int ret;
689
690 state = twl4030bci_state(bci);
691 if (state < 0)
692 return state;
693
297d716f 694 if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
2e727f17
GI		 695 is_charging = state & TWL4030_MSTATEC_USB;
696 else
697 is_charging = state & TWL4030_MSTATEC_AC;
698
699 switch (psp) {
700 case POWER_SUPPLY_PROP_STATUS:
701 if (is_charging)
702 val->intval = twl4030_bci_state_to_status(state);
703 else
704 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
705 break;
706 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
707 /* charging must be active for meaningful result */
708 if (!is_charging)
709 return -ENODATA;
297d716f 710 if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
2e727f17
GI		 711 ret = twl4030bci_read_adc_val(TWL4030_BCIVBUS);
712 if (ret < 0)
713 return ret;
714 /* BCIVBUS uses ADCIN8, 7/1023 V/step */
715 val->intval = ret * 6843;
716 } else {
717 ret = twl4030bci_read_adc_val(TWL4030_BCIVAC);
718 if (ret < 0)
719 return ret;
720 /* BCIVAC uses ADCIN11, 10/1023 V/step */
721 val->intval = ret * 9775;
722 }
723 break;
724 case POWER_SUPPLY_PROP_CURRENT_NOW:
725 if (!is_charging)
726 return -ENODATA;
727 /* current measurement is shared between AC and USB */
728 ret = twl4030_charger_get_current();
729 if (ret < 0)
730 return ret;
731 val->intval = ret;
732 break;
733 case POWER_SUPPLY_PROP_ONLINE:
734 val->intval = is_charging &&
735 twl4030_bci_state_to_status(state) !=
736 POWER_SUPPLY_STATUS_NOT_CHARGING;
737 break;
738 default:
739 return -EINVAL;
740 }
741
742 return 0;
743}
744
745static enum power_supply_property twl4030_charger_props[] = {
746 POWER_SUPPLY_PROP_STATUS,
747 POWER_SUPPLY_PROP_ONLINE,
748 POWER_SUPPLY_PROP_VOLTAGE_NOW,
749 POWER_SUPPLY_PROP_CURRENT_NOW,
750};
751
ec0b3802
N		 752#ifdef CONFIG_OF
753static const struct twl4030_bci_platform_data *
754twl4030_bci_parse_dt(struct device *dev)
755{
756 struct device_node *np = dev->of_node;
757 struct twl4030_bci_platform_data *pdata;
758 u32 num;
759
760 if (!np)
761 return NULL;
762 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
763 if (!pdata)
764 return pdata;
765
766 if (of_property_read_u32(np, "ti,bb-uvolt", &num) == 0)
767 pdata->bb_uvolt = num;
768 if (of_property_read_u32(np, "ti,bb-uamp", &num) == 0)
769 pdata->bb_uamp = num;
770 return pdata;
771}
772#else
773static inline const struct twl4030_bci_platform_data *
774twl4030_bci_parse_dt(struct device *dev)
775{
776 return NULL;
777}
778#endif
779
297d716f
KK		 780static const struct power_supply_desc twl4030_bci_ac_desc = {
781 .name = "twl4030_ac",
782 .type = POWER_SUPPLY_TYPE_MAINS,
783 .properties = twl4030_charger_props,
784 .num_properties = ARRAY_SIZE(twl4030_charger_props),
785 .get_property = twl4030_bci_get_property,
786};
787
788static const struct power_supply_desc twl4030_bci_usb_desc = {
789 .name = "twl4030_usb",
790 .type = POWER_SUPPLY_TYPE_USB,
791 .properties = twl4030_charger_props,
792 .num_properties = ARRAY_SIZE(twl4030_charger_props),
793 .get_property = twl4030_bci_get_property,
794};
795
7396f708 796static int twl4030_bci_probe(struct platform_device *pdev)
2e727f17
GI		 797{
798 struct twl4030_bci *bci;
ec0b3802 799 const struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
2e727f17 800 int ret;
28d48f04 801 u32 reg;
2e727f17 802
325b50aa 803 bci = devm_kzalloc(&pdev->dev, sizeof(*bci), GFP_KERNEL);
2e727f17
GI		 804 if (bci == NULL)
805 return -ENOMEM;
806
ec0b3802
N		 807 if (!pdata)
808 pdata = twl4030_bci_parse_dt(&pdev->dev);
809
1098cb58
N		 810 bci->ichg_eoc = 80100; /* Stop charging when current drops to here */
811 bci->ichg_lo = 241000; /* Low threshold */
812 bci->ichg_hi = 500000; /* High threshold */
e4ae537e 813 bci->ac_cur = 500000; /* 500mA */
1098cb58 814 if (allow_usb)
e4ae537e 815 bci->usb_cur = 500000; /* 500mA */
1098cb58 816 else
e4ae537e 817 bci->usb_cur = 100000; /* 100mA */
1098cb58 818
2e727f17
GI		 819 bci->dev = &pdev->dev;
820 bci->irq_chg = platform_get_irq(pdev, 0);
821 bci->irq_bci = platform_get_irq(pdev, 1);
822
61a7784e
NM		 823 /* Only proceed further *IF* battery is physically present */
824 ret = twl4030_is_battery_present(bci);
825 if (ret) {
826 dev_crit(&pdev->dev, "Battery was not detected:%d\n", ret);
325b50aa 827 return ret;
61a7784e 828 }
2e727f17 829
61a7784e 830 platform_set_drvdata(pdev, bci);
2e727f17 831
325b50aa
N		 832 bci->ac = devm_power_supply_register(&pdev->dev, &twl4030_bci_ac_desc,
833 NULL);
297d716f
KK		 834 if (IS_ERR(bci->ac)) {
835 ret = PTR_ERR(bci->ac);
2e727f17 836 dev_err(&pdev->dev, "failed to register ac: %d\n", ret);
325b50aa 837 return ret;
2e727f17
GI		 838 }
839
325b50aa
N		 840 bci->usb = devm_power_supply_register(&pdev->dev, &twl4030_bci_usb_desc,
841 NULL);
297d716f
KK		 842 if (IS_ERR(bci->usb)) {
843 ret = PTR_ERR(bci->usb);
2e727f17 844 dev_err(&pdev->dev, "failed to register usb: %d\n", ret);
325b50aa 845 return ret;
2e727f17
GI		 846 }
847
1b7cac23 848 ret = devm_request_threaded_irq(&pdev->dev, bci->irq_chg, NULL,
a2778b0f
FW		 849 twl4030_charger_interrupt, IRQF_ONESHOT, pdev->name,
850 bci);
2e727f17
GI		 851 if (ret < 0) {
852 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
853 bci->irq_chg, ret);
325b50aa 854 return ret;
2e727f17
GI		 855 }
856
1b7cac23 857 ret = devm_request_threaded_irq(&pdev->dev, bci->irq_bci, NULL,
a2778b0f 858 twl4030_bci_interrupt, IRQF_ONESHOT, pdev->name, bci);
2e727f17
GI		 859 if (ret < 0) {
860 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
861 bci->irq_bci, ret);
325b50aa 862 return ret;
2e727f17
GI		 863 }
864
d6ccc442
HK		 865 INIT_WORK(&bci->work, twl4030_bci_usb_work);
866
f5e4edb8
N		 867 bci->usb_nb.notifier_call = twl4030_bci_usb_ncb;
868 if (bci->dev->of_node) {
869 struct device_node *phynode;
870
871 phynode = of_find_compatible_node(bci->dev->of_node->parent,
872 NULL, "ti,twl4030-usb");
3fc3895e 873 if (phynode) {
f5e4edb8
N		 874 bci->transceiver = devm_usb_get_phy_by_node(
875 bci->dev, phynode, &bci->usb_nb);
3fc3895e
N		 876 if (IS_ERR(bci->transceiver) &&
877 PTR_ERR(bci->transceiver) == -EPROBE_DEFER)
878 return -EPROBE_DEFER;
879 }
2e727f17
GI		 880 }
881
882 /* Enable interrupts now. */
28d48f04 883 reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
2e727f17
GI		 884 TWL4030_TBATOR1 | TWL4030_BATSTS);
885 ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
886 TWL4030_INTERRUPTS_BCIIMR1A);
887 if (ret < 0) {
888 dev_err(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
325b50aa 889 return ret;
2e727f17
GI		 890 }
891
28d48f04 892 reg = ~(u32)(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
2e727f17
GI		 893 ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
894 TWL4030_INTERRUPTS_BCIIMR2A);
895 if (ret < 0)
896 dev_warn(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
897
1098cb58 898 twl4030_charger_update_current(bci);
aca3c354
N		 899 if (device_create_file(&bci->usb->dev, &dev_attr_max_current))
900 dev_warn(&pdev->dev, "could not create sysfs file\n");
901 if (device_create_file(&bci->ac->dev, &dev_attr_max_current))
902 dev_warn(&pdev->dev, "could not create sysfs file\n");
903
2e727f17 904 twl4030_charger_enable_ac(true);
6e37ec8c
N		 905 if (!IS_ERR_OR_NULL(bci->transceiver))
906 twl4030_bci_usb_ncb(&bci->usb_nb,
907 bci->transceiver->last_event,
908 NULL);
909 else
910 twl4030_charger_enable_usb(bci, false);
ec0b3802
N		 911 if (pdata)
912 twl4030_charger_enable_backup(pdata->bb_uvolt,
913 pdata->bb_uamp);
914 else
915 twl4030_charger_enable_backup(0, 0);
2e727f17
GI		 916
917 return 0;
2e727f17
GI		 918}
919
920static int __exit twl4030_bci_remove(struct platform_device *pdev)
921{
922 struct twl4030_bci *bci = platform_get_drvdata(pdev);
923
924 twl4030_charger_enable_ac(false);
925 twl4030_charger_enable_usb(bci, false);
210d4bc8 926 twl4030_charger_enable_backup(0, 0);
2e727f17 927
aca3c354
N		 928 device_remove_file(&bci->usb->dev, &dev_attr_max_current);
929 device_remove_file(&bci->ac->dev, &dev_attr_max_current);
2e727f17
GI		 930 /* mask interrupts */
931 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
932 TWL4030_INTERRUPTS_BCIIMR1A);
933 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
934 TWL4030_INTERRUPTS_BCIIMR2A);
935
2e727f17
GI		 936 return 0;
937}
938
ec0b3802
N		 939static const struct of_device_id twl_bci_of_match[] = {
940 {.compatible = "ti,twl4030-bci", },
941 { }
942};
943MODULE_DEVICE_TABLE(of, twl_bci_of_match);
944
2e727f17 945static struct platform_driver twl4030_bci_driver = {
7396f708 946 .probe = twl4030_bci_probe,
2e727f17
GI		 947 .driver = {
948 .name = "twl4030_bci",
ec0b3802 949 .of_match_table = of_match_ptr(twl_bci_of_match),
2e727f17
GI		 950 },
951 .remove = __exit_p(twl4030_bci_remove),
952};
7396f708 953module_platform_driver(twl4030_bci_driver);
2e727f17 954
28d48f04 955MODULE_AUTHOR("Gražvydas Ignotas");
2e727f17
GI		 956MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
957MODULE_LICENSE("GPL");
958MODULE_ALIAS("platform:twl4030_bci");
Linux 6.x block layer and io_uring tree(s)