bq24190_charger.c 54 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for the TI bq24190 battery charger.
  4. *
  5. * Author: Mark A. Greer <mgreer@animalcreek.com>
  6. */
  7. #include <linux/module.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/delay.h>
  10. #include <linux/of_irq.h>
  11. #include <linux/of_device.h>
  12. #include <linux/pm_runtime.h>
  13. #include <linux/power_supply.h>
  14. #include <linux/power/bq24190_charger.h>
  15. #include <linux/regulator/driver.h>
  16. #include <linux/regulator/machine.h>
  17. #include <linux/workqueue.h>
  18. #include <linux/gpio.h>
  19. #include <linux/i2c.h>
  20. #include <linux/extcon-provider.h>
  21. #define BQ24190_MANUFACTURER "Texas Instruments"
  22. #define BQ24190_REG_ISC 0x00 /* Input Source Control */
  23. #define BQ24190_REG_ISC_EN_HIZ_MASK BIT(7)
  24. #define BQ24190_REG_ISC_EN_HIZ_SHIFT 7
  25. #define BQ24190_REG_ISC_VINDPM_MASK (BIT(6) | BIT(5) | BIT(4) | \
  26. BIT(3))
  27. #define BQ24190_REG_ISC_VINDPM_SHIFT 3
  28. #define BQ24190_REG_ISC_IINLIM_MASK (BIT(2) | BIT(1) | BIT(0))
  29. #define BQ24190_REG_ISC_IINLIM_SHIFT 0
  30. #define BQ24190_REG_POC 0x01 /* Power-On Configuration */
  31. #define BQ24190_REG_POC_RESET_MASK BIT(7)
  32. #define BQ24190_REG_POC_RESET_SHIFT 7
  33. #define BQ24190_REG_POC_WDT_RESET_MASK BIT(6)
  34. #define BQ24190_REG_POC_WDT_RESET_SHIFT 6
  35. #define BQ24190_REG_POC_CHG_CONFIG_MASK (BIT(5) | BIT(4))
  36. #define BQ24190_REG_POC_CHG_CONFIG_SHIFT 4
  37. #define BQ24190_REG_POC_CHG_CONFIG_DISABLE 0x0
  38. #define BQ24190_REG_POC_CHG_CONFIG_CHARGE 0x1
  39. #define BQ24190_REG_POC_CHG_CONFIG_OTG 0x2
  40. #define BQ24190_REG_POC_CHG_CONFIG_OTG_ALT 0x3
  41. #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
  42. #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
  43. #define BQ24190_REG_POC_SYS_MIN_MIN 3000
  44. #define BQ24190_REG_POC_SYS_MIN_MAX 3700
  45. #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
  46. #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
  47. #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
  48. #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
  49. BIT(4) | BIT(3) | BIT(2))
  50. #define BQ24190_REG_CCC_ICHG_SHIFT 2
  51. #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
  52. #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
  53. #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
  54. #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
  55. BIT(4))
  56. #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
  57. #define BQ24190_REG_PCTCC_IPRECHG_MIN 128
  58. #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048
  59. #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
  60. BIT(0))
  61. #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
  62. #define BQ24190_REG_PCTCC_ITERM_MIN 128
  63. #define BQ24190_REG_PCTCC_ITERM_MAX 2048
  64. #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
  65. #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
  66. BIT(4) | BIT(3) | BIT(2))
  67. #define BQ24190_REG_CVC_VREG_SHIFT 2
  68. #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
  69. #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
  70. #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
  71. #define BQ24190_REG_CVC_VRECHG_SHIFT 0
  72. #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
  73. #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
  74. #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
  75. #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
  76. #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
  77. #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
  78. #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
  79. #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
  80. #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
  81. #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
  82. #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
  83. #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
  84. #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
  85. #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
  86. #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
  87. #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
  88. #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
  89. #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
  90. #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
  91. #define BQ24190_REG_ICTRC_TREG_SHIFT 0
  92. #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
  93. #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
  94. #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
  95. #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
  96. #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
  97. #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
  98. #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
  99. #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
  100. #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
  101. #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
  102. #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
  103. #define BQ24190_REG_SS 0x08 /* System Status */
  104. #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
  105. #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
  106. #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
  107. #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
  108. #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
  109. #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
  110. #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
  111. #define BQ24190_REG_SS_PG_STAT_SHIFT 2
  112. #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
  113. #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
  114. #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
  115. #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
  116. #define BQ24190_REG_F 0x09 /* Fault */
  117. #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
  118. #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
  119. #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
  120. #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
  121. #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
  122. #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
  123. #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
  124. #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
  125. #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
  126. #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
  127. #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
  128. #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
  129. #define BQ24190_REG_VPRS_PN_SHIFT 3
  130. #define BQ24190_REG_VPRS_PN_24190 0x4
  131. #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193, 24196 */
  132. #define BQ24190_REG_VPRS_PN_24192I 0x3
  133. #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
  134. #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
  135. #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
  136. #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
  137. /*
  138. * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
  139. * so the first read after a fault returns the latched value and subsequent
  140. * reads return the current value. In order to return the fault status
  141. * to the user, have the interrupt handler save the reg's value and retrieve
  142. * it in the appropriate health/status routine.
  143. */
  144. struct bq24190_dev_info {
  145. struct i2c_client *client;
  146. struct device *dev;
  147. struct extcon_dev *edev;
  148. struct power_supply *charger;
  149. struct power_supply *battery;
  150. struct delayed_work input_current_limit_work;
  151. char model_name[I2C_NAME_SIZE];
  152. bool initialized;
  153. bool irq_event;
  154. u16 sys_min;
  155. u16 iprechg;
  156. u16 iterm;
  157. struct mutex f_reg_lock;
  158. u8 f_reg;
  159. u8 ss_reg;
  160. u8 watchdog;
  161. };
  162. static const unsigned int bq24190_usb_extcon_cable[] = {
  163. EXTCON_USB,
  164. EXTCON_NONE,
  165. };
  166. /*
  167. * The tables below provide a 2-way mapping for the value that goes in
  168. * the register field and the real-world value that it represents.
  169. * The index of the array is the value that goes in the register; the
  170. * number at that index in the array is the real-world value that it
  171. * represents.
  172. */
  173. /* REG00[2:0] (IINLIM) in uAh */
  174. static const int bq24190_isc_iinlim_values[] = {
  175. 100000, 150000, 500000, 900000, 1200000, 1500000, 2000000, 3000000
  176. };
  177. /* REG02[7:2] (ICHG) in uAh */
  178. static const int bq24190_ccc_ichg_values[] = {
  179. 512000, 576000, 640000, 704000, 768000, 832000, 896000, 960000,
  180. 1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
  181. 1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
  182. 2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
  183. 2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
  184. 3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
  185. 3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
  186. 4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
  187. };
  188. /* REG04[7:2] (VREG) in uV */
  189. static const int bq24190_cvc_vreg_values[] = {
  190. 3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
  191. 3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
  192. 3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
  193. 3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
  194. 4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
  195. 4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
  196. 4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
  197. 4400000
  198. };
  199. /* REG06[1:0] (TREG) in tenths of degrees Celsius */
  200. static const int bq24190_ictrc_treg_values[] = {
  201. 600, 800, 1000, 1200
  202. };
  203. /*
  204. * Return the index in 'tbl' of greatest value that is less than or equal to
  205. * 'val'. The index range returned is 0 to 'tbl_size' - 1. Assumes that
  206. * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
  207. * is less than 2^8.
  208. */
  209. static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
  210. {
  211. int i;
  212. for (i = 1; i < tbl_size; i++)
  213. if (v < tbl[i])
  214. break;
  215. return i - 1;
  216. }
  217. /* Basic driver I/O routines */
  218. static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
  219. {
  220. int ret;
  221. ret = i2c_smbus_read_byte_data(bdi->client, reg);
  222. if (ret < 0)
  223. return ret;
  224. *data = ret;
  225. return 0;
  226. }
  227. static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
  228. {
  229. return i2c_smbus_write_byte_data(bdi->client, reg, data);
  230. }
  231. static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
  232. u8 mask, u8 shift, u8 *data)
  233. {
  234. u8 v;
  235. int ret;
  236. ret = bq24190_read(bdi, reg, &v);
  237. if (ret < 0)
  238. return ret;
  239. v &= mask;
  240. v >>= shift;
  241. *data = v;
  242. return 0;
  243. }
  244. static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
  245. u8 mask, u8 shift, u8 data)
  246. {
  247. u8 v;
  248. int ret;
  249. ret = bq24190_read(bdi, reg, &v);
  250. if (ret < 0)
  251. return ret;
  252. v &= ~mask;
  253. v |= ((data << shift) & mask);
  254. return bq24190_write(bdi, reg, v);
  255. }
  256. static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
  257. u8 reg, u8 mask, u8 shift,
  258. const int tbl[], int tbl_size,
  259. int *val)
  260. {
  261. u8 v;
  262. int ret;
  263. ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
  264. if (ret < 0)
  265. return ret;
  266. v = (v >= tbl_size) ? (tbl_size - 1) : v;
  267. *val = tbl[v];
  268. return 0;
  269. }
  270. static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
  271. u8 reg, u8 mask, u8 shift,
  272. const int tbl[], int tbl_size,
  273. int val)
  274. {
  275. u8 idx;
  276. idx = bq24190_find_idx(tbl, tbl_size, val);
  277. return bq24190_write_mask(bdi, reg, mask, shift, idx);
  278. }
  279. #ifdef CONFIG_SYSFS
  280. /*
  281. * There are a numerous options that are configurable on the bq24190
  282. * that go well beyond what the power_supply properties provide access to.
  283. * Provide sysfs access to them so they can be examined and possibly modified
  284. * on the fly. They will be provided for the charger power_supply object only
  285. * and will be prefixed by 'f_' to make them easier to recognize.
  286. */
  287. #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
  288. { \
  289. .attr = __ATTR(f_##_name, m, bq24190_sysfs_show, store), \
  290. .reg = BQ24190_REG_##r, \
  291. .mask = BQ24190_REG_##r##_##f##_MASK, \
  292. .shift = BQ24190_REG_##r##_##f##_SHIFT, \
  293. }
  294. #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
  295. BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
  296. bq24190_sysfs_store)
  297. #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
  298. BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
  299. static ssize_t bq24190_sysfs_show(struct device *dev,
  300. struct device_attribute *attr, char *buf);
  301. static ssize_t bq24190_sysfs_store(struct device *dev,
  302. struct device_attribute *attr, const char *buf, size_t count);
  303. struct bq24190_sysfs_field_info {
  304. struct device_attribute attr;
  305. u8 reg;
  306. u8 mask;
  307. u8 shift;
  308. };
  309. /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
  310. #undef SS
  311. static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
  312. /* sysfs name reg field in reg */
  313. BQ24190_SYSFS_FIELD_RW(en_hiz, ISC, EN_HIZ),
  314. BQ24190_SYSFS_FIELD_RW(vindpm, ISC, VINDPM),
  315. BQ24190_SYSFS_FIELD_RW(iinlim, ISC, IINLIM),
  316. BQ24190_SYSFS_FIELD_RW(chg_config, POC, CHG_CONFIG),
  317. BQ24190_SYSFS_FIELD_RW(sys_min, POC, SYS_MIN),
  318. BQ24190_SYSFS_FIELD_RW(boost_lim, POC, BOOST_LIM),
  319. BQ24190_SYSFS_FIELD_RW(ichg, CCC, ICHG),
  320. BQ24190_SYSFS_FIELD_RW(force_20_pct, CCC, FORCE_20PCT),
  321. BQ24190_SYSFS_FIELD_RW(iprechg, PCTCC, IPRECHG),
  322. BQ24190_SYSFS_FIELD_RW(iterm, PCTCC, ITERM),
  323. BQ24190_SYSFS_FIELD_RW(vreg, CVC, VREG),
  324. BQ24190_SYSFS_FIELD_RW(batlowv, CVC, BATLOWV),
  325. BQ24190_SYSFS_FIELD_RW(vrechg, CVC, VRECHG),
  326. BQ24190_SYSFS_FIELD_RW(en_term, CTTC, EN_TERM),
  327. BQ24190_SYSFS_FIELD_RW(term_stat, CTTC, TERM_STAT),
  328. BQ24190_SYSFS_FIELD_RO(watchdog, CTTC, WATCHDOG),
  329. BQ24190_SYSFS_FIELD_RW(en_timer, CTTC, EN_TIMER),
  330. BQ24190_SYSFS_FIELD_RW(chg_timer, CTTC, CHG_TIMER),
  331. BQ24190_SYSFS_FIELD_RW(jeta_iset, CTTC, JEITA_ISET),
  332. BQ24190_SYSFS_FIELD_RW(bat_comp, ICTRC, BAT_COMP),
  333. BQ24190_SYSFS_FIELD_RW(vclamp, ICTRC, VCLAMP),
  334. BQ24190_SYSFS_FIELD_RW(treg, ICTRC, TREG),
  335. BQ24190_SYSFS_FIELD_RW(dpdm_en, MOC, DPDM_EN),
  336. BQ24190_SYSFS_FIELD_RW(tmr2x_en, MOC, TMR2X_EN),
  337. BQ24190_SYSFS_FIELD_RW(batfet_disable, MOC, BATFET_DISABLE),
  338. BQ24190_SYSFS_FIELD_RW(jeita_vset, MOC, JEITA_VSET),
  339. BQ24190_SYSFS_FIELD_RO(int_mask, MOC, INT_MASK),
  340. BQ24190_SYSFS_FIELD_RO(vbus_stat, SS, VBUS_STAT),
  341. BQ24190_SYSFS_FIELD_RO(chrg_stat, SS, CHRG_STAT),
  342. BQ24190_SYSFS_FIELD_RO(dpm_stat, SS, DPM_STAT),
  343. BQ24190_SYSFS_FIELD_RO(pg_stat, SS, PG_STAT),
  344. BQ24190_SYSFS_FIELD_RO(therm_stat, SS, THERM_STAT),
  345. BQ24190_SYSFS_FIELD_RO(vsys_stat, SS, VSYS_STAT),
  346. BQ24190_SYSFS_FIELD_RO(watchdog_fault, F, WATCHDOG_FAULT),
  347. BQ24190_SYSFS_FIELD_RO(boost_fault, F, BOOST_FAULT),
  348. BQ24190_SYSFS_FIELD_RO(chrg_fault, F, CHRG_FAULT),
  349. BQ24190_SYSFS_FIELD_RO(bat_fault, F, BAT_FAULT),
  350. BQ24190_SYSFS_FIELD_RO(ntc_fault, F, NTC_FAULT),
  351. BQ24190_SYSFS_FIELD_RO(pn, VPRS, PN),
  352. BQ24190_SYSFS_FIELD_RO(ts_profile, VPRS, TS_PROFILE),
  353. BQ24190_SYSFS_FIELD_RO(dev_reg, VPRS, DEV_REG),
  354. };
  355. static struct attribute *
  356. bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
  357. ATTRIBUTE_GROUPS(bq24190_sysfs);
  358. static void bq24190_sysfs_init_attrs(void)
  359. {
  360. int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
  361. for (i = 0; i < limit; i++)
  362. bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
  363. bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
  364. }
  365. static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
  366. const char *name)
  367. {
  368. int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
  369. for (i = 0; i < limit; i++)
  370. if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
  371. break;
  372. if (i >= limit)
  373. return NULL;
  374. return &bq24190_sysfs_field_tbl[i];
  375. }
  376. static ssize_t bq24190_sysfs_show(struct device *dev,
  377. struct device_attribute *attr, char *buf)
  378. {
  379. struct power_supply *psy = dev_get_drvdata(dev);
  380. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  381. struct bq24190_sysfs_field_info *info;
  382. ssize_t count;
  383. int ret;
  384. u8 v;
  385. info = bq24190_sysfs_field_lookup(attr->attr.name);
  386. if (!info)
  387. return -EINVAL;
  388. ret = pm_runtime_get_sync(bdi->dev);
  389. if (ret < 0) {
  390. pm_runtime_put_noidle(bdi->dev);
  391. return ret;
  392. }
  393. ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
  394. if (ret)
  395. count = ret;
  396. else
  397. count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
  398. pm_runtime_mark_last_busy(bdi->dev);
  399. pm_runtime_put_autosuspend(bdi->dev);
  400. return count;
  401. }
  402. static ssize_t bq24190_sysfs_store(struct device *dev,
  403. struct device_attribute *attr, const char *buf, size_t count)
  404. {
  405. struct power_supply *psy = dev_get_drvdata(dev);
  406. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  407. struct bq24190_sysfs_field_info *info;
  408. int ret;
  409. u8 v;
  410. info = bq24190_sysfs_field_lookup(attr->attr.name);
  411. if (!info)
  412. return -EINVAL;
  413. ret = kstrtou8(buf, 0, &v);
  414. if (ret < 0)
  415. return ret;
  416. ret = pm_runtime_get_sync(bdi->dev);
  417. if (ret < 0) {
  418. pm_runtime_put_noidle(bdi->dev);
  419. return ret;
  420. }
  421. ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
  422. if (ret)
  423. count = ret;
  424. pm_runtime_mark_last_busy(bdi->dev);
  425. pm_runtime_put_autosuspend(bdi->dev);
  426. return count;
  427. }
  428. #endif
  429. #ifdef CONFIG_REGULATOR
  430. static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
  431. {
  432. struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
  433. int ret;
  434. ret = pm_runtime_get_sync(bdi->dev);
  435. if (ret < 0) {
  436. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
  437. pm_runtime_put_noidle(bdi->dev);
  438. return ret;
  439. }
  440. ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
  441. BQ24190_REG_POC_CHG_CONFIG_MASK,
  442. BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
  443. pm_runtime_mark_last_busy(bdi->dev);
  444. pm_runtime_put_autosuspend(bdi->dev);
  445. return ret;
  446. }
  447. static int bq24190_vbus_enable(struct regulator_dev *dev)
  448. {
  449. return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
  450. }
  451. static int bq24190_vbus_disable(struct regulator_dev *dev)
  452. {
  453. return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
  454. }
  455. static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
  456. {
  457. struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
  458. int ret;
  459. u8 val;
  460. ret = pm_runtime_get_sync(bdi->dev);
  461. if (ret < 0) {
  462. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
  463. pm_runtime_put_noidle(bdi->dev);
  464. return ret;
  465. }
  466. ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
  467. BQ24190_REG_POC_CHG_CONFIG_MASK,
  468. BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
  469. pm_runtime_mark_last_busy(bdi->dev);
  470. pm_runtime_put_autosuspend(bdi->dev);
  471. if (ret)
  472. return ret;
  473. return (val == BQ24190_REG_POC_CHG_CONFIG_OTG ||
  474. val == BQ24190_REG_POC_CHG_CONFIG_OTG_ALT);
  475. }
  476. static const struct regulator_ops bq24190_vbus_ops = {
  477. .enable = bq24190_vbus_enable,
  478. .disable = bq24190_vbus_disable,
  479. .is_enabled = bq24190_vbus_is_enabled,
  480. };
  481. static const struct regulator_desc bq24190_vbus_desc = {
  482. .name = "usb_otg_vbus",
  483. .of_match = "usb-otg-vbus",
  484. .type = REGULATOR_VOLTAGE,
  485. .owner = THIS_MODULE,
  486. .ops = &bq24190_vbus_ops,
  487. .fixed_uV = 5000000,
  488. .n_voltages = 1,
  489. };
  490. static const struct regulator_init_data bq24190_vbus_init_data = {
  491. .constraints = {
  492. .valid_ops_mask = REGULATOR_CHANGE_STATUS,
  493. },
  494. };
  495. static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
  496. {
  497. struct bq24190_platform_data *pdata = bdi->dev->platform_data;
  498. struct regulator_config cfg = { };
  499. struct regulator_dev *reg;
  500. int ret = 0;
  501. cfg.dev = bdi->dev;
  502. if (pdata && pdata->regulator_init_data)
  503. cfg.init_data = pdata->regulator_init_data;
  504. else
  505. cfg.init_data = &bq24190_vbus_init_data;
  506. cfg.driver_data = bdi;
  507. reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
  508. if (IS_ERR(reg)) {
  509. ret = PTR_ERR(reg);
  510. dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
  511. }
  512. return ret;
  513. }
  514. #else
  515. static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
  516. {
  517. return 0;
  518. }
  519. #endif
  520. static int bq24190_set_config(struct bq24190_dev_info *bdi)
  521. {
  522. int ret;
  523. u8 v;
  524. ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
  525. if (ret < 0)
  526. return ret;
  527. bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
  528. BQ24190_REG_CTTC_WATCHDOG_SHIFT);
  529. /*
  530. * According to the "Host Mode and default Mode" section of the
  531. * manual, a write to any register causes the bq24190 to switch
  532. * from default mode to host mode. It will switch back to default
  533. * mode after a WDT timeout unless the WDT is turned off as well.
  534. * So, by simply turning off the WDT, we accomplish both with the
  535. * same write.
  536. */
  537. v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
  538. ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
  539. if (ret < 0)
  540. return ret;
  541. if (bdi->sys_min) {
  542. v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
  543. ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
  544. BQ24190_REG_POC_SYS_MIN_MASK,
  545. BQ24190_REG_POC_SYS_MIN_SHIFT,
  546. v);
  547. if (ret < 0)
  548. return ret;
  549. }
  550. if (bdi->iprechg) {
  551. v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
  552. ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
  553. BQ24190_REG_PCTCC_IPRECHG_MASK,
  554. BQ24190_REG_PCTCC_IPRECHG_SHIFT,
  555. v);
  556. if (ret < 0)
  557. return ret;
  558. }
  559. if (bdi->iterm) {
  560. v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
  561. ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
  562. BQ24190_REG_PCTCC_ITERM_MASK,
  563. BQ24190_REG_PCTCC_ITERM_SHIFT,
  564. v);
  565. if (ret < 0)
  566. return ret;
  567. }
  568. return 0;
  569. }
  570. static int bq24190_register_reset(struct bq24190_dev_info *bdi)
  571. {
  572. int ret, limit = 100;
  573. u8 v;
  574. /*
  575. * This prop. can be passed on device instantiation from platform code:
  576. * struct property_entry pe[] =
  577. * { PROPERTY_ENTRY_BOOL("disable-reset"), ... };
  578. * struct i2c_board_info bi =
  579. * { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
  580. * struct i2c_adapter ad = { ... };
  581. * i2c_add_adapter(&ad);
  582. * i2c_new_client_device(&ad, &bi);
  583. */
  584. if (device_property_read_bool(bdi->dev, "disable-reset"))
  585. return 0;
  586. /* Reset the registers */
  587. ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
  588. BQ24190_REG_POC_RESET_MASK,
  589. BQ24190_REG_POC_RESET_SHIFT,
  590. 0x1);
  591. if (ret < 0)
  592. return ret;
  593. /* Reset bit will be cleared by hardware so poll until it is */
  594. do {
  595. ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
  596. BQ24190_REG_POC_RESET_MASK,
  597. BQ24190_REG_POC_RESET_SHIFT,
  598. &v);
  599. if (ret < 0)
  600. return ret;
  601. if (v == 0)
  602. return 0;
  603. usleep_range(100, 200);
  604. } while (--limit);
  605. return -EIO;
  606. }
  607. /* Charger power supply property routines */
  608. static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
  609. union power_supply_propval *val)
  610. {
  611. u8 v;
  612. int type, ret;
  613. ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
  614. BQ24190_REG_POC_CHG_CONFIG_MASK,
  615. BQ24190_REG_POC_CHG_CONFIG_SHIFT,
  616. &v);
  617. if (ret < 0)
  618. return ret;
  619. /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
  620. if (!v) {
  621. type = POWER_SUPPLY_CHARGE_TYPE_NONE;
  622. } else {
  623. ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
  624. BQ24190_REG_CCC_FORCE_20PCT_MASK,
  625. BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
  626. &v);
  627. if (ret < 0)
  628. return ret;
  629. type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
  630. POWER_SUPPLY_CHARGE_TYPE_FAST;
  631. }
  632. val->intval = type;
  633. return 0;
  634. }
  635. static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
  636. const union power_supply_propval *val)
  637. {
  638. u8 chg_config, force_20pct, en_term;
  639. int ret;
  640. /*
  641. * According to the "Termination when REG02[0] = 1" section of
  642. * the bq24190 manual, the trickle charge could be less than the
  643. * termination current so it recommends turning off the termination
  644. * function.
  645. *
  646. * Note: AFAICT from the datasheet, the user will have to manually
  647. * turn off the charging when in 20% mode. If its not turned off,
  648. * there could be battery damage. So, use this mode at your own risk.
  649. */
  650. switch (val->intval) {
  651. case POWER_SUPPLY_CHARGE_TYPE_NONE:
  652. chg_config = 0x0;
  653. break;
  654. case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
  655. chg_config = 0x1;
  656. force_20pct = 0x1;
  657. en_term = 0x0;
  658. break;
  659. case POWER_SUPPLY_CHARGE_TYPE_FAST:
  660. chg_config = 0x1;
  661. force_20pct = 0x0;
  662. en_term = 0x1;
  663. break;
  664. default:
  665. return -EINVAL;
  666. }
  667. if (chg_config) { /* Enabling the charger */
  668. ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
  669. BQ24190_REG_CCC_FORCE_20PCT_MASK,
  670. BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
  671. force_20pct);
  672. if (ret < 0)
  673. return ret;
  674. ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
  675. BQ24190_REG_CTTC_EN_TERM_MASK,
  676. BQ24190_REG_CTTC_EN_TERM_SHIFT,
  677. en_term);
  678. if (ret < 0)
  679. return ret;
  680. }
  681. return bq24190_write_mask(bdi, BQ24190_REG_POC,
  682. BQ24190_REG_POC_CHG_CONFIG_MASK,
  683. BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
  684. }
  685. static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
  686. union power_supply_propval *val)
  687. {
  688. u8 v;
  689. int health;
  690. mutex_lock(&bdi->f_reg_lock);
  691. v = bdi->f_reg;
  692. mutex_unlock(&bdi->f_reg_lock);
  693. if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
  694. switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
  695. case 0x1: /* TS1 Cold */
  696. case 0x3: /* TS2 Cold */
  697. case 0x5: /* Both Cold */
  698. health = POWER_SUPPLY_HEALTH_COLD;
  699. break;
  700. case 0x2: /* TS1 Hot */
  701. case 0x4: /* TS2 Hot */
  702. case 0x6: /* Both Hot */
  703. health = POWER_SUPPLY_HEALTH_OVERHEAT;
  704. break;
  705. default:
  706. health = POWER_SUPPLY_HEALTH_UNKNOWN;
  707. }
  708. } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
  709. health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  710. } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
  711. switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
  712. case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
  713. /*
  714. * This could be over-voltage or under-voltage
  715. * and there's no way to tell which. Instead
  716. * of looking foolish and returning 'OVERVOLTAGE'
  717. * when its really under-voltage, just return
  718. * 'UNSPEC_FAILURE'.
  719. */
  720. health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  721. break;
  722. case 0x2: /* Thermal Shutdown */
  723. health = POWER_SUPPLY_HEALTH_OVERHEAT;
  724. break;
  725. case 0x3: /* Charge Safety Timer Expiration */
  726. health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
  727. break;
  728. default: /* prevent compiler warning */
  729. health = -1;
  730. }
  731. } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
  732. /*
  733. * This could be over-current or over-voltage but there's
  734. * no way to tell which. Return 'OVERVOLTAGE' since there
  735. * isn't an 'OVERCURRENT' value defined that we can return
  736. * even if it was over-current.
  737. */
  738. health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  739. } else {
  740. health = POWER_SUPPLY_HEALTH_GOOD;
  741. }
  742. val->intval = health;
  743. return 0;
  744. }
  745. static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
  746. union power_supply_propval *val)
  747. {
  748. u8 pg_stat, batfet_disable;
  749. int ret;
  750. ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
  751. BQ24190_REG_SS_PG_STAT_MASK,
  752. BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
  753. if (ret < 0)
  754. return ret;
  755. ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
  756. BQ24190_REG_MOC_BATFET_DISABLE_MASK,
  757. BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
  758. if (ret < 0)
  759. return ret;
  760. val->intval = pg_stat && !batfet_disable;
  761. return 0;
  762. }
  763. static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
  764. const union power_supply_propval *val);
  765. static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
  766. union power_supply_propval *val);
  767. static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
  768. union power_supply_propval *val);
  769. static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
  770. const union power_supply_propval *val);
  771. static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
  772. const union power_supply_propval *val)
  773. {
  774. return bq24190_battery_set_online(bdi, val);
  775. }
  776. static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
  777. union power_supply_propval *val)
  778. {
  779. return bq24190_battery_get_status(bdi, val);
  780. }
  781. static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
  782. union power_supply_propval *val)
  783. {
  784. return bq24190_battery_get_temp_alert_max(bdi, val);
  785. }
  786. static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
  787. const union power_supply_propval *val)
  788. {
  789. return bq24190_battery_set_temp_alert_max(bdi, val);
  790. }
  791. static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
  792. union power_supply_propval *val)
  793. {
  794. u8 v;
  795. int ret;
  796. ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
  797. BQ24190_REG_PCTCC_IPRECHG_MASK,
  798. BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
  799. if (ret < 0)
  800. return ret;
  801. val->intval = ++v * 128 * 1000;
  802. return 0;
  803. }
  804. static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
  805. union power_supply_propval *val)
  806. {
  807. u8 v;
  808. int ret;
  809. ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
  810. BQ24190_REG_PCTCC_ITERM_MASK,
  811. BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
  812. if (ret < 0)
  813. return ret;
  814. val->intval = ++v * 128 * 1000;
  815. return 0;
  816. }
  817. static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
  818. union power_supply_propval *val)
  819. {
  820. u8 v;
  821. int curr, ret;
  822. ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
  823. BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
  824. bq24190_ccc_ichg_values,
  825. ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
  826. if (ret < 0)
  827. return ret;
  828. ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
  829. BQ24190_REG_CCC_FORCE_20PCT_MASK,
  830. BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
  831. if (ret < 0)
  832. return ret;
  833. /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
  834. if (v)
  835. curr /= 5;
  836. val->intval = curr;
  837. return 0;
  838. }
  839. static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
  840. union power_supply_propval *val)
  841. {
  842. int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
  843. val->intval = bq24190_ccc_ichg_values[idx];
  844. return 0;
  845. }
  846. static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
  847. const union power_supply_propval *val)
  848. {
  849. u8 v;
  850. int ret, curr = val->intval;
  851. ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
  852. BQ24190_REG_CCC_FORCE_20PCT_MASK,
  853. BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
  854. if (ret < 0)
  855. return ret;
  856. /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
  857. if (v)
  858. curr *= 5;
  859. return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
  860. BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
  861. bq24190_ccc_ichg_values,
  862. ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
  863. }
  864. static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
  865. union power_supply_propval *val)
  866. {
  867. int voltage, ret;
  868. ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
  869. BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
  870. bq24190_cvc_vreg_values,
  871. ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
  872. if (ret < 0)
  873. return ret;
  874. val->intval = voltage;
  875. return 0;
  876. }
  877. static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
  878. union power_supply_propval *val)
  879. {
  880. int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
  881. val->intval = bq24190_cvc_vreg_values[idx];
  882. return 0;
  883. }
  884. static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
  885. const union power_supply_propval *val)
  886. {
  887. return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
  888. BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
  889. bq24190_cvc_vreg_values,
  890. ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
  891. }
  892. static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
  893. union power_supply_propval *val)
  894. {
  895. int iinlimit, ret;
  896. ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
  897. BQ24190_REG_ISC_IINLIM_MASK,
  898. BQ24190_REG_ISC_IINLIM_SHIFT,
  899. bq24190_isc_iinlim_values,
  900. ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
  901. if (ret < 0)
  902. return ret;
  903. val->intval = iinlimit;
  904. return 0;
  905. }
  906. static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
  907. const union power_supply_propval *val)
  908. {
  909. return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
  910. BQ24190_REG_ISC_IINLIM_MASK,
  911. BQ24190_REG_ISC_IINLIM_SHIFT,
  912. bq24190_isc_iinlim_values,
  913. ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
  914. }
  915. static int bq24190_charger_get_property(struct power_supply *psy,
  916. enum power_supply_property psp, union power_supply_propval *val)
  917. {
  918. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  919. int ret;
  920. dev_dbg(bdi->dev, "prop: %d\n", psp);
  921. ret = pm_runtime_get_sync(bdi->dev);
  922. if (ret < 0) {
  923. pm_runtime_put_noidle(bdi->dev);
  924. return ret;
  925. }
  926. switch (psp) {
  927. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  928. ret = bq24190_charger_get_charge_type(bdi, val);
  929. break;
  930. case POWER_SUPPLY_PROP_HEALTH:
  931. ret = bq24190_charger_get_health(bdi, val);
  932. break;
  933. case POWER_SUPPLY_PROP_ONLINE:
  934. ret = bq24190_charger_get_online(bdi, val);
  935. break;
  936. case POWER_SUPPLY_PROP_STATUS:
  937. ret = bq24190_charger_get_status(bdi, val);
  938. break;
  939. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  940. ret = bq24190_charger_get_temp_alert_max(bdi, val);
  941. break;
  942. case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
  943. ret = bq24190_charger_get_precharge(bdi, val);
  944. break;
  945. case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
  946. ret = bq24190_charger_get_charge_term(bdi, val);
  947. break;
  948. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  949. ret = bq24190_charger_get_current(bdi, val);
  950. break;
  951. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
  952. ret = bq24190_charger_get_current_max(bdi, val);
  953. break;
  954. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  955. ret = bq24190_charger_get_voltage(bdi, val);
  956. break;
  957. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  958. ret = bq24190_charger_get_voltage_max(bdi, val);
  959. break;
  960. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  961. ret = bq24190_charger_get_iinlimit(bdi, val);
  962. break;
  963. case POWER_SUPPLY_PROP_SCOPE:
  964. val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
  965. ret = 0;
  966. break;
  967. case POWER_SUPPLY_PROP_MODEL_NAME:
  968. val->strval = bdi->model_name;
  969. ret = 0;
  970. break;
  971. case POWER_SUPPLY_PROP_MANUFACTURER:
  972. val->strval = BQ24190_MANUFACTURER;
  973. ret = 0;
  974. break;
  975. default:
  976. ret = -ENODATA;
  977. }
  978. pm_runtime_mark_last_busy(bdi->dev);
  979. pm_runtime_put_autosuspend(bdi->dev);
  980. return ret;
  981. }
  982. static int bq24190_charger_set_property(struct power_supply *psy,
  983. enum power_supply_property psp,
  984. const union power_supply_propval *val)
  985. {
  986. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  987. int ret;
  988. dev_dbg(bdi->dev, "prop: %d\n", psp);
  989. ret = pm_runtime_get_sync(bdi->dev);
  990. if (ret < 0) {
  991. pm_runtime_put_noidle(bdi->dev);
  992. return ret;
  993. }
  994. switch (psp) {
  995. case POWER_SUPPLY_PROP_ONLINE:
  996. ret = bq24190_charger_set_online(bdi, val);
  997. break;
  998. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  999. ret = bq24190_charger_set_temp_alert_max(bdi, val);
  1000. break;
  1001. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  1002. ret = bq24190_charger_set_charge_type(bdi, val);
  1003. break;
  1004. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  1005. ret = bq24190_charger_set_current(bdi, val);
  1006. break;
  1007. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  1008. ret = bq24190_charger_set_voltage(bdi, val);
  1009. break;
  1010. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  1011. ret = bq24190_charger_set_iinlimit(bdi, val);
  1012. break;
  1013. default:
  1014. ret = -EINVAL;
  1015. }
  1016. pm_runtime_mark_last_busy(bdi->dev);
  1017. pm_runtime_put_autosuspend(bdi->dev);
  1018. return ret;
  1019. }
  1020. static int bq24190_charger_property_is_writeable(struct power_supply *psy,
  1021. enum power_supply_property psp)
  1022. {
  1023. switch (psp) {
  1024. case POWER_SUPPLY_PROP_ONLINE:
  1025. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  1026. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  1027. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  1028. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  1029. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  1030. return 1;
  1031. default:
  1032. return 0;
  1033. }
  1034. }
  1035. static void bq24190_input_current_limit_work(struct work_struct *work)
  1036. {
  1037. struct bq24190_dev_info *bdi =
  1038. container_of(work, struct bq24190_dev_info,
  1039. input_current_limit_work.work);
  1040. power_supply_set_input_current_limit_from_supplier(bdi->charger);
  1041. }
  1042. /* Sync the input-current-limit with our parent supply (if we have one) */
  1043. static void bq24190_charger_external_power_changed(struct power_supply *psy)
  1044. {
  1045. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  1046. /*
  1047. * The Power-Good detection may take up to 220ms, sometimes
  1048. * the external charger detection is quicker, and the bq24190 will
  1049. * reset to iinlim based on its own charger detection (which is not
  1050. * hooked up when using external charger detection) resulting in a
  1051. * too low default 500mA iinlim. Delay setting the input-current-limit
  1052. * for 300ms to avoid this.
  1053. */
  1054. queue_delayed_work(system_wq, &bdi->input_current_limit_work,
  1055. msecs_to_jiffies(300));
  1056. }
  1057. static enum power_supply_property bq24190_charger_properties[] = {
  1058. POWER_SUPPLY_PROP_CHARGE_TYPE,
  1059. POWER_SUPPLY_PROP_HEALTH,
  1060. POWER_SUPPLY_PROP_ONLINE,
  1061. POWER_SUPPLY_PROP_STATUS,
  1062. POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
  1063. POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
  1064. POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
  1065. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
  1066. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
  1067. POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
  1068. POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
  1069. POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
  1070. POWER_SUPPLY_PROP_SCOPE,
  1071. POWER_SUPPLY_PROP_MODEL_NAME,
  1072. POWER_SUPPLY_PROP_MANUFACTURER,
  1073. };
  1074. static char *bq24190_charger_supplied_to[] = {
  1075. "main-battery",
  1076. };
  1077. static const struct power_supply_desc bq24190_charger_desc = {
  1078. .name = "bq24190-charger",
  1079. .type = POWER_SUPPLY_TYPE_USB,
  1080. .properties = bq24190_charger_properties,
  1081. .num_properties = ARRAY_SIZE(bq24190_charger_properties),
  1082. .get_property = bq24190_charger_get_property,
  1083. .set_property = bq24190_charger_set_property,
  1084. .property_is_writeable = bq24190_charger_property_is_writeable,
  1085. .external_power_changed = bq24190_charger_external_power_changed,
  1086. };
  1087. /* Battery power supply property routines */
  1088. static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
  1089. union power_supply_propval *val)
  1090. {
  1091. u8 ss_reg, chrg_fault;
  1092. int status, ret;
  1093. mutex_lock(&bdi->f_reg_lock);
  1094. chrg_fault = bdi->f_reg;
  1095. mutex_unlock(&bdi->f_reg_lock);
  1096. chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
  1097. chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
  1098. ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
  1099. if (ret < 0)
  1100. return ret;
  1101. /*
  1102. * The battery must be discharging when any of these are true:
  1103. * - there is no good power source;
  1104. * - there is a charge fault.
  1105. * Could also be discharging when in "supplement mode" but
  1106. * there is no way to tell when its in that mode.
  1107. */
  1108. if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
  1109. status = POWER_SUPPLY_STATUS_DISCHARGING;
  1110. } else {
  1111. ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
  1112. ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
  1113. switch (ss_reg) {
  1114. case 0x0: /* Not Charging */
  1115. status = POWER_SUPPLY_STATUS_NOT_CHARGING;
  1116. break;
  1117. case 0x1: /* Pre-charge */
  1118. case 0x2: /* Fast Charging */
  1119. status = POWER_SUPPLY_STATUS_CHARGING;
  1120. break;
  1121. case 0x3: /* Charge Termination Done */
  1122. status = POWER_SUPPLY_STATUS_FULL;
  1123. break;
  1124. default:
  1125. ret = -EIO;
  1126. }
  1127. }
  1128. if (!ret)
  1129. val->intval = status;
  1130. return ret;
  1131. }
  1132. static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
  1133. union power_supply_propval *val)
  1134. {
  1135. u8 v;
  1136. int health;
  1137. mutex_lock(&bdi->f_reg_lock);
  1138. v = bdi->f_reg;
  1139. mutex_unlock(&bdi->f_reg_lock);
  1140. if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
  1141. health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  1142. } else {
  1143. v &= BQ24190_REG_F_NTC_FAULT_MASK;
  1144. v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
  1145. switch (v) {
  1146. case 0x0: /* Normal */
  1147. health = POWER_SUPPLY_HEALTH_GOOD;
  1148. break;
  1149. case 0x1: /* TS1 Cold */
  1150. case 0x3: /* TS2 Cold */
  1151. case 0x5: /* Both Cold */
  1152. health = POWER_SUPPLY_HEALTH_COLD;
  1153. break;
  1154. case 0x2: /* TS1 Hot */
  1155. case 0x4: /* TS2 Hot */
  1156. case 0x6: /* Both Hot */
  1157. health = POWER_SUPPLY_HEALTH_OVERHEAT;
  1158. break;
  1159. default:
  1160. health = POWER_SUPPLY_HEALTH_UNKNOWN;
  1161. }
  1162. }
  1163. val->intval = health;
  1164. return 0;
  1165. }
  1166. static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
  1167. union power_supply_propval *val)
  1168. {
  1169. u8 batfet_disable;
  1170. int ret;
  1171. ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
  1172. BQ24190_REG_MOC_BATFET_DISABLE_MASK,
  1173. BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
  1174. if (ret < 0)
  1175. return ret;
  1176. val->intval = !batfet_disable;
  1177. return 0;
  1178. }
  1179. static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
  1180. const union power_supply_propval *val)
  1181. {
  1182. return bq24190_write_mask(bdi, BQ24190_REG_MOC,
  1183. BQ24190_REG_MOC_BATFET_DISABLE_MASK,
  1184. BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
  1185. }
  1186. static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
  1187. union power_supply_propval *val)
  1188. {
  1189. int temp, ret;
  1190. ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
  1191. BQ24190_REG_ICTRC_TREG_MASK,
  1192. BQ24190_REG_ICTRC_TREG_SHIFT,
  1193. bq24190_ictrc_treg_values,
  1194. ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
  1195. if (ret < 0)
  1196. return ret;
  1197. val->intval = temp;
  1198. return 0;
  1199. }
  1200. static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
  1201. const union power_supply_propval *val)
  1202. {
  1203. return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
  1204. BQ24190_REG_ICTRC_TREG_MASK,
  1205. BQ24190_REG_ICTRC_TREG_SHIFT,
  1206. bq24190_ictrc_treg_values,
  1207. ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
  1208. }
  1209. static int bq24190_battery_get_property(struct power_supply *psy,
  1210. enum power_supply_property psp, union power_supply_propval *val)
  1211. {
  1212. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  1213. int ret;
  1214. dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
  1215. dev_dbg(bdi->dev, "prop: %d\n", psp);
  1216. ret = pm_runtime_get_sync(bdi->dev);
  1217. if (ret < 0) {
  1218. pm_runtime_put_noidle(bdi->dev);
  1219. return ret;
  1220. }
  1221. switch (psp) {
  1222. case POWER_SUPPLY_PROP_STATUS:
  1223. ret = bq24190_battery_get_status(bdi, val);
  1224. break;
  1225. case POWER_SUPPLY_PROP_HEALTH:
  1226. ret = bq24190_battery_get_health(bdi, val);
  1227. break;
  1228. case POWER_SUPPLY_PROP_ONLINE:
  1229. ret = bq24190_battery_get_online(bdi, val);
  1230. break;
  1231. case POWER_SUPPLY_PROP_TECHNOLOGY:
  1232. /* Could be Li-on or Li-polymer but no way to tell which */
  1233. val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
  1234. ret = 0;
  1235. break;
  1236. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  1237. ret = bq24190_battery_get_temp_alert_max(bdi, val);
  1238. break;
  1239. case POWER_SUPPLY_PROP_SCOPE:
  1240. val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
  1241. ret = 0;
  1242. break;
  1243. default:
  1244. ret = -ENODATA;
  1245. }
  1246. pm_runtime_mark_last_busy(bdi->dev);
  1247. pm_runtime_put_autosuspend(bdi->dev);
  1248. return ret;
  1249. }
  1250. static int bq24190_battery_set_property(struct power_supply *psy,
  1251. enum power_supply_property psp,
  1252. const union power_supply_propval *val)
  1253. {
  1254. struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
  1255. int ret;
  1256. dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
  1257. dev_dbg(bdi->dev, "prop: %d\n", psp);
  1258. ret = pm_runtime_get_sync(bdi->dev);
  1259. if (ret < 0) {
  1260. pm_runtime_put_noidle(bdi->dev);
  1261. return ret;
  1262. }
  1263. switch (psp) {
  1264. case POWER_SUPPLY_PROP_ONLINE:
  1265. ret = bq24190_battery_set_online(bdi, val);
  1266. break;
  1267. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  1268. ret = bq24190_battery_set_temp_alert_max(bdi, val);
  1269. break;
  1270. default:
  1271. ret = -EINVAL;
  1272. }
  1273. pm_runtime_mark_last_busy(bdi->dev);
  1274. pm_runtime_put_autosuspend(bdi->dev);
  1275. return ret;
  1276. }
  1277. static int bq24190_battery_property_is_writeable(struct power_supply *psy,
  1278. enum power_supply_property psp)
  1279. {
  1280. int ret;
  1281. switch (psp) {
  1282. case POWER_SUPPLY_PROP_ONLINE:
  1283. case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
  1284. ret = 1;
  1285. break;
  1286. default:
  1287. ret = 0;
  1288. }
  1289. return ret;
  1290. }
  1291. static enum power_supply_property bq24190_battery_properties[] = {
  1292. POWER_SUPPLY_PROP_STATUS,
  1293. POWER_SUPPLY_PROP_HEALTH,
  1294. POWER_SUPPLY_PROP_ONLINE,
  1295. POWER_SUPPLY_PROP_TECHNOLOGY,
  1296. POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
  1297. POWER_SUPPLY_PROP_SCOPE,
  1298. };
  1299. static const struct power_supply_desc bq24190_battery_desc = {
  1300. .name = "bq24190-battery",
  1301. .type = POWER_SUPPLY_TYPE_BATTERY,
  1302. .properties = bq24190_battery_properties,
  1303. .num_properties = ARRAY_SIZE(bq24190_battery_properties),
  1304. .get_property = bq24190_battery_get_property,
  1305. .set_property = bq24190_battery_set_property,
  1306. .property_is_writeable = bq24190_battery_property_is_writeable,
  1307. };
  1308. static int bq24190_configure_usb_otg(struct bq24190_dev_info *bdi, u8 ss_reg)
  1309. {
  1310. bool otg_enabled;
  1311. int ret;
  1312. otg_enabled = !!(ss_reg & BQ24190_REG_SS_VBUS_STAT_MASK);
  1313. ret = extcon_set_state_sync(bdi->edev, EXTCON_USB, otg_enabled);
  1314. if (ret < 0)
  1315. dev_err(bdi->dev, "Can't set extcon state to %d: %d\n",
  1316. otg_enabled, ret);
  1317. return ret;
  1318. }
  1319. static void bq24190_check_status(struct bq24190_dev_info *bdi)
  1320. {
  1321. const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
  1322. const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
  1323. | BQ24190_REG_F_NTC_FAULT_MASK;
  1324. bool alert_charger = false, alert_battery = false;
  1325. u8 ss_reg = 0, f_reg = 0;
  1326. int i, ret;
  1327. ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
  1328. if (ret < 0) {
  1329. dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
  1330. return;
  1331. }
  1332. i = 0;
  1333. do {
  1334. ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
  1335. if (ret < 0) {
  1336. dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
  1337. return;
  1338. }
  1339. } while (f_reg && ++i < 2);
  1340. /* ignore over/under voltage fault after disconnect */
  1341. if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
  1342. !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
  1343. f_reg = 0;
  1344. if (f_reg != bdi->f_reg) {
  1345. dev_warn(bdi->dev,
  1346. "Fault: boost %d, charge %d, battery %d, ntc %d\n",
  1347. !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
  1348. !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
  1349. !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
  1350. !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
  1351. mutex_lock(&bdi->f_reg_lock);
  1352. if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
  1353. alert_battery = true;
  1354. if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
  1355. alert_charger = true;
  1356. bdi->f_reg = f_reg;
  1357. mutex_unlock(&bdi->f_reg_lock);
  1358. }
  1359. if (ss_reg != bdi->ss_reg) {
  1360. /*
  1361. * The device is in host mode so when PG_STAT goes from 1->0
  1362. * (i.e., power removed) HIZ needs to be disabled.
  1363. */
  1364. if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
  1365. !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
  1366. ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
  1367. BQ24190_REG_ISC_EN_HIZ_MASK,
  1368. BQ24190_REG_ISC_EN_HIZ_SHIFT,
  1369. 0);
  1370. if (ret < 0)
  1371. dev_err(bdi->dev, "Can't access ISC reg: %d\n",
  1372. ret);
  1373. }
  1374. if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
  1375. alert_battery = true;
  1376. if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
  1377. alert_charger = true;
  1378. bdi->ss_reg = ss_reg;
  1379. }
  1380. if (alert_charger || alert_battery) {
  1381. power_supply_changed(bdi->charger);
  1382. bq24190_configure_usb_otg(bdi, ss_reg);
  1383. }
  1384. if (alert_battery && bdi->battery)
  1385. power_supply_changed(bdi->battery);
  1386. dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
  1387. }
  1388. static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
  1389. {
  1390. struct bq24190_dev_info *bdi = data;
  1391. int error;
  1392. bdi->irq_event = true;
  1393. error = pm_runtime_get_sync(bdi->dev);
  1394. if (error < 0) {
  1395. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
  1396. pm_runtime_put_noidle(bdi->dev);
  1397. return IRQ_NONE;
  1398. }
  1399. bq24190_check_status(bdi);
  1400. pm_runtime_mark_last_busy(bdi->dev);
  1401. pm_runtime_put_autosuspend(bdi->dev);
  1402. bdi->irq_event = false;
  1403. return IRQ_HANDLED;
  1404. }
  1405. static int bq24190_hw_init(struct bq24190_dev_info *bdi)
  1406. {
  1407. u8 v;
  1408. int ret;
  1409. /* First check that the device really is what its supposed to be */
  1410. ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
  1411. BQ24190_REG_VPRS_PN_MASK,
  1412. BQ24190_REG_VPRS_PN_SHIFT,
  1413. &v);
  1414. if (ret < 0)
  1415. return ret;
  1416. switch (v) {
  1417. case BQ24190_REG_VPRS_PN_24190:
  1418. case BQ24190_REG_VPRS_PN_24192:
  1419. case BQ24190_REG_VPRS_PN_24192I:
  1420. break;
  1421. default:
  1422. dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
  1423. return -ENODEV;
  1424. }
  1425. ret = bq24190_register_reset(bdi);
  1426. if (ret < 0)
  1427. return ret;
  1428. ret = bq24190_set_config(bdi);
  1429. if (ret < 0)
  1430. return ret;
  1431. return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
  1432. }
  1433. static int bq24190_get_config(struct bq24190_dev_info *bdi)
  1434. {
  1435. const char * const s = "ti,system-minimum-microvolt";
  1436. struct power_supply_battery_info info = {};
  1437. int v;
  1438. if (device_property_read_u32(bdi->dev, s, &v) == 0) {
  1439. v /= 1000;
  1440. if (v >= BQ24190_REG_POC_SYS_MIN_MIN
  1441. && v <= BQ24190_REG_POC_SYS_MIN_MAX)
  1442. bdi->sys_min = v;
  1443. else
  1444. dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
  1445. }
  1446. if (bdi->dev->of_node &&
  1447. !power_supply_get_battery_info(bdi->charger, &info)) {
  1448. v = info.precharge_current_ua / 1000;
  1449. if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
  1450. && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
  1451. bdi->iprechg = v;
  1452. else
  1453. dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
  1454. v);
  1455. v = info.charge_term_current_ua / 1000;
  1456. if (v >= BQ24190_REG_PCTCC_ITERM_MIN
  1457. && v <= BQ24190_REG_PCTCC_ITERM_MAX)
  1458. bdi->iterm = v;
  1459. else
  1460. dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
  1461. v);
  1462. }
  1463. return 0;
  1464. }
  1465. static int bq24190_probe(struct i2c_client *client,
  1466. const struct i2c_device_id *id)
  1467. {
  1468. struct i2c_adapter *adapter = client->adapter;
  1469. struct device *dev = &client->dev;
  1470. struct power_supply_config charger_cfg = {}, battery_cfg = {};
  1471. struct bq24190_dev_info *bdi;
  1472. int ret;
  1473. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  1474. dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
  1475. return -ENODEV;
  1476. }
  1477. bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
  1478. if (!bdi) {
  1479. dev_err(dev, "Can't alloc bdi struct\n");
  1480. return -ENOMEM;
  1481. }
  1482. bdi->client = client;
  1483. bdi->dev = dev;
  1484. strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
  1485. mutex_init(&bdi->f_reg_lock);
  1486. bdi->f_reg = 0;
  1487. bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
  1488. INIT_DELAYED_WORK(&bdi->input_current_limit_work,
  1489. bq24190_input_current_limit_work);
  1490. i2c_set_clientdata(client, bdi);
  1491. if (client->irq <= 0) {
  1492. dev_err(dev, "Can't get irq info\n");
  1493. return -EINVAL;
  1494. }
  1495. bdi->edev = devm_extcon_dev_allocate(dev, bq24190_usb_extcon_cable);
  1496. if (IS_ERR(bdi->edev))
  1497. return PTR_ERR(bdi->edev);
  1498. ret = devm_extcon_dev_register(dev, bdi->edev);
  1499. if (ret < 0)
  1500. return ret;
  1501. pm_runtime_enable(dev);
  1502. pm_runtime_use_autosuspend(dev);
  1503. pm_runtime_set_autosuspend_delay(dev, 600);
  1504. ret = pm_runtime_get_sync(dev);
  1505. if (ret < 0) {
  1506. dev_err(dev, "pm_runtime_get failed: %i\n", ret);
  1507. goto out_pmrt;
  1508. }
  1509. #ifdef CONFIG_SYSFS
  1510. bq24190_sysfs_init_attrs();
  1511. charger_cfg.attr_grp = bq24190_sysfs_groups;
  1512. #endif
  1513. charger_cfg.drv_data = bdi;
  1514. charger_cfg.of_node = dev->of_node;
  1515. charger_cfg.supplied_to = bq24190_charger_supplied_to;
  1516. charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
  1517. bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
  1518. &charger_cfg);
  1519. if (IS_ERR(bdi->charger)) {
  1520. dev_err(dev, "Can't register charger\n");
  1521. ret = PTR_ERR(bdi->charger);
  1522. goto out_pmrt;
  1523. }
  1524. /* the battery class is deprecated and will be removed. */
  1525. /* in the interim, this property hides it. */
  1526. if (!device_property_read_bool(dev, "omit-battery-class")) {
  1527. battery_cfg.drv_data = bdi;
  1528. bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
  1529. &battery_cfg);
  1530. if (IS_ERR(bdi->battery)) {
  1531. dev_err(dev, "Can't register battery\n");
  1532. ret = PTR_ERR(bdi->battery);
  1533. goto out_charger;
  1534. }
  1535. }
  1536. ret = bq24190_get_config(bdi);
  1537. if (ret < 0) {
  1538. dev_err(dev, "Can't get devicetree config\n");
  1539. goto out_charger;
  1540. }
  1541. ret = bq24190_hw_init(bdi);
  1542. if (ret < 0) {
  1543. dev_err(dev, "Hardware init failed\n");
  1544. goto out_charger;
  1545. }
  1546. ret = bq24190_configure_usb_otg(bdi, bdi->ss_reg);
  1547. if (ret < 0)
  1548. goto out_charger;
  1549. bdi->initialized = true;
  1550. ret = devm_request_threaded_irq(dev, client->irq, NULL,
  1551. bq24190_irq_handler_thread,
  1552. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  1553. "bq24190-charger", bdi);
  1554. if (ret < 0) {
  1555. dev_err(dev, "Can't set up irq handler\n");
  1556. goto out_charger;
  1557. }
  1558. ret = bq24190_register_vbus_regulator(bdi);
  1559. if (ret < 0)
  1560. goto out_charger;
  1561. enable_irq_wake(client->irq);
  1562. pm_runtime_mark_last_busy(dev);
  1563. pm_runtime_put_autosuspend(dev);
  1564. return 0;
  1565. out_charger:
  1566. if (!IS_ERR_OR_NULL(bdi->battery))
  1567. power_supply_unregister(bdi->battery);
  1568. power_supply_unregister(bdi->charger);
  1569. out_pmrt:
  1570. pm_runtime_put_sync(dev);
  1571. pm_runtime_dont_use_autosuspend(dev);
  1572. pm_runtime_disable(dev);
  1573. return ret;
  1574. }
  1575. static int bq24190_remove(struct i2c_client *client)
  1576. {
  1577. struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
  1578. int error;
  1579. error = pm_runtime_get_sync(bdi->dev);
  1580. if (error < 0) {
  1581. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
  1582. pm_runtime_put_noidle(bdi->dev);
  1583. }
  1584. bq24190_register_reset(bdi);
  1585. if (bdi->battery)
  1586. power_supply_unregister(bdi->battery);
  1587. power_supply_unregister(bdi->charger);
  1588. if (error >= 0)
  1589. pm_runtime_put_sync(bdi->dev);
  1590. pm_runtime_dont_use_autosuspend(bdi->dev);
  1591. pm_runtime_disable(bdi->dev);
  1592. return 0;
  1593. }
  1594. static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
  1595. {
  1596. struct i2c_client *client = to_i2c_client(dev);
  1597. struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
  1598. if (!bdi->initialized)
  1599. return 0;
  1600. dev_dbg(bdi->dev, "%s\n", __func__);
  1601. return 0;
  1602. }
  1603. static __maybe_unused int bq24190_runtime_resume(struct device *dev)
  1604. {
  1605. struct i2c_client *client = to_i2c_client(dev);
  1606. struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
  1607. if (!bdi->initialized)
  1608. return 0;
  1609. if (!bdi->irq_event) {
  1610. dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
  1611. bq24190_check_status(bdi);
  1612. }
  1613. return 0;
  1614. }
  1615. static __maybe_unused int bq24190_pm_suspend(struct device *dev)
  1616. {
  1617. struct i2c_client *client = to_i2c_client(dev);
  1618. struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
  1619. int error;
  1620. error = pm_runtime_get_sync(bdi->dev);
  1621. if (error < 0) {
  1622. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
  1623. pm_runtime_put_noidle(bdi->dev);
  1624. }
  1625. bq24190_register_reset(bdi);
  1626. if (error >= 0) {
  1627. pm_runtime_mark_last_busy(bdi->dev);
  1628. pm_runtime_put_autosuspend(bdi->dev);
  1629. }
  1630. return 0;
  1631. }
  1632. static __maybe_unused int bq24190_pm_resume(struct device *dev)
  1633. {
  1634. struct i2c_client *client = to_i2c_client(dev);
  1635. struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
  1636. int error;
  1637. bdi->f_reg = 0;
  1638. bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
  1639. error = pm_runtime_get_sync(bdi->dev);
  1640. if (error < 0) {
  1641. dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
  1642. pm_runtime_put_noidle(bdi->dev);
  1643. }
  1644. bq24190_register_reset(bdi);
  1645. bq24190_set_config(bdi);
  1646. bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
  1647. if (error >= 0) {
  1648. pm_runtime_mark_last_busy(bdi->dev);
  1649. pm_runtime_put_autosuspend(bdi->dev);
  1650. }
  1651. /* Things may have changed while suspended so alert upper layer */
  1652. power_supply_changed(bdi->charger);
  1653. if (bdi->battery)
  1654. power_supply_changed(bdi->battery);
  1655. return 0;
  1656. }
  1657. static const struct dev_pm_ops bq24190_pm_ops = {
  1658. SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
  1659. NULL)
  1660. SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
  1661. };
  1662. static const struct i2c_device_id bq24190_i2c_ids[] = {
  1663. { "bq24190" },
  1664. { "bq24192" },
  1665. { "bq24192i" },
  1666. { "bq24196" },
  1667. { },
  1668. };
  1669. MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
  1670. #ifdef CONFIG_OF
  1671. static const struct of_device_id bq24190_of_match[] = {
  1672. { .compatible = "ti,bq24190", },
  1673. { .compatible = "ti,bq24192", },
  1674. { .compatible = "ti,bq24192i", },
  1675. { .compatible = "ti,bq24196", },
  1676. { },
  1677. };
  1678. MODULE_DEVICE_TABLE(of, bq24190_of_match);
  1679. #else
  1680. static const struct of_device_id bq24190_of_match[] = {
  1681. { },
  1682. };
  1683. #endif
  1684. static struct i2c_driver bq24190_driver = {
  1685. .probe = bq24190_probe,
  1686. .remove = bq24190_remove,
  1687. .id_table = bq24190_i2c_ids,
  1688. .driver = {
  1689. .name = "bq24190-charger",
  1690. .pm = &bq24190_pm_ops,
  1691. .of_match_table = of_match_ptr(bq24190_of_match),
  1692. },
  1693. };
  1694. module_i2c_driver(bq24190_driver);
  1695. MODULE_LICENSE("GPL");
  1696. MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
  1697. MODULE_DESCRIPTION("TI BQ24190 Charger Driver");