bq27xxx_battery.c 58 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * BQ27xxx battery driver
  4. *
  5. * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
  6. * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
  7. * Copyright (C) 2010-2011 Lars-Peter Clausen <lars@metafoo.de>
  8. * Copyright (C) 2011 Pali Rohár <pali@kernel.org>
  9. * Copyright (C) 2017 Liam Breck <kernel@networkimprov.net>
  10. *
  11. * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
  12. *
  13. * Datasheets:
  14. * https://www.ti.com/product/bq27000
  15. * https://www.ti.com/product/bq27200
  16. * https://www.ti.com/product/bq27010
  17. * https://www.ti.com/product/bq27210
  18. * https://www.ti.com/product/bq27500
  19. * https://www.ti.com/product/bq27510-g1
  20. * https://www.ti.com/product/bq27510-g2
  21. * https://www.ti.com/product/bq27510-g3
  22. * https://www.ti.com/product/bq27520-g1
  23. * https://www.ti.com/product/bq27520-g2
  24. * https://www.ti.com/product/bq27520-g3
  25. * https://www.ti.com/product/bq27520-g4
  26. * https://www.ti.com/product/bq27530-g1
  27. * https://www.ti.com/product/bq27531-g1
  28. * https://www.ti.com/product/bq27541-g1
  29. * https://www.ti.com/product/bq27542-g1
  30. * https://www.ti.com/product/bq27546-g1
  31. * https://www.ti.com/product/bq27742-g1
  32. * https://www.ti.com/product/bq27545-g1
  33. * https://www.ti.com/product/bq27421-g1
  34. * https://www.ti.com/product/bq27425-g1
  35. * https://www.ti.com/product/bq27426
  36. * https://www.ti.com/product/bq27411-g1
  37. * https://www.ti.com/product/bq27441-g1
  38. * https://www.ti.com/product/bq27621-g1
  39. * https://www.ti.com/product/bq27z561
  40. * https://www.ti.com/product/bq28z610
  41. * https://www.ti.com/product/bq34z100-g1
  42. */
  43. #include <linux/device.h>
  44. #include <linux/module.h>
  45. #include <linux/mutex.h>
  46. #include <linux/param.h>
  47. #include <linux/jiffies.h>
  48. #include <linux/workqueue.h>
  49. #include <linux/delay.h>
  50. #include <linux/platform_device.h>
  51. #include <linux/power_supply.h>
  52. #include <linux/slab.h>
  53. #include <linux/of.h>
  54. #include <linux/power/bq27xxx_battery.h>
  55. #define BQ27XXX_MANUFACTURER "Texas Instruments"
  56. /* BQ27XXX Flags */
  57. #define BQ27XXX_FLAG_DSC BIT(0)
  58. #define BQ27XXX_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */
  59. #define BQ27XXX_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */
  60. #define BQ27XXX_FLAG_CFGUP BIT(4)
  61. #define BQ27XXX_FLAG_FC BIT(9)
  62. #define BQ27XXX_FLAG_OTD BIT(14)
  63. #define BQ27XXX_FLAG_OTC BIT(15)
  64. #define BQ27XXX_FLAG_UT BIT(14)
  65. #define BQ27XXX_FLAG_OT BIT(15)
  66. /* BQ27000 has different layout for Flags register */
  67. #define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */
  68. #define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */
  69. #define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */
  70. #define BQ27000_FLAG_FC BIT(5)
  71. #define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */
  72. /* BQ27Z561 has different layout for Flags register */
  73. #define BQ27Z561_FLAG_FDC BIT(4) /* Battery fully discharged */
  74. #define BQ27Z561_FLAG_FC BIT(5) /* Battery fully charged */
  75. #define BQ27Z561_FLAG_DIS_CH BIT(6) /* Battery is discharging */
  76. /* control register params */
  77. #define BQ27XXX_SEALED 0x20
  78. #define BQ27XXX_SET_CFGUPDATE 0x13
  79. #define BQ27XXX_SOFT_RESET 0x42
  80. #define BQ27XXX_RESET 0x41
  81. #define BQ27XXX_RS (20) /* Resistor sense mOhm */
  82. #define BQ27XXX_POWER_CONSTANT (29200) /* 29.2 µV^2 * 1000 */
  83. #define BQ27XXX_CURRENT_CONSTANT (3570) /* 3.57 µV * 1000 */
  84. #define INVALID_REG_ADDR 0xff
  85. /*
  86. * bq27xxx_reg_index - Register names
  87. *
  88. * These are indexes into a device's register mapping array.
  89. */
  90. enum bq27xxx_reg_index {
  91. BQ27XXX_REG_CTRL = 0, /* Control */
  92. BQ27XXX_REG_TEMP, /* Temperature */
  93. BQ27XXX_REG_INT_TEMP, /* Internal Temperature */
  94. BQ27XXX_REG_VOLT, /* Voltage */
  95. BQ27XXX_REG_AI, /* Average Current */
  96. BQ27XXX_REG_FLAGS, /* Flags */
  97. BQ27XXX_REG_TTE, /* Time-to-Empty */
  98. BQ27XXX_REG_TTF, /* Time-to-Full */
  99. BQ27XXX_REG_TTES, /* Time-to-Empty Standby */
  100. BQ27XXX_REG_TTECP, /* Time-to-Empty at Constant Power */
  101. BQ27XXX_REG_NAC, /* Nominal Available Capacity */
  102. BQ27XXX_REG_FCC, /* Full Charge Capacity */
  103. BQ27XXX_REG_CYCT, /* Cycle Count */
  104. BQ27XXX_REG_AE, /* Available Energy */
  105. BQ27XXX_REG_SOC, /* State-of-Charge */
  106. BQ27XXX_REG_DCAP, /* Design Capacity */
  107. BQ27XXX_REG_AP, /* Average Power */
  108. BQ27XXX_DM_CTRL, /* Block Data Control */
  109. BQ27XXX_DM_CLASS, /* Data Class */
  110. BQ27XXX_DM_BLOCK, /* Data Block */
  111. BQ27XXX_DM_DATA, /* Block Data */
  112. BQ27XXX_DM_CKSUM, /* Block Data Checksum */
  113. BQ27XXX_REG_MAX, /* sentinel */
  114. };
  115. #define BQ27XXX_DM_REG_ROWS \
  116. [BQ27XXX_DM_CTRL] = 0x61, \
  117. [BQ27XXX_DM_CLASS] = 0x3e, \
  118. [BQ27XXX_DM_BLOCK] = 0x3f, \
  119. [BQ27XXX_DM_DATA] = 0x40, \
  120. [BQ27XXX_DM_CKSUM] = 0x60
  121. /* Register mappings */
  122. static u8
  123. bq27000_regs[BQ27XXX_REG_MAX] = {
  124. [BQ27XXX_REG_CTRL] = 0x00,
  125. [BQ27XXX_REG_TEMP] = 0x06,
  126. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  127. [BQ27XXX_REG_VOLT] = 0x08,
  128. [BQ27XXX_REG_AI] = 0x14,
  129. [BQ27XXX_REG_FLAGS] = 0x0a,
  130. [BQ27XXX_REG_TTE] = 0x16,
  131. [BQ27XXX_REG_TTF] = 0x18,
  132. [BQ27XXX_REG_TTES] = 0x1c,
  133. [BQ27XXX_REG_TTECP] = 0x26,
  134. [BQ27XXX_REG_NAC] = 0x0c,
  135. [BQ27XXX_REG_FCC] = 0x12,
  136. [BQ27XXX_REG_CYCT] = 0x2a,
  137. [BQ27XXX_REG_AE] = 0x22,
  138. [BQ27XXX_REG_SOC] = 0x0b,
  139. [BQ27XXX_REG_DCAP] = 0x76,
  140. [BQ27XXX_REG_AP] = 0x24,
  141. [BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
  142. [BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
  143. [BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
  144. [BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
  145. [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
  146. },
  147. bq27010_regs[BQ27XXX_REG_MAX] = {
  148. [BQ27XXX_REG_CTRL] = 0x00,
  149. [BQ27XXX_REG_TEMP] = 0x06,
  150. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  151. [BQ27XXX_REG_VOLT] = 0x08,
  152. [BQ27XXX_REG_AI] = 0x14,
  153. [BQ27XXX_REG_FLAGS] = 0x0a,
  154. [BQ27XXX_REG_TTE] = 0x16,
  155. [BQ27XXX_REG_TTF] = 0x18,
  156. [BQ27XXX_REG_TTES] = 0x1c,
  157. [BQ27XXX_REG_TTECP] = 0x26,
  158. [BQ27XXX_REG_NAC] = 0x0c,
  159. [BQ27XXX_REG_FCC] = 0x12,
  160. [BQ27XXX_REG_CYCT] = 0x2a,
  161. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  162. [BQ27XXX_REG_SOC] = 0x0b,
  163. [BQ27XXX_REG_DCAP] = 0x76,
  164. [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
  165. [BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
  166. [BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
  167. [BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
  168. [BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
  169. [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
  170. },
  171. bq2750x_regs[BQ27XXX_REG_MAX] = {
  172. [BQ27XXX_REG_CTRL] = 0x00,
  173. [BQ27XXX_REG_TEMP] = 0x06,
  174. [BQ27XXX_REG_INT_TEMP] = 0x28,
  175. [BQ27XXX_REG_VOLT] = 0x08,
  176. [BQ27XXX_REG_AI] = 0x14,
  177. [BQ27XXX_REG_FLAGS] = 0x0a,
  178. [BQ27XXX_REG_TTE] = 0x16,
  179. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  180. [BQ27XXX_REG_TTES] = 0x1a,
  181. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  182. [BQ27XXX_REG_NAC] = 0x0c,
  183. [BQ27XXX_REG_FCC] = 0x12,
  184. [BQ27XXX_REG_CYCT] = 0x2a,
  185. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  186. [BQ27XXX_REG_SOC] = 0x2c,
  187. [BQ27XXX_REG_DCAP] = 0x3c,
  188. [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
  189. BQ27XXX_DM_REG_ROWS,
  190. },
  191. #define bq2751x_regs bq27510g3_regs
  192. #define bq2752x_regs bq27510g3_regs
  193. bq27500_regs[BQ27XXX_REG_MAX] = {
  194. [BQ27XXX_REG_CTRL] = 0x00,
  195. [BQ27XXX_REG_TEMP] = 0x06,
  196. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  197. [BQ27XXX_REG_VOLT] = 0x08,
  198. [BQ27XXX_REG_AI] = 0x14,
  199. [BQ27XXX_REG_FLAGS] = 0x0a,
  200. [BQ27XXX_REG_TTE] = 0x16,
  201. [BQ27XXX_REG_TTF] = 0x18,
  202. [BQ27XXX_REG_TTES] = 0x1c,
  203. [BQ27XXX_REG_TTECP] = 0x26,
  204. [BQ27XXX_REG_NAC] = 0x0c,
  205. [BQ27XXX_REG_FCC] = 0x12,
  206. [BQ27XXX_REG_CYCT] = 0x2a,
  207. [BQ27XXX_REG_AE] = 0x22,
  208. [BQ27XXX_REG_SOC] = 0x2c,
  209. [BQ27XXX_REG_DCAP] = 0x3c,
  210. [BQ27XXX_REG_AP] = 0x24,
  211. BQ27XXX_DM_REG_ROWS,
  212. },
  213. #define bq27510g1_regs bq27500_regs
  214. #define bq27510g2_regs bq27500_regs
  215. bq27510g3_regs[BQ27XXX_REG_MAX] = {
  216. [BQ27XXX_REG_CTRL] = 0x00,
  217. [BQ27XXX_REG_TEMP] = 0x06,
  218. [BQ27XXX_REG_INT_TEMP] = 0x28,
  219. [BQ27XXX_REG_VOLT] = 0x08,
  220. [BQ27XXX_REG_AI] = 0x14,
  221. [BQ27XXX_REG_FLAGS] = 0x0a,
  222. [BQ27XXX_REG_TTE] = 0x16,
  223. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  224. [BQ27XXX_REG_TTES] = 0x1a,
  225. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  226. [BQ27XXX_REG_NAC] = 0x0c,
  227. [BQ27XXX_REG_FCC] = 0x12,
  228. [BQ27XXX_REG_CYCT] = 0x1e,
  229. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  230. [BQ27XXX_REG_SOC] = 0x20,
  231. [BQ27XXX_REG_DCAP] = 0x2e,
  232. [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
  233. BQ27XXX_DM_REG_ROWS,
  234. },
  235. bq27520g1_regs[BQ27XXX_REG_MAX] = {
  236. [BQ27XXX_REG_CTRL] = 0x00,
  237. [BQ27XXX_REG_TEMP] = 0x06,
  238. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  239. [BQ27XXX_REG_VOLT] = 0x08,
  240. [BQ27XXX_REG_AI] = 0x14,
  241. [BQ27XXX_REG_FLAGS] = 0x0a,
  242. [BQ27XXX_REG_TTE] = 0x16,
  243. [BQ27XXX_REG_TTF] = 0x18,
  244. [BQ27XXX_REG_TTES] = 0x1c,
  245. [BQ27XXX_REG_TTECP] = 0x26,
  246. [BQ27XXX_REG_NAC] = 0x0c,
  247. [BQ27XXX_REG_FCC] = 0x12,
  248. [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR,
  249. [BQ27XXX_REG_AE] = 0x22,
  250. [BQ27XXX_REG_SOC] = 0x2c,
  251. [BQ27XXX_REG_DCAP] = 0x3c,
  252. [BQ27XXX_REG_AP] = 0x24,
  253. BQ27XXX_DM_REG_ROWS,
  254. },
  255. bq27520g2_regs[BQ27XXX_REG_MAX] = {
  256. [BQ27XXX_REG_CTRL] = 0x00,
  257. [BQ27XXX_REG_TEMP] = 0x06,
  258. [BQ27XXX_REG_INT_TEMP] = 0x36,
  259. [BQ27XXX_REG_VOLT] = 0x08,
  260. [BQ27XXX_REG_AI] = 0x14,
  261. [BQ27XXX_REG_FLAGS] = 0x0a,
  262. [BQ27XXX_REG_TTE] = 0x16,
  263. [BQ27XXX_REG_TTF] = 0x18,
  264. [BQ27XXX_REG_TTES] = 0x1c,
  265. [BQ27XXX_REG_TTECP] = 0x26,
  266. [BQ27XXX_REG_NAC] = 0x0c,
  267. [BQ27XXX_REG_FCC] = 0x12,
  268. [BQ27XXX_REG_CYCT] = 0x2a,
  269. [BQ27XXX_REG_AE] = 0x22,
  270. [BQ27XXX_REG_SOC] = 0x2c,
  271. [BQ27XXX_REG_DCAP] = 0x3c,
  272. [BQ27XXX_REG_AP] = 0x24,
  273. BQ27XXX_DM_REG_ROWS,
  274. },
  275. bq27520g3_regs[BQ27XXX_REG_MAX] = {
  276. [BQ27XXX_REG_CTRL] = 0x00,
  277. [BQ27XXX_REG_TEMP] = 0x06,
  278. [BQ27XXX_REG_INT_TEMP] = 0x36,
  279. [BQ27XXX_REG_VOLT] = 0x08,
  280. [BQ27XXX_REG_AI] = 0x14,
  281. [BQ27XXX_REG_FLAGS] = 0x0a,
  282. [BQ27XXX_REG_TTE] = 0x16,
  283. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  284. [BQ27XXX_REG_TTES] = 0x1c,
  285. [BQ27XXX_REG_TTECP] = 0x26,
  286. [BQ27XXX_REG_NAC] = 0x0c,
  287. [BQ27XXX_REG_FCC] = 0x12,
  288. [BQ27XXX_REG_CYCT] = 0x2a,
  289. [BQ27XXX_REG_AE] = 0x22,
  290. [BQ27XXX_REG_SOC] = 0x2c,
  291. [BQ27XXX_REG_DCAP] = 0x3c,
  292. [BQ27XXX_REG_AP] = 0x24,
  293. BQ27XXX_DM_REG_ROWS,
  294. },
  295. bq27520g4_regs[BQ27XXX_REG_MAX] = {
  296. [BQ27XXX_REG_CTRL] = 0x00,
  297. [BQ27XXX_REG_TEMP] = 0x06,
  298. [BQ27XXX_REG_INT_TEMP] = 0x28,
  299. [BQ27XXX_REG_VOLT] = 0x08,
  300. [BQ27XXX_REG_AI] = 0x14,
  301. [BQ27XXX_REG_FLAGS] = 0x0a,
  302. [BQ27XXX_REG_TTE] = 0x16,
  303. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  304. [BQ27XXX_REG_TTES] = 0x1c,
  305. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  306. [BQ27XXX_REG_NAC] = 0x0c,
  307. [BQ27XXX_REG_FCC] = 0x12,
  308. [BQ27XXX_REG_CYCT] = 0x1e,
  309. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  310. [BQ27XXX_REG_SOC] = 0x20,
  311. [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
  312. [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
  313. BQ27XXX_DM_REG_ROWS,
  314. },
  315. bq27521_regs[BQ27XXX_REG_MAX] = {
  316. [BQ27XXX_REG_CTRL] = 0x02,
  317. [BQ27XXX_REG_TEMP] = 0x0a,
  318. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  319. [BQ27XXX_REG_VOLT] = 0x0c,
  320. [BQ27XXX_REG_AI] = 0x0e,
  321. [BQ27XXX_REG_FLAGS] = 0x08,
  322. [BQ27XXX_REG_TTE] = INVALID_REG_ADDR,
  323. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  324. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  325. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  326. [BQ27XXX_REG_NAC] = INVALID_REG_ADDR,
  327. [BQ27XXX_REG_FCC] = INVALID_REG_ADDR,
  328. [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR,
  329. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  330. [BQ27XXX_REG_SOC] = INVALID_REG_ADDR,
  331. [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
  332. [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
  333. [BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
  334. [BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
  335. [BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
  336. [BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
  337. [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
  338. },
  339. bq27530_regs[BQ27XXX_REG_MAX] = {
  340. [BQ27XXX_REG_CTRL] = 0x00,
  341. [BQ27XXX_REG_TEMP] = 0x06,
  342. [BQ27XXX_REG_INT_TEMP] = 0x32,
  343. [BQ27XXX_REG_VOLT] = 0x08,
  344. [BQ27XXX_REG_AI] = 0x14,
  345. [BQ27XXX_REG_FLAGS] = 0x0a,
  346. [BQ27XXX_REG_TTE] = 0x16,
  347. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  348. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  349. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  350. [BQ27XXX_REG_NAC] = 0x0c,
  351. [BQ27XXX_REG_FCC] = 0x12,
  352. [BQ27XXX_REG_CYCT] = 0x2a,
  353. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  354. [BQ27XXX_REG_SOC] = 0x2c,
  355. [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
  356. [BQ27XXX_REG_AP] = 0x24,
  357. BQ27XXX_DM_REG_ROWS,
  358. },
  359. #define bq27531_regs bq27530_regs
  360. bq27541_regs[BQ27XXX_REG_MAX] = {
  361. [BQ27XXX_REG_CTRL] = 0x00,
  362. [BQ27XXX_REG_TEMP] = 0x06,
  363. [BQ27XXX_REG_INT_TEMP] = 0x28,
  364. [BQ27XXX_REG_VOLT] = 0x08,
  365. [BQ27XXX_REG_AI] = 0x14,
  366. [BQ27XXX_REG_FLAGS] = 0x0a,
  367. [BQ27XXX_REG_TTE] = 0x16,
  368. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  369. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  370. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  371. [BQ27XXX_REG_NAC] = 0x0c,
  372. [BQ27XXX_REG_FCC] = 0x12,
  373. [BQ27XXX_REG_CYCT] = 0x2a,
  374. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  375. [BQ27XXX_REG_SOC] = 0x2c,
  376. [BQ27XXX_REG_DCAP] = 0x3c,
  377. [BQ27XXX_REG_AP] = 0x24,
  378. BQ27XXX_DM_REG_ROWS,
  379. },
  380. #define bq27542_regs bq27541_regs
  381. #define bq27546_regs bq27541_regs
  382. #define bq27742_regs bq27541_regs
  383. bq27545_regs[BQ27XXX_REG_MAX] = {
  384. [BQ27XXX_REG_CTRL] = 0x00,
  385. [BQ27XXX_REG_TEMP] = 0x06,
  386. [BQ27XXX_REG_INT_TEMP] = 0x28,
  387. [BQ27XXX_REG_VOLT] = 0x08,
  388. [BQ27XXX_REG_AI] = 0x14,
  389. [BQ27XXX_REG_FLAGS] = 0x0a,
  390. [BQ27XXX_REG_TTE] = 0x16,
  391. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  392. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  393. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  394. [BQ27XXX_REG_NAC] = 0x0c,
  395. [BQ27XXX_REG_FCC] = 0x12,
  396. [BQ27XXX_REG_CYCT] = 0x2a,
  397. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  398. [BQ27XXX_REG_SOC] = 0x2c,
  399. [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
  400. [BQ27XXX_REG_AP] = 0x24,
  401. BQ27XXX_DM_REG_ROWS,
  402. },
  403. bq27421_regs[BQ27XXX_REG_MAX] = {
  404. [BQ27XXX_REG_CTRL] = 0x00,
  405. [BQ27XXX_REG_TEMP] = 0x02,
  406. [BQ27XXX_REG_INT_TEMP] = 0x1e,
  407. [BQ27XXX_REG_VOLT] = 0x04,
  408. [BQ27XXX_REG_AI] = 0x10,
  409. [BQ27XXX_REG_FLAGS] = 0x06,
  410. [BQ27XXX_REG_TTE] = INVALID_REG_ADDR,
  411. [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
  412. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  413. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  414. [BQ27XXX_REG_NAC] = 0x08,
  415. [BQ27XXX_REG_FCC] = 0x0e,
  416. [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR,
  417. [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
  418. [BQ27XXX_REG_SOC] = 0x1c,
  419. [BQ27XXX_REG_DCAP] = 0x3c,
  420. [BQ27XXX_REG_AP] = 0x18,
  421. BQ27XXX_DM_REG_ROWS,
  422. },
  423. #define bq27411_regs bq27421_regs
  424. #define bq27425_regs bq27421_regs
  425. #define bq27426_regs bq27421_regs
  426. #define bq27441_regs bq27421_regs
  427. #define bq27621_regs bq27421_regs
  428. bq27z561_regs[BQ27XXX_REG_MAX] = {
  429. [BQ27XXX_REG_CTRL] = 0x00,
  430. [BQ27XXX_REG_TEMP] = 0x06,
  431. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  432. [BQ27XXX_REG_VOLT] = 0x08,
  433. [BQ27XXX_REG_AI] = 0x14,
  434. [BQ27XXX_REG_FLAGS] = 0x0a,
  435. [BQ27XXX_REG_TTE] = 0x16,
  436. [BQ27XXX_REG_TTF] = 0x18,
  437. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  438. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  439. [BQ27XXX_REG_NAC] = INVALID_REG_ADDR,
  440. [BQ27XXX_REG_FCC] = 0x12,
  441. [BQ27XXX_REG_CYCT] = 0x2a,
  442. [BQ27XXX_REG_AE] = 0x22,
  443. [BQ27XXX_REG_SOC] = 0x2c,
  444. [BQ27XXX_REG_DCAP] = 0x3c,
  445. [BQ27XXX_REG_AP] = 0x22,
  446. BQ27XXX_DM_REG_ROWS,
  447. },
  448. bq28z610_regs[BQ27XXX_REG_MAX] = {
  449. [BQ27XXX_REG_CTRL] = 0x00,
  450. [BQ27XXX_REG_TEMP] = 0x06,
  451. [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
  452. [BQ27XXX_REG_VOLT] = 0x08,
  453. [BQ27XXX_REG_AI] = 0x14,
  454. [BQ27XXX_REG_FLAGS] = 0x0a,
  455. [BQ27XXX_REG_TTE] = 0x16,
  456. [BQ27XXX_REG_TTF] = 0x18,
  457. [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
  458. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  459. [BQ27XXX_REG_NAC] = INVALID_REG_ADDR,
  460. [BQ27XXX_REG_FCC] = 0x12,
  461. [BQ27XXX_REG_CYCT] = 0x2a,
  462. [BQ27XXX_REG_AE] = 0x22,
  463. [BQ27XXX_REG_SOC] = 0x2c,
  464. [BQ27XXX_REG_DCAP] = 0x3c,
  465. [BQ27XXX_REG_AP] = 0x22,
  466. BQ27XXX_DM_REG_ROWS,
  467. },
  468. bq34z100_regs[BQ27XXX_REG_MAX] = {
  469. [BQ27XXX_REG_CTRL] = 0x00,
  470. [BQ27XXX_REG_TEMP] = 0x0c,
  471. [BQ27XXX_REG_INT_TEMP] = 0x2a,
  472. [BQ27XXX_REG_VOLT] = 0x08,
  473. [BQ27XXX_REG_AI] = 0x0a,
  474. [BQ27XXX_REG_FLAGS] = 0x0e,
  475. [BQ27XXX_REG_TTE] = 0x18,
  476. [BQ27XXX_REG_TTF] = 0x1a,
  477. [BQ27XXX_REG_TTES] = 0x1e,
  478. [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
  479. [BQ27XXX_REG_NAC] = INVALID_REG_ADDR,
  480. [BQ27XXX_REG_FCC] = 0x06,
  481. [BQ27XXX_REG_CYCT] = 0x2c,
  482. [BQ27XXX_REG_AE] = 0x24,
  483. [BQ27XXX_REG_SOC] = 0x02,
  484. [BQ27XXX_REG_DCAP] = 0x3c,
  485. [BQ27XXX_REG_AP] = 0x22,
  486. BQ27XXX_DM_REG_ROWS,
  487. };
  488. static enum power_supply_property bq27000_props[] = {
  489. POWER_SUPPLY_PROP_STATUS,
  490. POWER_SUPPLY_PROP_PRESENT,
  491. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  492. POWER_SUPPLY_PROP_CURRENT_NOW,
  493. POWER_SUPPLY_PROP_CAPACITY,
  494. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  495. POWER_SUPPLY_PROP_TEMP,
  496. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  497. POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
  498. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  499. POWER_SUPPLY_PROP_TECHNOLOGY,
  500. POWER_SUPPLY_PROP_CHARGE_FULL,
  501. POWER_SUPPLY_PROP_CHARGE_NOW,
  502. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  503. POWER_SUPPLY_PROP_CYCLE_COUNT,
  504. POWER_SUPPLY_PROP_ENERGY_NOW,
  505. POWER_SUPPLY_PROP_POWER_AVG,
  506. POWER_SUPPLY_PROP_HEALTH,
  507. POWER_SUPPLY_PROP_MANUFACTURER,
  508. };
  509. static enum power_supply_property bq27010_props[] = {
  510. POWER_SUPPLY_PROP_STATUS,
  511. POWER_SUPPLY_PROP_PRESENT,
  512. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  513. POWER_SUPPLY_PROP_CURRENT_NOW,
  514. POWER_SUPPLY_PROP_CAPACITY,
  515. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  516. POWER_SUPPLY_PROP_TEMP,
  517. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  518. POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
  519. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  520. POWER_SUPPLY_PROP_TECHNOLOGY,
  521. POWER_SUPPLY_PROP_CHARGE_FULL,
  522. POWER_SUPPLY_PROP_CHARGE_NOW,
  523. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  524. POWER_SUPPLY_PROP_CYCLE_COUNT,
  525. POWER_SUPPLY_PROP_HEALTH,
  526. POWER_SUPPLY_PROP_MANUFACTURER,
  527. };
  528. #define bq2750x_props bq27510g3_props
  529. #define bq2751x_props bq27510g3_props
  530. #define bq2752x_props bq27510g3_props
  531. static enum power_supply_property bq27500_props[] = {
  532. POWER_SUPPLY_PROP_STATUS,
  533. POWER_SUPPLY_PROP_PRESENT,
  534. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  535. POWER_SUPPLY_PROP_CURRENT_NOW,
  536. POWER_SUPPLY_PROP_CAPACITY,
  537. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  538. POWER_SUPPLY_PROP_TEMP,
  539. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  540. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  541. POWER_SUPPLY_PROP_TECHNOLOGY,
  542. POWER_SUPPLY_PROP_CHARGE_FULL,
  543. POWER_SUPPLY_PROP_CHARGE_NOW,
  544. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  545. POWER_SUPPLY_PROP_CYCLE_COUNT,
  546. POWER_SUPPLY_PROP_ENERGY_NOW,
  547. POWER_SUPPLY_PROP_POWER_AVG,
  548. POWER_SUPPLY_PROP_HEALTH,
  549. POWER_SUPPLY_PROP_MANUFACTURER,
  550. };
  551. #define bq27510g1_props bq27500_props
  552. #define bq27510g2_props bq27500_props
  553. static enum power_supply_property bq27510g3_props[] = {
  554. POWER_SUPPLY_PROP_STATUS,
  555. POWER_SUPPLY_PROP_PRESENT,
  556. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  557. POWER_SUPPLY_PROP_CURRENT_NOW,
  558. POWER_SUPPLY_PROP_CAPACITY,
  559. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  560. POWER_SUPPLY_PROP_TEMP,
  561. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  562. POWER_SUPPLY_PROP_TECHNOLOGY,
  563. POWER_SUPPLY_PROP_CHARGE_FULL,
  564. POWER_SUPPLY_PROP_CHARGE_NOW,
  565. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  566. POWER_SUPPLY_PROP_CYCLE_COUNT,
  567. POWER_SUPPLY_PROP_HEALTH,
  568. POWER_SUPPLY_PROP_MANUFACTURER,
  569. };
  570. static enum power_supply_property bq27520g1_props[] = {
  571. POWER_SUPPLY_PROP_STATUS,
  572. POWER_SUPPLY_PROP_PRESENT,
  573. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  574. POWER_SUPPLY_PROP_CURRENT_NOW,
  575. POWER_SUPPLY_PROP_CAPACITY,
  576. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  577. POWER_SUPPLY_PROP_TEMP,
  578. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  579. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  580. POWER_SUPPLY_PROP_TECHNOLOGY,
  581. POWER_SUPPLY_PROP_CHARGE_FULL,
  582. POWER_SUPPLY_PROP_CHARGE_NOW,
  583. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  584. POWER_SUPPLY_PROP_ENERGY_NOW,
  585. POWER_SUPPLY_PROP_POWER_AVG,
  586. POWER_SUPPLY_PROP_HEALTH,
  587. POWER_SUPPLY_PROP_MANUFACTURER,
  588. };
  589. #define bq27520g2_props bq27500_props
  590. static enum power_supply_property bq27520g3_props[] = {
  591. POWER_SUPPLY_PROP_STATUS,
  592. POWER_SUPPLY_PROP_PRESENT,
  593. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  594. POWER_SUPPLY_PROP_CURRENT_NOW,
  595. POWER_SUPPLY_PROP_CAPACITY,
  596. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  597. POWER_SUPPLY_PROP_TEMP,
  598. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  599. POWER_SUPPLY_PROP_TECHNOLOGY,
  600. POWER_SUPPLY_PROP_CHARGE_FULL,
  601. POWER_SUPPLY_PROP_CHARGE_NOW,
  602. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  603. POWER_SUPPLY_PROP_CYCLE_COUNT,
  604. POWER_SUPPLY_PROP_ENERGY_NOW,
  605. POWER_SUPPLY_PROP_POWER_AVG,
  606. POWER_SUPPLY_PROP_HEALTH,
  607. POWER_SUPPLY_PROP_MANUFACTURER,
  608. };
  609. static enum power_supply_property bq27520g4_props[] = {
  610. POWER_SUPPLY_PROP_STATUS,
  611. POWER_SUPPLY_PROP_PRESENT,
  612. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  613. POWER_SUPPLY_PROP_CURRENT_NOW,
  614. POWER_SUPPLY_PROP_CAPACITY,
  615. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  616. POWER_SUPPLY_PROP_TEMP,
  617. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  618. POWER_SUPPLY_PROP_TECHNOLOGY,
  619. POWER_SUPPLY_PROP_CHARGE_FULL,
  620. POWER_SUPPLY_PROP_CHARGE_NOW,
  621. POWER_SUPPLY_PROP_CYCLE_COUNT,
  622. POWER_SUPPLY_PROP_HEALTH,
  623. POWER_SUPPLY_PROP_MANUFACTURER,
  624. };
  625. static enum power_supply_property bq27521_props[] = {
  626. POWER_SUPPLY_PROP_STATUS,
  627. POWER_SUPPLY_PROP_PRESENT,
  628. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  629. POWER_SUPPLY_PROP_CURRENT_NOW,
  630. POWER_SUPPLY_PROP_TEMP,
  631. POWER_SUPPLY_PROP_TECHNOLOGY,
  632. };
  633. static enum power_supply_property bq27530_props[] = {
  634. POWER_SUPPLY_PROP_STATUS,
  635. POWER_SUPPLY_PROP_PRESENT,
  636. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  637. POWER_SUPPLY_PROP_CURRENT_NOW,
  638. POWER_SUPPLY_PROP_CAPACITY,
  639. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  640. POWER_SUPPLY_PROP_TEMP,
  641. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  642. POWER_SUPPLY_PROP_TECHNOLOGY,
  643. POWER_SUPPLY_PROP_CHARGE_FULL,
  644. POWER_SUPPLY_PROP_CHARGE_NOW,
  645. POWER_SUPPLY_PROP_POWER_AVG,
  646. POWER_SUPPLY_PROP_HEALTH,
  647. POWER_SUPPLY_PROP_CYCLE_COUNT,
  648. POWER_SUPPLY_PROP_MANUFACTURER,
  649. };
  650. #define bq27531_props bq27530_props
  651. static enum power_supply_property bq27541_props[] = {
  652. POWER_SUPPLY_PROP_STATUS,
  653. POWER_SUPPLY_PROP_PRESENT,
  654. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  655. POWER_SUPPLY_PROP_CURRENT_NOW,
  656. POWER_SUPPLY_PROP_CAPACITY,
  657. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  658. POWER_SUPPLY_PROP_TEMP,
  659. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  660. POWER_SUPPLY_PROP_TECHNOLOGY,
  661. POWER_SUPPLY_PROP_CHARGE_FULL,
  662. POWER_SUPPLY_PROP_CHARGE_NOW,
  663. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  664. POWER_SUPPLY_PROP_CYCLE_COUNT,
  665. POWER_SUPPLY_PROP_POWER_AVG,
  666. POWER_SUPPLY_PROP_HEALTH,
  667. POWER_SUPPLY_PROP_MANUFACTURER,
  668. };
  669. #define bq27542_props bq27541_props
  670. #define bq27546_props bq27541_props
  671. #define bq27742_props bq27541_props
  672. static enum power_supply_property bq27545_props[] = {
  673. POWER_SUPPLY_PROP_STATUS,
  674. POWER_SUPPLY_PROP_PRESENT,
  675. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  676. POWER_SUPPLY_PROP_CURRENT_NOW,
  677. POWER_SUPPLY_PROP_CAPACITY,
  678. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  679. POWER_SUPPLY_PROP_TEMP,
  680. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  681. POWER_SUPPLY_PROP_TECHNOLOGY,
  682. POWER_SUPPLY_PROP_CHARGE_FULL,
  683. POWER_SUPPLY_PROP_CHARGE_NOW,
  684. POWER_SUPPLY_PROP_HEALTH,
  685. POWER_SUPPLY_PROP_CYCLE_COUNT,
  686. POWER_SUPPLY_PROP_POWER_AVG,
  687. POWER_SUPPLY_PROP_MANUFACTURER,
  688. };
  689. static enum power_supply_property bq27421_props[] = {
  690. POWER_SUPPLY_PROP_STATUS,
  691. POWER_SUPPLY_PROP_PRESENT,
  692. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  693. POWER_SUPPLY_PROP_CURRENT_NOW,
  694. POWER_SUPPLY_PROP_CAPACITY,
  695. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  696. POWER_SUPPLY_PROP_TEMP,
  697. POWER_SUPPLY_PROP_TECHNOLOGY,
  698. POWER_SUPPLY_PROP_CHARGE_FULL,
  699. POWER_SUPPLY_PROP_CHARGE_NOW,
  700. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  701. POWER_SUPPLY_PROP_MANUFACTURER,
  702. };
  703. #define bq27411_props bq27421_props
  704. #define bq27425_props bq27421_props
  705. #define bq27426_props bq27421_props
  706. #define bq27441_props bq27421_props
  707. #define bq27621_props bq27421_props
  708. static enum power_supply_property bq27z561_props[] = {
  709. POWER_SUPPLY_PROP_STATUS,
  710. POWER_SUPPLY_PROP_PRESENT,
  711. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  712. POWER_SUPPLY_PROP_CURRENT_NOW,
  713. POWER_SUPPLY_PROP_CAPACITY,
  714. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  715. POWER_SUPPLY_PROP_TEMP,
  716. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  717. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  718. POWER_SUPPLY_PROP_TECHNOLOGY,
  719. POWER_SUPPLY_PROP_CHARGE_FULL,
  720. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  721. POWER_SUPPLY_PROP_CYCLE_COUNT,
  722. POWER_SUPPLY_PROP_POWER_AVG,
  723. POWER_SUPPLY_PROP_HEALTH,
  724. POWER_SUPPLY_PROP_MANUFACTURER,
  725. };
  726. static enum power_supply_property bq28z610_props[] = {
  727. POWER_SUPPLY_PROP_STATUS,
  728. POWER_SUPPLY_PROP_PRESENT,
  729. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  730. POWER_SUPPLY_PROP_CURRENT_NOW,
  731. POWER_SUPPLY_PROP_CAPACITY,
  732. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  733. POWER_SUPPLY_PROP_TEMP,
  734. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  735. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  736. POWER_SUPPLY_PROP_TECHNOLOGY,
  737. POWER_SUPPLY_PROP_CHARGE_FULL,
  738. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  739. POWER_SUPPLY_PROP_CYCLE_COUNT,
  740. POWER_SUPPLY_PROP_POWER_AVG,
  741. POWER_SUPPLY_PROP_HEALTH,
  742. POWER_SUPPLY_PROP_MANUFACTURER,
  743. };
  744. static enum power_supply_property bq34z100_props[] = {
  745. POWER_SUPPLY_PROP_STATUS,
  746. POWER_SUPPLY_PROP_PRESENT,
  747. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  748. POWER_SUPPLY_PROP_CURRENT_NOW,
  749. POWER_SUPPLY_PROP_CAPACITY,
  750. POWER_SUPPLY_PROP_CAPACITY_LEVEL,
  751. POWER_SUPPLY_PROP_TEMP,
  752. POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  753. POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
  754. POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  755. POWER_SUPPLY_PROP_TECHNOLOGY,
  756. POWER_SUPPLY_PROP_CHARGE_FULL,
  757. POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
  758. POWER_SUPPLY_PROP_CYCLE_COUNT,
  759. POWER_SUPPLY_PROP_ENERGY_NOW,
  760. POWER_SUPPLY_PROP_POWER_AVG,
  761. POWER_SUPPLY_PROP_HEALTH,
  762. POWER_SUPPLY_PROP_MANUFACTURER,
  763. };
  764. struct bq27xxx_dm_reg {
  765. u8 subclass_id;
  766. u8 offset;
  767. u8 bytes;
  768. u16 min, max;
  769. };
  770. enum bq27xxx_dm_reg_id {
  771. BQ27XXX_DM_DESIGN_CAPACITY = 0,
  772. BQ27XXX_DM_DESIGN_ENERGY,
  773. BQ27XXX_DM_TERMINATE_VOLTAGE,
  774. };
  775. #define bq27000_dm_regs 0
  776. #define bq27010_dm_regs 0
  777. #define bq2750x_dm_regs 0
  778. #define bq2751x_dm_regs 0
  779. #define bq2752x_dm_regs 0
  780. #if 0 /* not yet tested */
  781. static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
  782. [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 10, 2, 0, 65535 },
  783. [BQ27XXX_DM_DESIGN_ENERGY] = { }, /* missing on chip */
  784. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
  785. };
  786. #else
  787. #define bq27500_dm_regs 0
  788. #endif
  789. /* todo create data memory definitions from datasheets and test on chips */
  790. #define bq27510g1_dm_regs 0
  791. #define bq27510g2_dm_regs 0
  792. #define bq27510g3_dm_regs 0
  793. #define bq27520g1_dm_regs 0
  794. #define bq27520g2_dm_regs 0
  795. #define bq27520g3_dm_regs 0
  796. #define bq27520g4_dm_regs 0
  797. #define bq27521_dm_regs 0
  798. #define bq27530_dm_regs 0
  799. #define bq27531_dm_regs 0
  800. #define bq27541_dm_regs 0
  801. #define bq27542_dm_regs 0
  802. #define bq27546_dm_regs 0
  803. #define bq27742_dm_regs 0
  804. #if 0 /* not yet tested */
  805. static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
  806. [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 23, 2, 0, 32767 },
  807. [BQ27XXX_DM_DESIGN_ENERGY] = { 48, 25, 2, 0, 32767 },
  808. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800, 3700 },
  809. };
  810. #else
  811. #define bq27545_dm_regs 0
  812. #endif
  813. static struct bq27xxx_dm_reg bq27411_dm_regs[] = {
  814. [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 10, 2, 0, 32767 },
  815. [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 12, 2, 0, 32767 },
  816. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2800, 3700 },
  817. };
  818. static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
  819. [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 10, 2, 0, 8000 },
  820. [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 12, 2, 0, 32767 },
  821. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500, 3700 },
  822. };
  823. static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
  824. [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 12, 2, 0, 32767 },
  825. [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 14, 2, 0, 32767 },
  826. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800, 3700 },
  827. };
  828. static struct bq27xxx_dm_reg bq27426_dm_regs[] = {
  829. [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 6, 2, 0, 8000 },
  830. [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 8, 2, 0, 32767 },
  831. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 10, 2, 2500, 3700 },
  832. };
  833. #if 0 /* not yet tested */
  834. #define bq27441_dm_regs bq27421_dm_regs
  835. #else
  836. #define bq27441_dm_regs 0
  837. #endif
  838. #if 0 /* not yet tested */
  839. static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
  840. [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 3, 2, 0, 8000 },
  841. [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 5, 2, 0, 32767 },
  842. [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500, 3700 },
  843. };
  844. #else
  845. #define bq27621_dm_regs 0
  846. #endif
  847. #define bq27z561_dm_regs 0
  848. #define bq28z610_dm_regs 0
  849. #define bq34z100_dm_regs 0
  850. #define BQ27XXX_O_ZERO BIT(0)
  851. #define BQ27XXX_O_OTDC BIT(1) /* has OTC/OTD overtemperature flags */
  852. #define BQ27XXX_O_UTOT BIT(2) /* has OT overtemperature flag */
  853. #define BQ27XXX_O_CFGUP BIT(3)
  854. #define BQ27XXX_O_RAM BIT(4)
  855. #define BQ27Z561_O_BITS BIT(5)
  856. #define BQ27XXX_O_SOC_SI BIT(6) /* SoC is single register */
  857. #define BQ27XXX_O_HAS_CI BIT(7) /* has Capacity Inaccurate flag */
  858. #define BQ27XXX_O_MUL_CHEM BIT(8) /* multiple chemistries supported */
  859. #define BQ27XXX_DATA(ref, key, opt) { \
  860. .opts = (opt), \
  861. .unseal_key = key, \
  862. .regs = ref##_regs, \
  863. .dm_regs = ref##_dm_regs, \
  864. .props = ref##_props, \
  865. .props_size = ARRAY_SIZE(ref##_props) }
  866. static struct {
  867. u32 opts;
  868. u32 unseal_key;
  869. u8 *regs;
  870. struct bq27xxx_dm_reg *dm_regs;
  871. enum power_supply_property *props;
  872. size_t props_size;
  873. } bq27xxx_chip_data[] = {
  874. [BQ27000] = BQ27XXX_DATA(bq27000, 0 , BQ27XXX_O_ZERO | BQ27XXX_O_SOC_SI | BQ27XXX_O_HAS_CI),
  875. [BQ27010] = BQ27XXX_DATA(bq27010, 0 , BQ27XXX_O_ZERO | BQ27XXX_O_SOC_SI | BQ27XXX_O_HAS_CI),
  876. [BQ2750X] = BQ27XXX_DATA(bq2750x, 0 , BQ27XXX_O_OTDC),
  877. [BQ2751X] = BQ27XXX_DATA(bq2751x, 0 , BQ27XXX_O_OTDC),
  878. [BQ2752X] = BQ27XXX_DATA(bq2752x, 0 , BQ27XXX_O_OTDC),
  879. [BQ27500] = BQ27XXX_DATA(bq27500, 0x04143672, BQ27XXX_O_OTDC),
  880. [BQ27510G1] = BQ27XXX_DATA(bq27510g1, 0 , BQ27XXX_O_OTDC),
  881. [BQ27510G2] = BQ27XXX_DATA(bq27510g2, 0 , BQ27XXX_O_OTDC),
  882. [BQ27510G3] = BQ27XXX_DATA(bq27510g3, 0 , BQ27XXX_O_OTDC),
  883. [BQ27520G1] = BQ27XXX_DATA(bq27520g1, 0 , BQ27XXX_O_OTDC),
  884. [BQ27520G2] = BQ27XXX_DATA(bq27520g2, 0 , BQ27XXX_O_OTDC),
  885. [BQ27520G3] = BQ27XXX_DATA(bq27520g3, 0 , BQ27XXX_O_OTDC),
  886. [BQ27520G4] = BQ27XXX_DATA(bq27520g4, 0 , BQ27XXX_O_OTDC),
  887. [BQ27521] = BQ27XXX_DATA(bq27521, 0 , 0),
  888. [BQ27530] = BQ27XXX_DATA(bq27530, 0 , BQ27XXX_O_UTOT),
  889. [BQ27531] = BQ27XXX_DATA(bq27531, 0 , BQ27XXX_O_UTOT),
  890. [BQ27541] = BQ27XXX_DATA(bq27541, 0 , BQ27XXX_O_OTDC),
  891. [BQ27542] = BQ27XXX_DATA(bq27542, 0 , BQ27XXX_O_OTDC),
  892. [BQ27546] = BQ27XXX_DATA(bq27546, 0 , BQ27XXX_O_OTDC),
  893. [BQ27742] = BQ27XXX_DATA(bq27742, 0 , BQ27XXX_O_OTDC),
  894. [BQ27545] = BQ27XXX_DATA(bq27545, 0x04143672, BQ27XXX_O_OTDC),
  895. [BQ27411] = BQ27XXX_DATA(bq27411, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
  896. [BQ27421] = BQ27XXX_DATA(bq27421, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
  897. [BQ27425] = BQ27XXX_DATA(bq27425, 0x04143672, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP),
  898. [BQ27426] = BQ27XXX_DATA(bq27426, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
  899. [BQ27441] = BQ27XXX_DATA(bq27441, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
  900. [BQ27621] = BQ27XXX_DATA(bq27621, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
  901. [BQ27Z561] = BQ27XXX_DATA(bq27z561, 0 , BQ27Z561_O_BITS),
  902. [BQ28Z610] = BQ27XXX_DATA(bq28z610, 0 , BQ27Z561_O_BITS),
  903. [BQ34Z100] = BQ27XXX_DATA(bq34z100, 0 , BQ27XXX_O_OTDC | BQ27XXX_O_SOC_SI | \
  904. BQ27XXX_O_HAS_CI | BQ27XXX_O_MUL_CHEM),
  905. };
  906. static DEFINE_MUTEX(bq27xxx_list_lock);
  907. static LIST_HEAD(bq27xxx_battery_devices);
  908. #define BQ27XXX_MSLEEP(i) usleep_range((i)*1000, (i)*1000+500)
  909. #define BQ27XXX_DM_SZ 32
  910. /**
  911. * struct bq27xxx_dm_buf - chip data memory buffer
  912. * @class: data memory subclass_id
  913. * @block: data memory block number
  914. * @data: data from/for the block
  915. * @has_data: true if data has been filled by read
  916. * @dirty: true if data has changed since last read/write
  917. *
  918. * Encapsulates info required to manage chip data memory blocks.
  919. */
  920. struct bq27xxx_dm_buf {
  921. u8 class;
  922. u8 block;
  923. u8 data[BQ27XXX_DM_SZ];
  924. bool has_data, dirty;
  925. };
  926. #define BQ27XXX_DM_BUF(di, i) { \
  927. .class = (di)->dm_regs[i].subclass_id, \
  928. .block = (di)->dm_regs[i].offset / BQ27XXX_DM_SZ, \
  929. }
  930. static inline u16 *bq27xxx_dm_reg_ptr(struct bq27xxx_dm_buf *buf,
  931. struct bq27xxx_dm_reg *reg)
  932. {
  933. if (buf->class == reg->subclass_id &&
  934. buf->block == reg->offset / BQ27XXX_DM_SZ)
  935. return (u16 *) (buf->data + reg->offset % BQ27XXX_DM_SZ);
  936. return NULL;
  937. }
  938. static const char * const bq27xxx_dm_reg_name[] = {
  939. [BQ27XXX_DM_DESIGN_CAPACITY] = "design-capacity",
  940. [BQ27XXX_DM_DESIGN_ENERGY] = "design-energy",
  941. [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
  942. };
  943. static bool bq27xxx_dt_to_nvm = true;
  944. module_param_named(dt_monitored_battery_updates_nvm, bq27xxx_dt_to_nvm, bool, 0444);
  945. MODULE_PARM_DESC(dt_monitored_battery_updates_nvm,
  946. "Devicetree monitored-battery config updates data memory on NVM/flash chips.\n"
  947. "Users must set this =0 when installing a different type of battery!\n"
  948. "Default is =1."
  949. #ifndef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
  950. "\nSetting this affects future kernel updates, not the current configuration."
  951. #endif
  952. );
  953. static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
  954. {
  955. struct bq27xxx_device_info *di;
  956. unsigned int prev_val = *(unsigned int *) kp->arg;
  957. int ret;
  958. ret = param_set_uint(val, kp);
  959. if (ret < 0 || prev_val == *(unsigned int *) kp->arg)
  960. return ret;
  961. mutex_lock(&bq27xxx_list_lock);
  962. list_for_each_entry(di, &bq27xxx_battery_devices, list) {
  963. cancel_delayed_work_sync(&di->work);
  964. schedule_delayed_work(&di->work, 0);
  965. }
  966. mutex_unlock(&bq27xxx_list_lock);
  967. return ret;
  968. }
  969. static const struct kernel_param_ops param_ops_poll_interval = {
  970. .get = param_get_uint,
  971. .set = poll_interval_param_set,
  972. };
  973. static unsigned int poll_interval = 360;
  974. module_param_cb(poll_interval, &param_ops_poll_interval, &poll_interval, 0644);
  975. MODULE_PARM_DESC(poll_interval,
  976. "battery poll interval in seconds - 0 disables polling");
  977. /*
  978. * Common code for BQ27xxx devices
  979. */
  980. static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
  981. bool single)
  982. {
  983. int ret;
  984. if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
  985. return -EINVAL;
  986. ret = di->bus.read(di, di->regs[reg_index], single);
  987. if (ret < 0)
  988. dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",
  989. di->regs[reg_index], reg_index);
  990. return ret;
  991. }
  992. static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index,
  993. u16 value, bool single)
  994. {
  995. int ret;
  996. if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
  997. return -EINVAL;
  998. if (!di->bus.write)
  999. return -EPERM;
  1000. ret = di->bus.write(di, di->regs[reg_index], value, single);
  1001. if (ret < 0)
  1002. dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",
  1003. di->regs[reg_index], reg_index);
  1004. return ret;
  1005. }
  1006. static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,
  1007. u8 *data, int len)
  1008. {
  1009. int ret;
  1010. if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
  1011. return -EINVAL;
  1012. if (!di->bus.read_bulk)
  1013. return -EPERM;
  1014. ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);
  1015. if (ret < 0)
  1016. dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",
  1017. di->regs[reg_index], reg_index);
  1018. return ret;
  1019. }
  1020. static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,
  1021. u8 *data, int len)
  1022. {
  1023. int ret;
  1024. if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
  1025. return -EINVAL;
  1026. if (!di->bus.write_bulk)
  1027. return -EPERM;
  1028. ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);
  1029. if (ret < 0)
  1030. dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",
  1031. di->regs[reg_index], reg_index);
  1032. return ret;
  1033. }
  1034. static int bq27xxx_battery_seal(struct bq27xxx_device_info *di)
  1035. {
  1036. int ret;
  1037. ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false);
  1038. if (ret < 0) {
  1039. dev_err(di->dev, "bus error on seal: %d\n", ret);
  1040. return ret;
  1041. }
  1042. return 0;
  1043. }
  1044. static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)
  1045. {
  1046. int ret;
  1047. if (di->unseal_key == 0) {
  1048. dev_err(di->dev, "unseal failed due to missing key\n");
  1049. return -EINVAL;
  1050. }
  1051. ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);
  1052. if (ret < 0)
  1053. goto out;
  1054. ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);
  1055. if (ret < 0)
  1056. goto out;
  1057. return 0;
  1058. out:
  1059. dev_err(di->dev, "bus error on unseal: %d\n", ret);
  1060. return ret;
  1061. }
  1062. static u8 bq27xxx_battery_checksum_dm_block(struct bq27xxx_dm_buf *buf)
  1063. {
  1064. u16 sum = 0;
  1065. int i;
  1066. for (i = 0; i < BQ27XXX_DM_SZ; i++)
  1067. sum += buf->data[i];
  1068. sum &= 0xff;
  1069. return 0xff - sum;
  1070. }
  1071. static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,
  1072. struct bq27xxx_dm_buf *buf)
  1073. {
  1074. int ret;
  1075. buf->has_data = false;
  1076. ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
  1077. if (ret < 0)
  1078. goto out;
  1079. ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
  1080. if (ret < 0)
  1081. goto out;
  1082. BQ27XXX_MSLEEP(1);
  1083. ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
  1084. if (ret < 0)
  1085. goto out;
  1086. ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);
  1087. if (ret < 0)
  1088. goto out;
  1089. if ((u8)ret != bq27xxx_battery_checksum_dm_block(buf)) {
  1090. ret = -EINVAL;
  1091. goto out;
  1092. }
  1093. buf->has_data = true;
  1094. buf->dirty = false;
  1095. return 0;
  1096. out:
  1097. dev_err(di->dev, "bus error reading chip memory: %d\n", ret);
  1098. return ret;
  1099. }
  1100. static void bq27xxx_battery_update_dm_block(struct bq27xxx_device_info *di,
  1101. struct bq27xxx_dm_buf *buf,
  1102. enum bq27xxx_dm_reg_id reg_id,
  1103. unsigned int val)
  1104. {
  1105. struct bq27xxx_dm_reg *reg = &di->dm_regs[reg_id];
  1106. const char *str = bq27xxx_dm_reg_name[reg_id];
  1107. u16 *prev = bq27xxx_dm_reg_ptr(buf, reg);
  1108. if (prev == NULL) {
  1109. dev_warn(di->dev, "buffer does not match %s dm spec\n", str);
  1110. return;
  1111. }
  1112. if (reg->bytes != 2) {
  1113. dev_warn(di->dev, "%s dm spec has unsupported byte size\n", str);
  1114. return;
  1115. }
  1116. if (!buf->has_data)
  1117. return;
  1118. if (be16_to_cpup(prev) == val) {
  1119. dev_info(di->dev, "%s has %u\n", str, val);
  1120. return;
  1121. }
  1122. #ifdef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
  1123. if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) {
  1124. #else
  1125. if (!(di->opts & BQ27XXX_O_RAM)) {
  1126. #endif
  1127. /* devicetree and NVM differ; defer to NVM */
  1128. dev_warn(di->dev, "%s has %u; update to %u disallowed "
  1129. #ifdef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
  1130. "by dt_monitored_battery_updates_nvm=0"
  1131. #else
  1132. "for flash/NVM data memory"
  1133. #endif
  1134. "\n", str, be16_to_cpup(prev), val);
  1135. return;
  1136. }
  1137. dev_info(di->dev, "update %s to %u\n", str, val);
  1138. *prev = cpu_to_be16(val);
  1139. buf->dirty = true;
  1140. }
  1141. static int bq27xxx_battery_cfgupdate_priv(struct bq27xxx_device_info *di, bool active)
  1142. {
  1143. const int limit = 100;
  1144. u16 cmd = active ? BQ27XXX_SET_CFGUPDATE : BQ27XXX_SOFT_RESET;
  1145. int ret, try = limit;
  1146. ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, cmd, false);
  1147. if (ret < 0)
  1148. return ret;
  1149. do {
  1150. BQ27XXX_MSLEEP(25);
  1151. ret = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
  1152. if (ret < 0)
  1153. return ret;
  1154. } while (!!(ret & BQ27XXX_FLAG_CFGUP) != active && --try);
  1155. if (!try && di->chip != BQ27425) { // 425 has a bug
  1156. dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active);
  1157. return -EINVAL;
  1158. }
  1159. if (limit - try > 3)
  1160. dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);
  1161. return 0;
  1162. }
  1163. static inline int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di)
  1164. {
  1165. int ret = bq27xxx_battery_cfgupdate_priv(di, true);
  1166. if (ret < 0 && ret != -EINVAL)
  1167. dev_err(di->dev, "bus error on set_cfgupdate: %d\n", ret);
  1168. return ret;
  1169. }
  1170. static inline int bq27xxx_battery_soft_reset(struct bq27xxx_device_info *di)
  1171. {
  1172. int ret = bq27xxx_battery_cfgupdate_priv(di, false);
  1173. if (ret < 0 && ret != -EINVAL)
  1174. dev_err(di->dev, "bus error on soft_reset: %d\n", ret);
  1175. return ret;
  1176. }
  1177. static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,
  1178. struct bq27xxx_dm_buf *buf)
  1179. {
  1180. bool cfgup = di->opts & BQ27XXX_O_CFGUP;
  1181. int ret;
  1182. if (!buf->dirty)
  1183. return 0;
  1184. if (cfgup) {
  1185. ret = bq27xxx_battery_set_cfgupdate(di);
  1186. if (ret < 0)
  1187. return ret;
  1188. }
  1189. ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
  1190. if (ret < 0)
  1191. goto out;
  1192. ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
  1193. if (ret < 0)
  1194. goto out;
  1195. ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
  1196. if (ret < 0)
  1197. goto out;
  1198. BQ27XXX_MSLEEP(1);
  1199. ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
  1200. if (ret < 0)
  1201. goto out;
  1202. ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
  1203. bq27xxx_battery_checksum_dm_block(buf), true);
  1204. if (ret < 0)
  1205. goto out;
  1206. /* DO NOT read BQ27XXX_DM_CKSUM here to verify it! That may cause NVM
  1207. * corruption on the '425 chip (and perhaps others), which can damage
  1208. * the chip.
  1209. */
  1210. if (cfgup) {
  1211. BQ27XXX_MSLEEP(1);
  1212. ret = bq27xxx_battery_soft_reset(di);
  1213. if (ret < 0)
  1214. return ret;
  1215. } else {
  1216. BQ27XXX_MSLEEP(100); /* flash DM updates in <100ms */
  1217. }
  1218. buf->dirty = false;
  1219. return 0;
  1220. out:
  1221. if (cfgup)
  1222. bq27xxx_battery_soft_reset(di);
  1223. dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
  1224. return ret;
  1225. }
  1226. static void bq27xxx_battery_set_config(struct bq27xxx_device_info *di,
  1227. struct power_supply_battery_info *info)
  1228. {
  1229. struct bq27xxx_dm_buf bd = BQ27XXX_DM_BUF(di, BQ27XXX_DM_DESIGN_CAPACITY);
  1230. struct bq27xxx_dm_buf bt = BQ27XXX_DM_BUF(di, BQ27XXX_DM_TERMINATE_VOLTAGE);
  1231. bool updated;
  1232. if (bq27xxx_battery_unseal(di) < 0)
  1233. return;
  1234. if (info->charge_full_design_uah != -EINVAL &&
  1235. info->energy_full_design_uwh != -EINVAL) {
  1236. bq27xxx_battery_read_dm_block(di, &bd);
  1237. /* assume design energy & capacity are in same block */
  1238. bq27xxx_battery_update_dm_block(di, &bd,
  1239. BQ27XXX_DM_DESIGN_CAPACITY,
  1240. info->charge_full_design_uah / 1000);
  1241. bq27xxx_battery_update_dm_block(di, &bd,
  1242. BQ27XXX_DM_DESIGN_ENERGY,
  1243. info->energy_full_design_uwh / 1000);
  1244. }
  1245. if (info->voltage_min_design_uv != -EINVAL) {
  1246. bool same = bd.class == bt.class && bd.block == bt.block;
  1247. if (!same)
  1248. bq27xxx_battery_read_dm_block(di, &bt);
  1249. bq27xxx_battery_update_dm_block(di, same ? &bd : &bt,
  1250. BQ27XXX_DM_TERMINATE_VOLTAGE,
  1251. info->voltage_min_design_uv / 1000);
  1252. }
  1253. updated = bd.dirty || bt.dirty;
  1254. bq27xxx_battery_write_dm_block(di, &bd);
  1255. bq27xxx_battery_write_dm_block(di, &bt);
  1256. bq27xxx_battery_seal(di);
  1257. if (updated && !(di->opts & BQ27XXX_O_CFGUP)) {
  1258. bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false);
  1259. BQ27XXX_MSLEEP(300); /* reset time is not documented */
  1260. }
  1261. /* assume bq27xxx_battery_update() is called hereafter */
  1262. }
  1263. static void bq27xxx_battery_settings(struct bq27xxx_device_info *di)
  1264. {
  1265. struct power_supply_battery_info info = {};
  1266. unsigned int min, max;
  1267. if (power_supply_get_battery_info(di->bat, &info) < 0)
  1268. return;
  1269. if (!di->dm_regs) {
  1270. dev_warn(di->dev, "data memory update not supported for chip\n");
  1271. return;
  1272. }
  1273. if (info.energy_full_design_uwh != info.charge_full_design_uah) {
  1274. if (info.energy_full_design_uwh == -EINVAL)
  1275. dev_warn(di->dev, "missing battery:energy-full-design-microwatt-hours\n");
  1276. else if (info.charge_full_design_uah == -EINVAL)
  1277. dev_warn(di->dev, "missing battery:charge-full-design-microamp-hours\n");
  1278. }
  1279. /* assume min == 0 */
  1280. max = di->dm_regs[BQ27XXX_DM_DESIGN_ENERGY].max;
  1281. if (info.energy_full_design_uwh > max * 1000) {
  1282. dev_err(di->dev, "invalid battery:energy-full-design-microwatt-hours %d\n",
  1283. info.energy_full_design_uwh);
  1284. info.energy_full_design_uwh = -EINVAL;
  1285. }
  1286. /* assume min == 0 */
  1287. max = di->dm_regs[BQ27XXX_DM_DESIGN_CAPACITY].max;
  1288. if (info.charge_full_design_uah > max * 1000) {
  1289. dev_err(di->dev, "invalid battery:charge-full-design-microamp-hours %d\n",
  1290. info.charge_full_design_uah);
  1291. info.charge_full_design_uah = -EINVAL;
  1292. }
  1293. min = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].min;
  1294. max = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].max;
  1295. if ((info.voltage_min_design_uv < min * 1000 ||
  1296. info.voltage_min_design_uv > max * 1000) &&
  1297. info.voltage_min_design_uv != -EINVAL) {
  1298. dev_err(di->dev, "invalid battery:voltage-min-design-microvolt %d\n",
  1299. info.voltage_min_design_uv);
  1300. info.voltage_min_design_uv = -EINVAL;
  1301. }
  1302. if ((info.energy_full_design_uwh != -EINVAL &&
  1303. info.charge_full_design_uah != -EINVAL) ||
  1304. info.voltage_min_design_uv != -EINVAL)
  1305. bq27xxx_battery_set_config(di, &info);
  1306. }
  1307. /*
  1308. * Return the battery State-of-Charge
  1309. * Or < 0 if something fails.
  1310. */
  1311. static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
  1312. {
  1313. int soc;
  1314. if (di->opts & BQ27XXX_O_SOC_SI)
  1315. soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true);
  1316. else
  1317. soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
  1318. if (soc < 0)
  1319. dev_dbg(di->dev, "error reading State-of-Charge\n");
  1320. return soc;
  1321. }
  1322. /*
  1323. * Return a battery charge value in µAh
  1324. * Or < 0 if something fails.
  1325. */
  1326. static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
  1327. {
  1328. int charge;
  1329. charge = bq27xxx_read(di, reg, false);
  1330. if (charge < 0) {
  1331. dev_dbg(di->dev, "error reading charge register %02x: %d\n",
  1332. reg, charge);
  1333. return charge;
  1334. }
  1335. if (di->opts & BQ27XXX_O_ZERO)
  1336. charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
  1337. else
  1338. charge *= 1000;
  1339. return charge;
  1340. }
  1341. /*
  1342. * Return the battery Nominal available capacity in µAh
  1343. * Or < 0 if something fails.
  1344. */
  1345. static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
  1346. {
  1347. int flags;
  1348. if (di->opts & BQ27XXX_O_ZERO) {
  1349. flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
  1350. if (flags >= 0 && (flags & BQ27000_FLAG_CI))
  1351. return -ENODATA;
  1352. }
  1353. return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
  1354. }
  1355. /*
  1356. * Return the battery Full Charge Capacity in µAh
  1357. * Or < 0 if something fails.
  1358. */
  1359. static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
  1360. {
  1361. return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
  1362. }
  1363. /*
  1364. * Return the Design Capacity in µAh
  1365. * Or < 0 if something fails.
  1366. */
  1367. static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
  1368. {
  1369. int dcap;
  1370. if (di->opts & BQ27XXX_O_ZERO)
  1371. dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true);
  1372. else
  1373. dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
  1374. if (dcap < 0) {
  1375. dev_dbg(di->dev, "error reading initial last measured discharge\n");
  1376. return dcap;
  1377. }
  1378. if (di->opts & BQ27XXX_O_ZERO)
  1379. dcap = (dcap << 8) * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
  1380. else
  1381. dcap *= 1000;
  1382. return dcap;
  1383. }
  1384. /*
  1385. * Return the battery Available energy in µWh
  1386. * Or < 0 if something fails.
  1387. */
  1388. static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
  1389. {
  1390. int ae;
  1391. ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
  1392. if (ae < 0) {
  1393. dev_dbg(di->dev, "error reading available energy\n");
  1394. return ae;
  1395. }
  1396. if (di->opts & BQ27XXX_O_ZERO)
  1397. ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
  1398. else
  1399. ae *= 1000;
  1400. return ae;
  1401. }
  1402. /*
  1403. * Return the battery temperature in tenths of degree Kelvin
  1404. * Or < 0 if something fails.
  1405. */
  1406. static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
  1407. {
  1408. int temp;
  1409. temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
  1410. if (temp < 0) {
  1411. dev_err(di->dev, "error reading temperature\n");
  1412. return temp;
  1413. }
  1414. if (di->opts & BQ27XXX_O_ZERO)
  1415. temp = 5 * temp / 2;
  1416. return temp;
  1417. }
  1418. /*
  1419. * Return the battery Cycle count total
  1420. * Or < 0 if something fails.
  1421. */
  1422. static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
  1423. {
  1424. int cyct;
  1425. cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
  1426. if (cyct < 0)
  1427. dev_err(di->dev, "error reading cycle count total\n");
  1428. return cyct;
  1429. }
  1430. /*
  1431. * Read a time register.
  1432. * Return < 0 if something fails.
  1433. */
  1434. static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
  1435. {
  1436. int tval;
  1437. tval = bq27xxx_read(di, reg, false);
  1438. if (tval < 0) {
  1439. dev_dbg(di->dev, "error reading time register %02x: %d\n",
  1440. reg, tval);
  1441. return tval;
  1442. }
  1443. if (tval == 65535)
  1444. return -ENODATA;
  1445. return tval * 60;
  1446. }
  1447. /*
  1448. * Returns true if a battery over temperature condition is detected
  1449. */
  1450. static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
  1451. {
  1452. if (di->opts & BQ27XXX_O_OTDC)
  1453. return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
  1454. if (di->opts & BQ27XXX_O_UTOT)
  1455. return flags & BQ27XXX_FLAG_OT;
  1456. return false;
  1457. }
  1458. /*
  1459. * Returns true if a battery under temperature condition is detected
  1460. */
  1461. static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
  1462. {
  1463. if (di->opts & BQ27XXX_O_UTOT)
  1464. return flags & BQ27XXX_FLAG_UT;
  1465. return false;
  1466. }
  1467. /*
  1468. * Returns true if a low state of charge condition is detected
  1469. */
  1470. static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
  1471. {
  1472. if (di->opts & BQ27XXX_O_ZERO)
  1473. return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
  1474. else if (di->opts & BQ27Z561_O_BITS)
  1475. return flags & BQ27Z561_FLAG_FDC;
  1476. else
  1477. return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
  1478. }
  1479. static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
  1480. {
  1481. /* Unlikely but important to return first */
  1482. if (unlikely(bq27xxx_battery_overtemp(di, di->cache.flags)))
  1483. return POWER_SUPPLY_HEALTH_OVERHEAT;
  1484. if (unlikely(bq27xxx_battery_undertemp(di, di->cache.flags)))
  1485. return POWER_SUPPLY_HEALTH_COLD;
  1486. if (unlikely(bq27xxx_battery_dead(di, di->cache.flags)))
  1487. return POWER_SUPPLY_HEALTH_DEAD;
  1488. return POWER_SUPPLY_HEALTH_GOOD;
  1489. }
  1490. void bq27xxx_battery_update(struct bq27xxx_device_info *di)
  1491. {
  1492. struct bq27xxx_reg_cache cache = {0, };
  1493. bool has_ci_flag = di->opts & BQ27XXX_O_HAS_CI;
  1494. bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
  1495. cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
  1496. if ((cache.flags & 0xff) == 0xff)
  1497. cache.flags = -1; /* read error */
  1498. if (cache.flags >= 0) {
  1499. cache.temperature = bq27xxx_battery_read_temperature(di);
  1500. if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
  1501. dev_info_once(di->dev, "battery is not calibrated! ignoring capacity values\n");
  1502. cache.capacity = -ENODATA;
  1503. cache.energy = -ENODATA;
  1504. cache.time_to_empty = -ENODATA;
  1505. cache.time_to_empty_avg = -ENODATA;
  1506. cache.time_to_full = -ENODATA;
  1507. cache.charge_full = -ENODATA;
  1508. cache.health = -ENODATA;
  1509. } else {
  1510. if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
  1511. cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
  1512. if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
  1513. cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
  1514. if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
  1515. cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
  1516. cache.charge_full = bq27xxx_battery_read_fcc(di);
  1517. cache.capacity = bq27xxx_battery_read_soc(di);
  1518. if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
  1519. cache.energy = bq27xxx_battery_read_energy(di);
  1520. di->cache.flags = cache.flags;
  1521. cache.health = bq27xxx_battery_read_health(di);
  1522. }
  1523. if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
  1524. cache.cycle_count = bq27xxx_battery_read_cyct(di);
  1525. /* We only have to read charge design full once */
  1526. if (di->charge_design_full <= 0)
  1527. di->charge_design_full = bq27xxx_battery_read_dcap(di);
  1528. }
  1529. if ((di->cache.capacity != cache.capacity) ||
  1530. (di->cache.flags != cache.flags))
  1531. power_supply_changed(di->bat);
  1532. if (memcmp(&di->cache, &cache, sizeof(cache)) != 0)
  1533. di->cache = cache;
  1534. di->last_update = jiffies;
  1535. }
  1536. EXPORT_SYMBOL_GPL(bq27xxx_battery_update);
  1537. static void bq27xxx_battery_poll(struct work_struct *work)
  1538. {
  1539. struct bq27xxx_device_info *di =
  1540. container_of(work, struct bq27xxx_device_info,
  1541. work.work);
  1542. bq27xxx_battery_update(di);
  1543. if (poll_interval > 0)
  1544. schedule_delayed_work(&di->work, poll_interval * HZ);
  1545. }
  1546. /*
  1547. * Return the battery average current in µA
  1548. * Note that current can be negative signed as well
  1549. * Or 0 if something fails.
  1550. */
  1551. static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
  1552. union power_supply_propval *val)
  1553. {
  1554. int curr;
  1555. int flags;
  1556. curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
  1557. if (curr < 0) {
  1558. dev_err(di->dev, "error reading current\n");
  1559. return curr;
  1560. }
  1561. if (di->opts & BQ27XXX_O_ZERO) {
  1562. flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
  1563. if (flags & BQ27000_FLAG_CHGS) {
  1564. dev_dbg(di->dev, "negative current!\n");
  1565. curr = -curr;
  1566. }
  1567. val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
  1568. } else {
  1569. /* Other gauges return signed value */
  1570. val->intval = (int)((s16)curr) * 1000;
  1571. }
  1572. return 0;
  1573. }
  1574. /*
  1575. * Get the average power in µW
  1576. * Return < 0 if something fails.
  1577. */
  1578. static int bq27xxx_battery_pwr_avg(struct bq27xxx_device_info *di,
  1579. union power_supply_propval *val)
  1580. {
  1581. int power;
  1582. power = bq27xxx_read(di, BQ27XXX_REG_AP, false);
  1583. if (power < 0) {
  1584. dev_err(di->dev,
  1585. "error reading average power register %02x: %d\n",
  1586. BQ27XXX_REG_AP, power);
  1587. return power;
  1588. }
  1589. if (di->opts & BQ27XXX_O_ZERO)
  1590. val->intval = (power * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
  1591. else
  1592. /* Other gauges return a signed value in units of 10mW */
  1593. val->intval = (int)((s16)power) * 10000;
  1594. return 0;
  1595. }
  1596. static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
  1597. union power_supply_propval *val)
  1598. {
  1599. int status;
  1600. if (di->opts & BQ27XXX_O_ZERO) {
  1601. if (di->cache.flags & BQ27000_FLAG_FC)
  1602. status = POWER_SUPPLY_STATUS_FULL;
  1603. else if (di->cache.flags & BQ27000_FLAG_CHGS)
  1604. status = POWER_SUPPLY_STATUS_CHARGING;
  1605. else
  1606. status = POWER_SUPPLY_STATUS_DISCHARGING;
  1607. } else if (di->opts & BQ27Z561_O_BITS) {
  1608. if (di->cache.flags & BQ27Z561_FLAG_FC)
  1609. status = POWER_SUPPLY_STATUS_FULL;
  1610. else if (di->cache.flags & BQ27Z561_FLAG_DIS_CH)
  1611. status = POWER_SUPPLY_STATUS_DISCHARGING;
  1612. else
  1613. status = POWER_SUPPLY_STATUS_CHARGING;
  1614. } else {
  1615. if (di->cache.flags & BQ27XXX_FLAG_FC)
  1616. status = POWER_SUPPLY_STATUS_FULL;
  1617. else if (di->cache.flags & BQ27XXX_FLAG_DSC)
  1618. status = POWER_SUPPLY_STATUS_DISCHARGING;
  1619. else
  1620. status = POWER_SUPPLY_STATUS_CHARGING;
  1621. }
  1622. if ((status == POWER_SUPPLY_STATUS_DISCHARGING) &&
  1623. (power_supply_am_i_supplied(di->bat) > 0))
  1624. status = POWER_SUPPLY_STATUS_NOT_CHARGING;
  1625. val->intval = status;
  1626. return 0;
  1627. }
  1628. static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
  1629. union power_supply_propval *val)
  1630. {
  1631. int level;
  1632. if (di->opts & BQ27XXX_O_ZERO) {
  1633. if (di->cache.flags & BQ27000_FLAG_FC)
  1634. level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
  1635. else if (di->cache.flags & BQ27000_FLAG_EDV1)
  1636. level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
  1637. else if (di->cache.flags & BQ27000_FLAG_EDVF)
  1638. level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
  1639. else
  1640. level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
  1641. } else if (di->opts & BQ27Z561_O_BITS) {
  1642. if (di->cache.flags & BQ27Z561_FLAG_FC)
  1643. level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
  1644. else if (di->cache.flags & BQ27Z561_FLAG_FDC)
  1645. level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
  1646. else
  1647. level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
  1648. } else {
  1649. if (di->cache.flags & BQ27XXX_FLAG_FC)
  1650. level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
  1651. else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
  1652. level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
  1653. else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
  1654. level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
  1655. else
  1656. level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
  1657. }
  1658. val->intval = level;
  1659. return 0;
  1660. }
  1661. /*
  1662. * Return the battery Voltage in millivolts
  1663. * Or < 0 if something fails.
  1664. */
  1665. static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
  1666. union power_supply_propval *val)
  1667. {
  1668. int volt;
  1669. volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
  1670. if (volt < 0) {
  1671. dev_err(di->dev, "error reading voltage\n");
  1672. return volt;
  1673. }
  1674. val->intval = volt * 1000;
  1675. return 0;
  1676. }
  1677. static int bq27xxx_simple_value(int value,
  1678. union power_supply_propval *val)
  1679. {
  1680. if (value < 0)
  1681. return value;
  1682. val->intval = value;
  1683. return 0;
  1684. }
  1685. static int bq27xxx_battery_get_property(struct power_supply *psy,
  1686. enum power_supply_property psp,
  1687. union power_supply_propval *val)
  1688. {
  1689. int ret = 0;
  1690. struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
  1691. mutex_lock(&di->lock);
  1692. if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
  1693. cancel_delayed_work_sync(&di->work);
  1694. bq27xxx_battery_poll(&di->work.work);
  1695. }
  1696. mutex_unlock(&di->lock);
  1697. if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
  1698. return -ENODEV;
  1699. switch (psp) {
  1700. case POWER_SUPPLY_PROP_STATUS:
  1701. ret = bq27xxx_battery_status(di, val);
  1702. break;
  1703. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  1704. ret = bq27xxx_battery_voltage(di, val);
  1705. break;
  1706. case POWER_SUPPLY_PROP_PRESENT:
  1707. val->intval = di->cache.flags < 0 ? 0 : 1;
  1708. break;
  1709. case POWER_SUPPLY_PROP_CURRENT_NOW:
  1710. ret = bq27xxx_battery_current(di, val);
  1711. break;
  1712. case POWER_SUPPLY_PROP_CAPACITY:
  1713. ret = bq27xxx_simple_value(di->cache.capacity, val);
  1714. break;
  1715. case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
  1716. ret = bq27xxx_battery_capacity_level(di, val);
  1717. break;
  1718. case POWER_SUPPLY_PROP_TEMP:
  1719. ret = bq27xxx_simple_value(di->cache.temperature, val);
  1720. if (ret == 0)
  1721. val->intval -= 2731; /* convert decidegree k to c */
  1722. break;
  1723. case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
  1724. ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
  1725. break;
  1726. case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
  1727. ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
  1728. break;
  1729. case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
  1730. ret = bq27xxx_simple_value(di->cache.time_to_full, val);
  1731. break;
  1732. case POWER_SUPPLY_PROP_TECHNOLOGY:
  1733. if (di->opts & BQ27XXX_O_MUL_CHEM)
  1734. val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
  1735. else
  1736. val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
  1737. break;
  1738. case POWER_SUPPLY_PROP_CHARGE_NOW:
  1739. ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
  1740. break;
  1741. case POWER_SUPPLY_PROP_CHARGE_FULL:
  1742. ret = bq27xxx_simple_value(di->cache.charge_full, val);
  1743. break;
  1744. case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
  1745. ret = bq27xxx_simple_value(di->charge_design_full, val);
  1746. break;
  1747. /*
  1748. * TODO: Implement these to make registers set from
  1749. * power_supply_battery_info visible in sysfs.
  1750. */
  1751. case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
  1752. case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
  1753. return -EINVAL;
  1754. case POWER_SUPPLY_PROP_CYCLE_COUNT:
  1755. ret = bq27xxx_simple_value(di->cache.cycle_count, val);
  1756. break;
  1757. case POWER_SUPPLY_PROP_ENERGY_NOW:
  1758. ret = bq27xxx_simple_value(di->cache.energy, val);
  1759. break;
  1760. case POWER_SUPPLY_PROP_POWER_AVG:
  1761. ret = bq27xxx_battery_pwr_avg(di, val);
  1762. break;
  1763. case POWER_SUPPLY_PROP_HEALTH:
  1764. ret = bq27xxx_simple_value(di->cache.health, val);
  1765. break;
  1766. case POWER_SUPPLY_PROP_MANUFACTURER:
  1767. val->strval = BQ27XXX_MANUFACTURER;
  1768. break;
  1769. default:
  1770. return -EINVAL;
  1771. }
  1772. return ret;
  1773. }
  1774. static void bq27xxx_external_power_changed(struct power_supply *psy)
  1775. {
  1776. struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
  1777. cancel_delayed_work_sync(&di->work);
  1778. schedule_delayed_work(&di->work, 0);
  1779. }
  1780. int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
  1781. {
  1782. struct power_supply_desc *psy_desc;
  1783. struct power_supply_config psy_cfg = {
  1784. .of_node = di->dev->of_node,
  1785. .drv_data = di,
  1786. };
  1787. INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
  1788. mutex_init(&di->lock);
  1789. di->regs = bq27xxx_chip_data[di->chip].regs;
  1790. di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key;
  1791. di->dm_regs = bq27xxx_chip_data[di->chip].dm_regs;
  1792. di->opts = bq27xxx_chip_data[di->chip].opts;
  1793. psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
  1794. if (!psy_desc)
  1795. return -ENOMEM;
  1796. psy_desc->name = di->name;
  1797. psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
  1798. psy_desc->properties = bq27xxx_chip_data[di->chip].props;
  1799. psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size;
  1800. psy_desc->get_property = bq27xxx_battery_get_property;
  1801. psy_desc->external_power_changed = bq27xxx_external_power_changed;
  1802. di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
  1803. if (IS_ERR(di->bat))
  1804. return dev_err_probe(di->dev, PTR_ERR(di->bat),
  1805. "failed to register battery\n");
  1806. bq27xxx_battery_settings(di);
  1807. bq27xxx_battery_update(di);
  1808. mutex_lock(&bq27xxx_list_lock);
  1809. list_add(&di->list, &bq27xxx_battery_devices);
  1810. mutex_unlock(&bq27xxx_list_lock);
  1811. return 0;
  1812. }
  1813. EXPORT_SYMBOL_GPL(bq27xxx_battery_setup);
  1814. void bq27xxx_battery_teardown(struct bq27xxx_device_info *di)
  1815. {
  1816. /*
  1817. * power_supply_unregister call bq27xxx_battery_get_property which
  1818. * call bq27xxx_battery_poll.
  1819. * Make sure that bq27xxx_battery_poll will not call
  1820. * schedule_delayed_work again after unregister (which cause OOPS).
  1821. */
  1822. poll_interval = 0;
  1823. cancel_delayed_work_sync(&di->work);
  1824. power_supply_unregister(di->bat);
  1825. mutex_lock(&bq27xxx_list_lock);
  1826. list_del(&di->list);
  1827. mutex_unlock(&bq27xxx_list_lock);
  1828. mutex_destroy(&di->lock);
  1829. }
  1830. EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown);
  1831. MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
  1832. MODULE_DESCRIPTION("BQ27xxx battery monitor driver");
  1833. MODULE_LICENSE("GPL");