smb347-charger.c 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Summit Microelectronics SMB347 Battery Charger Driver
  4. *
  5. * Copyright (C) 2011, Intel Corporation
  6. *
  7. * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
  8. * Mika Westerberg <mika.westerberg@linux.intel.com>
  9. */
  10. #include <linux/delay.h>
  11. #include <linux/err.h>
  12. #include <linux/gpio.h>
  13. #include <linux/kernel.h>
  14. #include <linux/module.h>
  15. #include <linux/init.h>
  16. #include <linux/interrupt.h>
  17. #include <linux/i2c.h>
  18. #include <linux/power_supply.h>
  19. #include <linux/property.h>
  20. #include <linux/regmap.h>
  21. #include <dt-bindings/power/summit,smb347-charger.h>
  22. /* Use the default compensation method */
  23. #define SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT -1
  24. /* Use default factory programmed value for hard/soft temperature limit */
  25. #define SMB3XX_TEMP_USE_DEFAULT -273
  26. /*
  27. * Configuration registers. These are mirrored to volatile RAM and can be
  28. * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
  29. * reloaded from non-volatile registers after POR.
  30. */
  31. #define CFG_CHARGE_CURRENT 0x00
  32. #define CFG_CHARGE_CURRENT_FCC_MASK 0xe0
  33. #define CFG_CHARGE_CURRENT_FCC_SHIFT 5
  34. #define CFG_CHARGE_CURRENT_PCC_MASK 0x18
  35. #define CFG_CHARGE_CURRENT_PCC_SHIFT 3
  36. #define CFG_CHARGE_CURRENT_TC_MASK 0x07
  37. #define CFG_CURRENT_LIMIT 0x01
  38. #define CFG_CURRENT_LIMIT_DC_MASK 0xf0
  39. #define CFG_CURRENT_LIMIT_DC_SHIFT 4
  40. #define CFG_CURRENT_LIMIT_USB_MASK 0x0f
  41. #define CFG_FLOAT_VOLTAGE 0x03
  42. #define CFG_FLOAT_VOLTAGE_FLOAT_MASK 0x3f
  43. #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0
  44. #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
  45. #define CFG_STAT 0x05
  46. #define CFG_STAT_DISABLED BIT(5)
  47. #define CFG_STAT_ACTIVE_HIGH BIT(7)
  48. #define CFG_PIN 0x06
  49. #define CFG_PIN_EN_CTRL_MASK 0x60
  50. #define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40
  51. #define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60
  52. #define CFG_PIN_EN_APSD_IRQ BIT(1)
  53. #define CFG_PIN_EN_CHARGER_ERROR BIT(2)
  54. #define CFG_PIN_EN_CTRL BIT(4)
  55. #define CFG_THERM 0x07
  56. #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03
  57. #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
  58. #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c
  59. #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
  60. #define CFG_THERM_MONITOR_DISABLED BIT(4)
  61. #define CFG_SYSOK 0x08
  62. #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2)
  63. #define CFG_OTHER 0x09
  64. #define CFG_OTHER_RID_MASK 0xc0
  65. #define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0
  66. #define CFG_OTG 0x0a
  67. #define CFG_OTG_TEMP_THRESHOLD_MASK 0x30
  68. #define CFG_OTG_TEMP_THRESHOLD_SHIFT 4
  69. #define CFG_OTG_CC_COMPENSATION_MASK 0xc0
  70. #define CFG_OTG_CC_COMPENSATION_SHIFT 6
  71. #define CFG_TEMP_LIMIT 0x0b
  72. #define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03
  73. #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
  74. #define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c
  75. #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
  76. #define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30
  77. #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
  78. #define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0
  79. #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
  80. #define CFG_FAULT_IRQ 0x0c
  81. #define CFG_FAULT_IRQ_DCIN_UV BIT(2)
  82. #define CFG_STATUS_IRQ 0x0d
  83. #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4)
  84. #define CFG_STATUS_IRQ_CHARGE_TIMEOUT BIT(7)
  85. #define CFG_ADDRESS 0x0e
  86. /* Command registers */
  87. #define CMD_A 0x30
  88. #define CMD_A_CHG_ENABLED BIT(1)
  89. #define CMD_A_SUSPEND_ENABLED BIT(2)
  90. #define CMD_A_ALLOW_WRITE BIT(7)
  91. #define CMD_B 0x31
  92. #define CMD_C 0x33
  93. /* Interrupt Status registers */
  94. #define IRQSTAT_A 0x35
  95. #define IRQSTAT_C 0x37
  96. #define IRQSTAT_C_TERMINATION_STAT BIT(0)
  97. #define IRQSTAT_C_TERMINATION_IRQ BIT(1)
  98. #define IRQSTAT_C_TAPER_IRQ BIT(3)
  99. #define IRQSTAT_D 0x38
  100. #define IRQSTAT_D_CHARGE_TIMEOUT_STAT BIT(2)
  101. #define IRQSTAT_D_CHARGE_TIMEOUT_IRQ BIT(3)
  102. #define IRQSTAT_E 0x39
  103. #define IRQSTAT_E_USBIN_UV_STAT BIT(0)
  104. #define IRQSTAT_E_USBIN_UV_IRQ BIT(1)
  105. #define IRQSTAT_E_DCIN_UV_STAT BIT(4)
  106. #define IRQSTAT_E_DCIN_UV_IRQ BIT(5)
  107. #define IRQSTAT_F 0x3a
  108. /* Status registers */
  109. #define STAT_A 0x3b
  110. #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
  111. #define STAT_B 0x3c
  112. #define STAT_C 0x3d
  113. #define STAT_C_CHG_ENABLED BIT(0)
  114. #define STAT_C_HOLDOFF_STAT BIT(3)
  115. #define STAT_C_CHG_MASK 0x06
  116. #define STAT_C_CHG_SHIFT 1
  117. #define STAT_C_CHG_TERM BIT(5)
  118. #define STAT_C_CHARGER_ERROR BIT(6)
  119. #define STAT_E 0x3f
  120. #define SMB347_MAX_REGISTER 0x3f
  121. /**
  122. * struct smb347_charger - smb347 charger instance
  123. * @dev: pointer to device
  124. * @regmap: pointer to driver regmap
  125. * @mains: power_supply instance for AC/DC power
  126. * @usb: power_supply instance for USB power
  127. * @id: SMB charger ID
  128. * @mains_online: is AC/DC input connected
  129. * @usb_online: is USB input connected
  130. * @charging_enabled: is charging enabled
  131. * @irq_unsupported: is interrupt unsupported by SMB hardware
  132. * @max_charge_current: maximum current (in uA) the battery can be charged
  133. * @max_charge_voltage: maximum voltage (in uV) the battery can be charged
  134. * @pre_charge_current: current (in uA) to use in pre-charging phase
  135. * @termination_current: current (in uA) used to determine when the
  136. * charging cycle terminates
  137. * @pre_to_fast_voltage: voltage (in uV) treshold used for transitioning to
  138. * pre-charge to fast charge mode
  139. * @mains_current_limit: maximum input current drawn from AC/DC input (in uA)
  140. * @usb_hc_current_limit: maximum input high current (in uA) drawn from USB
  141. * input
  142. * @chip_temp_threshold: die temperature where device starts limiting charge
  143. * current [%100 - %130] (in degree C)
  144. * @soft_cold_temp_limit: soft cold temperature limit [%0 - %15] (in degree C),
  145. * granularity is 5 deg C.
  146. * @soft_hot_temp_limit: soft hot temperature limit [%40 - %55] (in degree C),
  147. * granularity is 5 deg C.
  148. * @hard_cold_temp_limit: hard cold temperature limit [%-5 - %10] (in degree C),
  149. * granularity is 5 deg C.
  150. * @hard_hot_temp_limit: hard hot temperature limit [%50 - %65] (in degree C),
  151. * granularity is 5 deg C.
  152. * @suspend_on_hard_temp_limit: suspend charging when hard limit is hit
  153. * @soft_temp_limit_compensation: compensation method when soft temperature
  154. * limit is hit
  155. * @charge_current_compensation: current (in uA) for charging compensation
  156. * current when temperature hits soft limits
  157. * @use_mains: AC/DC input can be used
  158. * @use_usb: USB input can be used
  159. * @use_usb_otg: USB OTG output can be used (not implemented yet)
  160. * @enable_control: how charging enable/disable is controlled
  161. * (driver/pin controls)
  162. *
  163. * @use_main, @use_usb, and @use_usb_otg are means to enable/disable
  164. * hardware support for these. This is useful when we want to have for
  165. * example OTG charging controlled via OTG transceiver driver and not by
  166. * the SMB347 hardware.
  167. *
  168. * Hard and soft temperature limit values are given as described in the
  169. * device data sheet and assuming NTC beta value is %3750. Even if this is
  170. * not the case, these values should be used. They can be mapped to the
  171. * corresponding NTC beta values with the help of table %2 in the data
  172. * sheet. So for example if NTC beta is %3375 and we want to program hard
  173. * hot limit to be %53 deg C, @hard_hot_temp_limit should be set to %50.
  174. *
  175. * If zero value is given in any of the current and voltage values, the
  176. * factory programmed default will be used. For soft/hard temperature
  177. * values, pass in %SMB3XX_TEMP_USE_DEFAULT instead.
  178. */
  179. struct smb347_charger {
  180. struct device *dev;
  181. struct regmap *regmap;
  182. struct power_supply *mains;
  183. struct power_supply *usb;
  184. unsigned int id;
  185. bool mains_online;
  186. bool usb_online;
  187. bool charging_enabled;
  188. bool irq_unsupported;
  189. unsigned int max_charge_current;
  190. unsigned int max_charge_voltage;
  191. unsigned int pre_charge_current;
  192. unsigned int termination_current;
  193. unsigned int pre_to_fast_voltage;
  194. unsigned int mains_current_limit;
  195. unsigned int usb_hc_current_limit;
  196. unsigned int chip_temp_threshold;
  197. int soft_cold_temp_limit;
  198. int soft_hot_temp_limit;
  199. int hard_cold_temp_limit;
  200. int hard_hot_temp_limit;
  201. bool suspend_on_hard_temp_limit;
  202. unsigned int soft_temp_limit_compensation;
  203. unsigned int charge_current_compensation;
  204. bool use_mains;
  205. bool use_usb;
  206. bool use_usb_otg;
  207. unsigned int enable_control;
  208. };
  209. enum smb_charger_chipid {
  210. SMB345,
  211. SMB347,
  212. SMB358,
  213. NUM_CHIP_TYPES,
  214. };
  215. /* Fast charge current in uA */
  216. static const unsigned int fcc_tbl[NUM_CHIP_TYPES][8] = {
  217. [SMB345] = { 200000, 450000, 600000, 900000,
  218. 1300000, 1500000, 1800000, 2000000 },
  219. [SMB347] = { 700000, 900000, 1200000, 1500000,
  220. 1800000, 2000000, 2200000, 2500000 },
  221. [SMB358] = { 200000, 450000, 600000, 900000,
  222. 1300000, 1500000, 1800000, 2000000 },
  223. };
  224. /* Pre-charge current in uA */
  225. static const unsigned int pcc_tbl[NUM_CHIP_TYPES][4] = {
  226. [SMB345] = { 150000, 250000, 350000, 450000 },
  227. [SMB347] = { 100000, 150000, 200000, 250000 },
  228. [SMB358] = { 150000, 250000, 350000, 450000 },
  229. };
  230. /* Termination current in uA */
  231. static const unsigned int tc_tbl[NUM_CHIP_TYPES][8] = {
  232. [SMB345] = { 30000, 40000, 60000, 80000,
  233. 100000, 125000, 150000, 200000 },
  234. [SMB347] = { 37500, 50000, 100000, 150000,
  235. 200000, 250000, 500000, 600000 },
  236. [SMB358] = { 30000, 40000, 60000, 80000,
  237. 100000, 125000, 150000, 200000 },
  238. };
  239. /* Input current limit in uA */
  240. static const unsigned int icl_tbl[NUM_CHIP_TYPES][10] = {
  241. [SMB345] = { 300000, 500000, 700000, 1000000, 1500000,
  242. 1800000, 2000000, 2000000, 2000000, 2000000 },
  243. [SMB347] = { 300000, 500000, 700000, 900000, 1200000,
  244. 1500000, 1800000, 2000000, 2200000, 2500000 },
  245. [SMB358] = { 300000, 500000, 700000, 1000000, 1500000,
  246. 1800000, 2000000, 2000000, 2000000, 2000000 },
  247. };
  248. /* Charge current compensation in uA */
  249. static const unsigned int ccc_tbl[NUM_CHIP_TYPES][4] = {
  250. [SMB345] = { 200000, 450000, 600000, 900000 },
  251. [SMB347] = { 250000, 700000, 900000, 1200000 },
  252. [SMB358] = { 200000, 450000, 600000, 900000 },
  253. };
  254. /* Convert register value to current using lookup table */
  255. static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
  256. {
  257. if (val >= size)
  258. return -EINVAL;
  259. return tbl[val];
  260. }
  261. /* Convert current to register value using lookup table */
  262. static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
  263. {
  264. size_t i;
  265. for (i = 0; i < size; i++)
  266. if (val < tbl[i])
  267. break;
  268. return i > 0 ? i - 1 : -EINVAL;
  269. }
  270. /**
  271. * smb347_update_ps_status - refreshes the power source status
  272. * @smb: pointer to smb347 charger instance
  273. *
  274. * Function checks whether any power source is connected to the charger and
  275. * updates internal state accordingly. If there is a change to previous state
  276. * function returns %1, otherwise %0 and negative errno in case of errror.
  277. */
  278. static int smb347_update_ps_status(struct smb347_charger *smb)
  279. {
  280. bool usb = false;
  281. bool dc = false;
  282. unsigned int val;
  283. int ret;
  284. ret = regmap_read(smb->regmap, IRQSTAT_E, &val);
  285. if (ret < 0)
  286. return ret;
  287. /*
  288. * Dc and usb are set depending on whether they are enabled in
  289. * platform data _and_ whether corresponding undervoltage is set.
  290. */
  291. if (smb->use_mains)
  292. dc = !(val & IRQSTAT_E_DCIN_UV_STAT);
  293. if (smb->use_usb)
  294. usb = !(val & IRQSTAT_E_USBIN_UV_STAT);
  295. ret = smb->mains_online != dc || smb->usb_online != usb;
  296. smb->mains_online = dc;
  297. smb->usb_online = usb;
  298. return ret;
  299. }
  300. /*
  301. * smb347_is_ps_online - returns whether input power source is connected
  302. * @smb: pointer to smb347 charger instance
  303. *
  304. * Returns %true if input power source is connected. Note that this is
  305. * dependent on what platform has configured for usable power sources. For
  306. * example if USB is disabled, this will return %false even if the USB cable
  307. * is connected.
  308. */
  309. static bool smb347_is_ps_online(struct smb347_charger *smb)
  310. {
  311. return smb->usb_online || smb->mains_online;
  312. }
  313. /**
  314. * smb347_charging_status - returns status of charging
  315. * @smb: pointer to smb347 charger instance
  316. *
  317. * Function returns charging status. %0 means no charging is in progress,
  318. * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
  319. */
  320. static int smb347_charging_status(struct smb347_charger *smb)
  321. {
  322. unsigned int val;
  323. int ret;
  324. if (!smb347_is_ps_online(smb))
  325. return 0;
  326. ret = regmap_read(smb->regmap, STAT_C, &val);
  327. if (ret < 0)
  328. return 0;
  329. return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
  330. }
  331. static int smb347_charging_set(struct smb347_charger *smb, bool enable)
  332. {
  333. int ret = 0;
  334. if (smb->enable_control != SMB3XX_CHG_ENABLE_SW) {
  335. dev_dbg(smb->dev, "charging enable/disable in SW disabled\n");
  336. return 0;
  337. }
  338. if (smb->charging_enabled != enable) {
  339. ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED,
  340. enable ? CMD_A_CHG_ENABLED : 0);
  341. if (!ret)
  342. smb->charging_enabled = enable;
  343. }
  344. return ret;
  345. }
  346. static inline int smb347_charging_enable(struct smb347_charger *smb)
  347. {
  348. return smb347_charging_set(smb, true);
  349. }
  350. static inline int smb347_charging_disable(struct smb347_charger *smb)
  351. {
  352. return smb347_charging_set(smb, false);
  353. }
  354. static int smb347_start_stop_charging(struct smb347_charger *smb)
  355. {
  356. int ret;
  357. /*
  358. * Depending on whether valid power source is connected or not, we
  359. * disable or enable the charging. We do it manually because it
  360. * depends on how the platform has configured the valid inputs.
  361. */
  362. if (smb347_is_ps_online(smb)) {
  363. ret = smb347_charging_enable(smb);
  364. if (ret < 0)
  365. dev_err(smb->dev, "failed to enable charging\n");
  366. } else {
  367. ret = smb347_charging_disable(smb);
  368. if (ret < 0)
  369. dev_err(smb->dev, "failed to disable charging\n");
  370. }
  371. return ret;
  372. }
  373. static int smb347_set_charge_current(struct smb347_charger *smb)
  374. {
  375. unsigned int id = smb->id;
  376. int ret;
  377. if (smb->max_charge_current) {
  378. ret = current_to_hw(fcc_tbl[id], ARRAY_SIZE(fcc_tbl[id]),
  379. smb->max_charge_current);
  380. if (ret < 0)
  381. return ret;
  382. ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
  383. CFG_CHARGE_CURRENT_FCC_MASK,
  384. ret << CFG_CHARGE_CURRENT_FCC_SHIFT);
  385. if (ret < 0)
  386. return ret;
  387. }
  388. if (smb->pre_charge_current) {
  389. ret = current_to_hw(pcc_tbl[id], ARRAY_SIZE(pcc_tbl[id]),
  390. smb->pre_charge_current);
  391. if (ret < 0)
  392. return ret;
  393. ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
  394. CFG_CHARGE_CURRENT_PCC_MASK,
  395. ret << CFG_CHARGE_CURRENT_PCC_SHIFT);
  396. if (ret < 0)
  397. return ret;
  398. }
  399. if (smb->termination_current) {
  400. ret = current_to_hw(tc_tbl[id], ARRAY_SIZE(tc_tbl[id]),
  401. smb->termination_current);
  402. if (ret < 0)
  403. return ret;
  404. ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
  405. CFG_CHARGE_CURRENT_TC_MASK, ret);
  406. if (ret < 0)
  407. return ret;
  408. }
  409. return 0;
  410. }
  411. static int smb347_set_current_limits(struct smb347_charger *smb)
  412. {
  413. unsigned int id = smb->id;
  414. int ret;
  415. if (smb->mains_current_limit) {
  416. ret = current_to_hw(icl_tbl[id], ARRAY_SIZE(icl_tbl[id]),
  417. smb->mains_current_limit);
  418. if (ret < 0)
  419. return ret;
  420. ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
  421. CFG_CURRENT_LIMIT_DC_MASK,
  422. ret << CFG_CURRENT_LIMIT_DC_SHIFT);
  423. if (ret < 0)
  424. return ret;
  425. }
  426. if (smb->usb_hc_current_limit) {
  427. ret = current_to_hw(icl_tbl[id], ARRAY_SIZE(icl_tbl[id]),
  428. smb->usb_hc_current_limit);
  429. if (ret < 0)
  430. return ret;
  431. ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
  432. CFG_CURRENT_LIMIT_USB_MASK, ret);
  433. if (ret < 0)
  434. return ret;
  435. }
  436. return 0;
  437. }
  438. static int smb347_set_voltage_limits(struct smb347_charger *smb)
  439. {
  440. int ret;
  441. if (smb->pre_to_fast_voltage) {
  442. ret = smb->pre_to_fast_voltage;
  443. /* uV */
  444. ret = clamp_val(ret, 2400000, 3000000) - 2400000;
  445. ret /= 200000;
  446. ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
  447. CFG_FLOAT_VOLTAGE_THRESHOLD_MASK,
  448. ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT);
  449. if (ret < 0)
  450. return ret;
  451. }
  452. if (smb->max_charge_voltage) {
  453. ret = smb->max_charge_voltage;
  454. /* uV */
  455. ret = clamp_val(ret, 3500000, 4500000) - 3500000;
  456. ret /= 20000;
  457. ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
  458. CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret);
  459. if (ret < 0)
  460. return ret;
  461. }
  462. return 0;
  463. }
  464. static int smb347_set_temp_limits(struct smb347_charger *smb)
  465. {
  466. unsigned int id = smb->id;
  467. bool enable_therm_monitor = false;
  468. int ret = 0;
  469. int val;
  470. if (smb->chip_temp_threshold) {
  471. val = smb->chip_temp_threshold;
  472. /* degree C */
  473. val = clamp_val(val, 100, 130) - 100;
  474. val /= 10;
  475. ret = regmap_update_bits(smb->regmap, CFG_OTG,
  476. CFG_OTG_TEMP_THRESHOLD_MASK,
  477. val << CFG_OTG_TEMP_THRESHOLD_SHIFT);
  478. if (ret < 0)
  479. return ret;
  480. }
  481. if (smb->soft_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
  482. val = smb->soft_cold_temp_limit;
  483. val = clamp_val(val, 0, 15);
  484. val /= 5;
  485. /* this goes from higher to lower so invert the value */
  486. val = ~val & 0x3;
  487. ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
  488. CFG_TEMP_LIMIT_SOFT_COLD_MASK,
  489. val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT);
  490. if (ret < 0)
  491. return ret;
  492. enable_therm_monitor = true;
  493. }
  494. if (smb->soft_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
  495. val = smb->soft_hot_temp_limit;
  496. val = clamp_val(val, 40, 55) - 40;
  497. val /= 5;
  498. ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
  499. CFG_TEMP_LIMIT_SOFT_HOT_MASK,
  500. val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT);
  501. if (ret < 0)
  502. return ret;
  503. enable_therm_monitor = true;
  504. }
  505. if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
  506. val = smb->hard_cold_temp_limit;
  507. val = clamp_val(val, -5, 10) + 5;
  508. val /= 5;
  509. /* this goes from higher to lower so invert the value */
  510. val = ~val & 0x3;
  511. ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
  512. CFG_TEMP_LIMIT_HARD_COLD_MASK,
  513. val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT);
  514. if (ret < 0)
  515. return ret;
  516. enable_therm_monitor = true;
  517. }
  518. if (smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) {
  519. val = smb->hard_hot_temp_limit;
  520. val = clamp_val(val, 50, 65) - 50;
  521. val /= 5;
  522. ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
  523. CFG_TEMP_LIMIT_HARD_HOT_MASK,
  524. val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT);
  525. if (ret < 0)
  526. return ret;
  527. enable_therm_monitor = true;
  528. }
  529. /*
  530. * If any of the temperature limits are set, we also enable the
  531. * thermistor monitoring.
  532. *
  533. * When soft limits are hit, the device will start to compensate
  534. * current and/or voltage depending on the configuration.
  535. *
  536. * When hard limit is hit, the device will suspend charging
  537. * depending on the configuration.
  538. */
  539. if (enable_therm_monitor) {
  540. ret = regmap_update_bits(smb->regmap, CFG_THERM,
  541. CFG_THERM_MONITOR_DISABLED, 0);
  542. if (ret < 0)
  543. return ret;
  544. }
  545. if (smb->suspend_on_hard_temp_limit) {
  546. ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
  547. CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0);
  548. if (ret < 0)
  549. return ret;
  550. }
  551. if (smb->soft_temp_limit_compensation !=
  552. SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT) {
  553. val = smb->soft_temp_limit_compensation & 0x3;
  554. ret = regmap_update_bits(smb->regmap, CFG_THERM,
  555. CFG_THERM_SOFT_HOT_COMPENSATION_MASK,
  556. val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT);
  557. if (ret < 0)
  558. return ret;
  559. ret = regmap_update_bits(smb->regmap, CFG_THERM,
  560. CFG_THERM_SOFT_COLD_COMPENSATION_MASK,
  561. val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT);
  562. if (ret < 0)
  563. return ret;
  564. }
  565. if (smb->charge_current_compensation) {
  566. val = current_to_hw(ccc_tbl[id], ARRAY_SIZE(ccc_tbl[id]),
  567. smb->charge_current_compensation);
  568. if (val < 0)
  569. return val;
  570. ret = regmap_update_bits(smb->regmap, CFG_OTG,
  571. CFG_OTG_CC_COMPENSATION_MASK,
  572. (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT);
  573. if (ret < 0)
  574. return ret;
  575. }
  576. return ret;
  577. }
  578. /*
  579. * smb347_set_writable - enables/disables writing to non-volatile registers
  580. * @smb: pointer to smb347 charger instance
  581. *
  582. * You can enable/disable writing to the non-volatile configuration
  583. * registers by calling this function.
  584. *
  585. * Returns %0 on success and negative errno in case of failure.
  586. */
  587. static int smb347_set_writable(struct smb347_charger *smb, bool writable)
  588. {
  589. return regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE,
  590. writable ? CMD_A_ALLOW_WRITE : 0);
  591. }
  592. static int smb347_hw_init(struct smb347_charger *smb)
  593. {
  594. unsigned int val;
  595. int ret;
  596. ret = smb347_set_writable(smb, true);
  597. if (ret < 0)
  598. return ret;
  599. /*
  600. * Program the platform specific configuration values to the device
  601. * first.
  602. */
  603. ret = smb347_set_charge_current(smb);
  604. if (ret < 0)
  605. goto fail;
  606. ret = smb347_set_current_limits(smb);
  607. if (ret < 0)
  608. goto fail;
  609. ret = smb347_set_voltage_limits(smb);
  610. if (ret < 0)
  611. goto fail;
  612. ret = smb347_set_temp_limits(smb);
  613. if (ret < 0)
  614. goto fail;
  615. /* If USB charging is disabled we put the USB in suspend mode */
  616. if (!smb->use_usb) {
  617. ret = regmap_update_bits(smb->regmap, CMD_A,
  618. CMD_A_SUSPEND_ENABLED,
  619. CMD_A_SUSPEND_ENABLED);
  620. if (ret < 0)
  621. goto fail;
  622. }
  623. /*
  624. * If configured by platform data, we enable hardware Auto-OTG
  625. * support for driving VBUS. Otherwise we disable it.
  626. */
  627. ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK,
  628. smb->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0);
  629. if (ret < 0)
  630. goto fail;
  631. /* Activate pin control, making it writable. */
  632. switch (smb->enable_control) {
  633. case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW:
  634. case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH:
  635. ret = regmap_set_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL);
  636. if (ret < 0)
  637. goto fail;
  638. }
  639. /*
  640. * Make the charging functionality controllable by a write to the
  641. * command register unless pin control is specified in the platform
  642. * data.
  643. */
  644. switch (smb->enable_control) {
  645. case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW:
  646. val = CFG_PIN_EN_CTRL_ACTIVE_LOW;
  647. break;
  648. case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH:
  649. val = CFG_PIN_EN_CTRL_ACTIVE_HIGH;
  650. break;
  651. default:
  652. val = 0;
  653. break;
  654. }
  655. ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK,
  656. val);
  657. if (ret < 0)
  658. goto fail;
  659. /* Disable Automatic Power Source Detection (APSD) interrupt. */
  660. ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0);
  661. if (ret < 0)
  662. goto fail;
  663. ret = smb347_update_ps_status(smb);
  664. if (ret < 0)
  665. goto fail;
  666. ret = smb347_start_stop_charging(smb);
  667. fail:
  668. smb347_set_writable(smb, false);
  669. return ret;
  670. }
  671. static irqreturn_t smb347_interrupt(int irq, void *data)
  672. {
  673. struct smb347_charger *smb = data;
  674. unsigned int stat_c, irqstat_c, irqstat_d, irqstat_e;
  675. bool handled = false;
  676. int ret;
  677. /* SMB347 it needs at least 20ms for setting IRQSTAT_E_*IN_UV_IRQ */
  678. usleep_range(25000, 35000);
  679. ret = regmap_read(smb->regmap, STAT_C, &stat_c);
  680. if (ret < 0) {
  681. dev_warn(smb->dev, "reading STAT_C failed\n");
  682. return IRQ_NONE;
  683. }
  684. ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c);
  685. if (ret < 0) {
  686. dev_warn(smb->dev, "reading IRQSTAT_C failed\n");
  687. return IRQ_NONE;
  688. }
  689. ret = regmap_read(smb->regmap, IRQSTAT_D, &irqstat_d);
  690. if (ret < 0) {
  691. dev_warn(smb->dev, "reading IRQSTAT_D failed\n");
  692. return IRQ_NONE;
  693. }
  694. ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e);
  695. if (ret < 0) {
  696. dev_warn(smb->dev, "reading IRQSTAT_E failed\n");
  697. return IRQ_NONE;
  698. }
  699. /*
  700. * If we get charger error we report the error back to user.
  701. * If the error is recovered charging will resume again.
  702. */
  703. if (stat_c & STAT_C_CHARGER_ERROR) {
  704. dev_err(smb->dev, "charging stopped due to charger error\n");
  705. if (smb->use_mains)
  706. power_supply_changed(smb->mains);
  707. if (smb->use_usb)
  708. power_supply_changed(smb->usb);
  709. handled = true;
  710. }
  711. /*
  712. * If we reached the termination current the battery is charged and
  713. * we can update the status now. Charging is automatically
  714. * disabled by the hardware.
  715. */
  716. if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
  717. if (irqstat_c & IRQSTAT_C_TERMINATION_STAT) {
  718. if (smb->use_mains)
  719. power_supply_changed(smb->mains);
  720. if (smb->use_usb)
  721. power_supply_changed(smb->usb);
  722. }
  723. dev_dbg(smb->dev, "going to HW maintenance mode\n");
  724. handled = true;
  725. }
  726. /*
  727. * If we got a charger timeout INT that means the charge
  728. * full is not detected with in charge timeout value.
  729. */
  730. if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_IRQ) {
  731. dev_dbg(smb->dev, "total Charge Timeout INT received\n");
  732. if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_STAT)
  733. dev_warn(smb->dev, "charging stopped due to timeout\n");
  734. if (smb->use_mains)
  735. power_supply_changed(smb->mains);
  736. if (smb->use_usb)
  737. power_supply_changed(smb->usb);
  738. handled = true;
  739. }
  740. /*
  741. * If we got an under voltage interrupt it means that AC/USB input
  742. * was connected or disconnected.
  743. */
  744. if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
  745. if (smb347_update_ps_status(smb) > 0) {
  746. smb347_start_stop_charging(smb);
  747. if (smb->use_mains)
  748. power_supply_changed(smb->mains);
  749. if (smb->use_usb)
  750. power_supply_changed(smb->usb);
  751. }
  752. handled = true;
  753. }
  754. return handled ? IRQ_HANDLED : IRQ_NONE;
  755. }
  756. static int smb347_irq_set(struct smb347_charger *smb, bool enable)
  757. {
  758. int ret;
  759. if (smb->irq_unsupported)
  760. return 0;
  761. ret = smb347_set_writable(smb, true);
  762. if (ret < 0)
  763. return ret;
  764. /*
  765. * Enable/disable interrupts for:
  766. * - under voltage
  767. * - termination current reached
  768. * - charger timeout
  769. * - charger error
  770. */
  771. ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff,
  772. enable ? CFG_FAULT_IRQ_DCIN_UV : 0);
  773. if (ret < 0)
  774. goto fail;
  775. ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff,
  776. enable ? (CFG_STATUS_IRQ_TERMINATION_OR_TAPER |
  777. CFG_STATUS_IRQ_CHARGE_TIMEOUT) : 0);
  778. if (ret < 0)
  779. goto fail;
  780. ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR,
  781. enable ? CFG_PIN_EN_CHARGER_ERROR : 0);
  782. fail:
  783. smb347_set_writable(smb, false);
  784. return ret;
  785. }
  786. static inline int smb347_irq_enable(struct smb347_charger *smb)
  787. {
  788. return smb347_irq_set(smb, true);
  789. }
  790. static inline int smb347_irq_disable(struct smb347_charger *smb)
  791. {
  792. return smb347_irq_set(smb, false);
  793. }
  794. static int smb347_irq_init(struct smb347_charger *smb,
  795. struct i2c_client *client)
  796. {
  797. int ret;
  798. ret = devm_request_threaded_irq(smb->dev, client->irq, NULL,
  799. smb347_interrupt, IRQF_ONESHOT,
  800. client->name, smb);
  801. if (ret < 0)
  802. return ret;
  803. ret = smb347_set_writable(smb, true);
  804. if (ret < 0)
  805. return ret;
  806. /*
  807. * Configure the STAT output to be suitable for interrupts: disable
  808. * all other output (except interrupts) and make it active low.
  809. */
  810. ret = regmap_update_bits(smb->regmap, CFG_STAT,
  811. CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED,
  812. CFG_STAT_DISABLED);
  813. smb347_set_writable(smb, false);
  814. return ret;
  815. }
  816. /*
  817. * Returns the constant charge current programmed
  818. * into the charger in uA.
  819. */
  820. static int get_const_charge_current(struct smb347_charger *smb)
  821. {
  822. unsigned int id = smb->id;
  823. int ret, intval;
  824. unsigned int v;
  825. if (!smb347_is_ps_online(smb))
  826. return -ENODATA;
  827. ret = regmap_read(smb->regmap, STAT_B, &v);
  828. if (ret < 0)
  829. return ret;
  830. /*
  831. * The current value is composition of FCC and PCC values
  832. * and we can detect which table to use from bit 5.
  833. */
  834. if (v & 0x20) {
  835. intval = hw_to_current(fcc_tbl[id],
  836. ARRAY_SIZE(fcc_tbl[id]), v & 7);
  837. } else {
  838. v >>= 3;
  839. intval = hw_to_current(pcc_tbl[id],
  840. ARRAY_SIZE(pcc_tbl[id]), v & 7);
  841. }
  842. return intval;
  843. }
  844. /*
  845. * Returns the constant charge voltage programmed
  846. * into the charger in uV.
  847. */
  848. static int get_const_charge_voltage(struct smb347_charger *smb)
  849. {
  850. int ret, intval;
  851. unsigned int v;
  852. if (!smb347_is_ps_online(smb))
  853. return -ENODATA;
  854. ret = regmap_read(smb->regmap, STAT_A, &v);
  855. if (ret < 0)
  856. return ret;
  857. v &= STAT_A_FLOAT_VOLTAGE_MASK;
  858. if (v > 0x3d)
  859. v = 0x3d;
  860. intval = 3500000 + v * 20000;
  861. return intval;
  862. }
  863. static int smb347_get_charging_status(struct smb347_charger *smb,
  864. struct power_supply *psy)
  865. {
  866. int ret, status;
  867. unsigned int val;
  868. if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
  869. if (!smb->usb_online)
  870. return POWER_SUPPLY_STATUS_DISCHARGING;
  871. } else {
  872. if (!smb->mains_online)
  873. return POWER_SUPPLY_STATUS_DISCHARGING;
  874. }
  875. ret = regmap_read(smb->regmap, STAT_C, &val);
  876. if (ret < 0)
  877. return ret;
  878. if ((val & STAT_C_CHARGER_ERROR) ||
  879. (val & STAT_C_HOLDOFF_STAT)) {
  880. /*
  881. * set to NOT CHARGING upon charger error
  882. * or charging has stopped.
  883. */
  884. status = POWER_SUPPLY_STATUS_NOT_CHARGING;
  885. } else {
  886. if ((val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT) {
  887. /*
  888. * set to charging if battery is in pre-charge,
  889. * fast charge or taper charging mode.
  890. */
  891. status = POWER_SUPPLY_STATUS_CHARGING;
  892. } else if (val & STAT_C_CHG_TERM) {
  893. /*
  894. * set the status to FULL if battery is not in pre
  895. * charge, fast charge or taper charging mode AND
  896. * charging is terminated at least once.
  897. */
  898. status = POWER_SUPPLY_STATUS_FULL;
  899. } else {
  900. /*
  901. * in this case no charger error or termination
  902. * occured but charging is not in progress!!!
  903. */
  904. status = POWER_SUPPLY_STATUS_NOT_CHARGING;
  905. }
  906. }
  907. return status;
  908. }
  909. static int smb347_get_property_locked(struct power_supply *psy,
  910. enum power_supply_property prop,
  911. union power_supply_propval *val)
  912. {
  913. struct smb347_charger *smb = power_supply_get_drvdata(psy);
  914. int ret;
  915. switch (prop) {
  916. case POWER_SUPPLY_PROP_STATUS:
  917. ret = smb347_get_charging_status(smb, psy);
  918. if (ret < 0)
  919. return ret;
  920. val->intval = ret;
  921. break;
  922. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  923. if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
  924. if (!smb->usb_online)
  925. return -ENODATA;
  926. } else {
  927. if (!smb->mains_online)
  928. return -ENODATA;
  929. }
  930. /*
  931. * We handle trickle and pre-charging the same, and taper
  932. * and none the same.
  933. */
  934. switch (smb347_charging_status(smb)) {
  935. case 1:
  936. val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  937. break;
  938. case 2:
  939. val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
  940. break;
  941. default:
  942. val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
  943. break;
  944. }
  945. break;
  946. case POWER_SUPPLY_PROP_ONLINE:
  947. if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
  948. val->intval = smb->usb_online;
  949. else
  950. val->intval = smb->mains_online;
  951. break;
  952. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  953. ret = get_const_charge_voltage(smb);
  954. if (ret < 0)
  955. return ret;
  956. val->intval = ret;
  957. break;
  958. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  959. ret = get_const_charge_current(smb);
  960. if (ret < 0)
  961. return ret;
  962. val->intval = ret;
  963. break;
  964. default:
  965. return -EINVAL;
  966. }
  967. return 0;
  968. }
  969. static int smb347_get_property(struct power_supply *psy,
  970. enum power_supply_property prop,
  971. union power_supply_propval *val)
  972. {
  973. struct smb347_charger *smb = power_supply_get_drvdata(psy);
  974. struct i2c_client *client = to_i2c_client(smb->dev);
  975. int ret;
  976. disable_irq(client->irq);
  977. ret = smb347_get_property_locked(psy, prop, val);
  978. enable_irq(client->irq);
  979. return ret;
  980. }
  981. static enum power_supply_property smb347_properties[] = {
  982. POWER_SUPPLY_PROP_STATUS,
  983. POWER_SUPPLY_PROP_CHARGE_TYPE,
  984. POWER_SUPPLY_PROP_ONLINE,
  985. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
  986. POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
  987. };
  988. static bool smb347_volatile_reg(struct device *dev, unsigned int reg)
  989. {
  990. switch (reg) {
  991. case IRQSTAT_A:
  992. case IRQSTAT_C:
  993. case IRQSTAT_D:
  994. case IRQSTAT_E:
  995. case IRQSTAT_F:
  996. case STAT_A:
  997. case STAT_B:
  998. case STAT_C:
  999. case STAT_E:
  1000. return true;
  1001. }
  1002. return false;
  1003. }
  1004. static bool smb347_readable_reg(struct device *dev, unsigned int reg)
  1005. {
  1006. switch (reg) {
  1007. case CFG_CHARGE_CURRENT:
  1008. case CFG_CURRENT_LIMIT:
  1009. case CFG_FLOAT_VOLTAGE:
  1010. case CFG_STAT:
  1011. case CFG_PIN:
  1012. case CFG_THERM:
  1013. case CFG_SYSOK:
  1014. case CFG_OTHER:
  1015. case CFG_OTG:
  1016. case CFG_TEMP_LIMIT:
  1017. case CFG_FAULT_IRQ:
  1018. case CFG_STATUS_IRQ:
  1019. case CFG_ADDRESS:
  1020. case CMD_A:
  1021. case CMD_B:
  1022. case CMD_C:
  1023. return true;
  1024. }
  1025. return smb347_volatile_reg(dev, reg);
  1026. }
  1027. static void smb347_dt_parse_dev_info(struct smb347_charger *smb)
  1028. {
  1029. struct device *dev = smb->dev;
  1030. smb->soft_temp_limit_compensation =
  1031. SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT;
  1032. /*
  1033. * These properties come from the battery info, still we need to
  1034. * pre-initialize the values. See smb347_get_battery_info() below.
  1035. */
  1036. smb->soft_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
  1037. smb->hard_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
  1038. smb->soft_hot_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
  1039. smb->hard_hot_temp_limit = SMB3XX_TEMP_USE_DEFAULT;
  1040. /* Charging constraints */
  1041. device_property_read_u32(dev, "summit,fast-voltage-threshold-microvolt",
  1042. &smb->pre_to_fast_voltage);
  1043. device_property_read_u32(dev, "summit,mains-current-limit-microamp",
  1044. &smb->mains_current_limit);
  1045. device_property_read_u32(dev, "summit,usb-current-limit-microamp",
  1046. &smb->usb_hc_current_limit);
  1047. /* For thermometer monitoring */
  1048. device_property_read_u32(dev, "summit,chip-temperature-threshold-celsius",
  1049. &smb->chip_temp_threshold);
  1050. device_property_read_u32(dev, "summit,soft-compensation-method",
  1051. &smb->soft_temp_limit_compensation);
  1052. device_property_read_u32(dev, "summit,charge-current-compensation-microamp",
  1053. &smb->charge_current_compensation);
  1054. /* Supported charging mode */
  1055. smb->use_mains = device_property_read_bool(dev, "summit,enable-mains-charging");
  1056. smb->use_usb = device_property_read_bool(dev, "summit,enable-usb-charging");
  1057. smb->use_usb_otg = device_property_read_bool(dev, "summit,enable-otg-charging");
  1058. /* Select charging control */
  1059. device_property_read_u32(dev, "summit,enable-charge-control",
  1060. &smb->enable_control);
  1061. }
  1062. static int smb347_get_battery_info(struct smb347_charger *smb)
  1063. {
  1064. struct power_supply_battery_info info = {};
  1065. struct power_supply *supply;
  1066. int err;
  1067. if (smb->mains)
  1068. supply = smb->mains;
  1069. else
  1070. supply = smb->usb;
  1071. err = power_supply_get_battery_info(supply, &info);
  1072. if (err == -ENXIO || err == -ENODEV)
  1073. return 0;
  1074. if (err)
  1075. return err;
  1076. if (info.constant_charge_current_max_ua != -EINVAL)
  1077. smb->max_charge_current = info.constant_charge_current_max_ua;
  1078. if (info.constant_charge_voltage_max_uv != -EINVAL)
  1079. smb->max_charge_voltage = info.constant_charge_voltage_max_uv;
  1080. if (info.precharge_current_ua != -EINVAL)
  1081. smb->pre_charge_current = info.precharge_current_ua;
  1082. if (info.charge_term_current_ua != -EINVAL)
  1083. smb->termination_current = info.charge_term_current_ua;
  1084. if (info.temp_alert_min != INT_MIN)
  1085. smb->soft_cold_temp_limit = info.temp_alert_min;
  1086. if (info.temp_alert_max != INT_MAX)
  1087. smb->soft_hot_temp_limit = info.temp_alert_max;
  1088. if (info.temp_min != INT_MIN)
  1089. smb->hard_cold_temp_limit = info.temp_min;
  1090. if (info.temp_max != INT_MAX)
  1091. smb->hard_hot_temp_limit = info.temp_max;
  1092. /* Suspend when battery temperature is outside hard limits */
  1093. if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT ||
  1094. smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT)
  1095. smb->suspend_on_hard_temp_limit = true;
  1096. return 0;
  1097. }
  1098. static const struct regmap_config smb347_regmap = {
  1099. .reg_bits = 8,
  1100. .val_bits = 8,
  1101. .max_register = SMB347_MAX_REGISTER,
  1102. .volatile_reg = smb347_volatile_reg,
  1103. .readable_reg = smb347_readable_reg,
  1104. };
  1105. static const struct power_supply_desc smb347_mains_desc = {
  1106. .name = "smb347-mains",
  1107. .type = POWER_SUPPLY_TYPE_MAINS,
  1108. .get_property = smb347_get_property,
  1109. .properties = smb347_properties,
  1110. .num_properties = ARRAY_SIZE(smb347_properties),
  1111. };
  1112. static const struct power_supply_desc smb347_usb_desc = {
  1113. .name = "smb347-usb",
  1114. .type = POWER_SUPPLY_TYPE_USB,
  1115. .get_property = smb347_get_property,
  1116. .properties = smb347_properties,
  1117. .num_properties = ARRAY_SIZE(smb347_properties),
  1118. };
  1119. static int smb347_probe(struct i2c_client *client,
  1120. const struct i2c_device_id *id)
  1121. {
  1122. struct power_supply_config mains_usb_cfg = {};
  1123. struct device *dev = &client->dev;
  1124. struct smb347_charger *smb;
  1125. int ret;
  1126. smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
  1127. if (!smb)
  1128. return -ENOMEM;
  1129. smb->dev = &client->dev;
  1130. smb->id = id->driver_data;
  1131. i2c_set_clientdata(client, smb);
  1132. smb347_dt_parse_dev_info(smb);
  1133. if (!smb->use_mains && !smb->use_usb)
  1134. return -EINVAL;
  1135. smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap);
  1136. if (IS_ERR(smb->regmap))
  1137. return PTR_ERR(smb->regmap);
  1138. mains_usb_cfg.drv_data = smb;
  1139. mains_usb_cfg.of_node = dev->of_node;
  1140. if (smb->use_mains) {
  1141. smb->mains = devm_power_supply_register(dev, &smb347_mains_desc,
  1142. &mains_usb_cfg);
  1143. if (IS_ERR(smb->mains))
  1144. return PTR_ERR(smb->mains);
  1145. }
  1146. if (smb->use_usb) {
  1147. smb->usb = devm_power_supply_register(dev, &smb347_usb_desc,
  1148. &mains_usb_cfg);
  1149. if (IS_ERR(smb->usb))
  1150. return PTR_ERR(smb->usb);
  1151. }
  1152. ret = smb347_get_battery_info(smb);
  1153. if (ret)
  1154. return ret;
  1155. ret = smb347_hw_init(smb);
  1156. if (ret < 0)
  1157. return ret;
  1158. /*
  1159. * Interrupt pin is optional. If it is connected, we setup the
  1160. * interrupt support here.
  1161. */
  1162. if (client->irq) {
  1163. ret = smb347_irq_init(smb, client);
  1164. if (ret < 0) {
  1165. dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
  1166. dev_warn(dev, "disabling IRQ support\n");
  1167. smb->irq_unsupported = true;
  1168. } else {
  1169. smb347_irq_enable(smb);
  1170. }
  1171. }
  1172. return 0;
  1173. }
  1174. static int smb347_remove(struct i2c_client *client)
  1175. {
  1176. struct smb347_charger *smb = i2c_get_clientdata(client);
  1177. smb347_irq_disable(smb);
  1178. return 0;
  1179. }
  1180. static const struct i2c_device_id smb347_id[] = {
  1181. { "smb345", SMB345 },
  1182. { "smb347", SMB347 },
  1183. { "smb358", SMB358 },
  1184. { },
  1185. };
  1186. MODULE_DEVICE_TABLE(i2c, smb347_id);
  1187. static const struct of_device_id smb3xx_of_match[] = {
  1188. { .compatible = "summit,smb345" },
  1189. { .compatible = "summit,smb347" },
  1190. { .compatible = "summit,smb358" },
  1191. { },
  1192. };
  1193. MODULE_DEVICE_TABLE(of, smb3xx_of_match);
  1194. static struct i2c_driver smb347_driver = {
  1195. .driver = {
  1196. .name = "smb347",
  1197. .of_match_table = smb3xx_of_match,
  1198. },
  1199. .probe = smb347_probe,
  1200. .remove = smb347_remove,
  1201. .id_table = smb347_id,
  1202. };
  1203. module_i2c_driver(smb347_driver);
  1204. MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
  1205. MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
  1206. MODULE_DESCRIPTION("SMB347 battery charger driver");
  1207. MODULE_LICENSE("GPL");