twl4030_charger.c 29 KB

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