max77693_charger.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762
  1. // SPDX-License-Identifier: GPL-2.0+
  2. //
  3. // max77693_charger.c - Battery charger driver for the Maxim 77693
  4. //
  5. // Copyright (C) 2014 Samsung Electronics
  6. // Krzysztof Kozlowski <krzk@kernel.org>
  7. #include <linux/module.h>
  8. #include <linux/platform_device.h>
  9. #include <linux/power_supply.h>
  10. #include <linux/regmap.h>
  11. #include <linux/mfd/max77693.h>
  12. #include <linux/mfd/max77693-common.h>
  13. #include <linux/mfd/max77693-private.h>
  14. #define MAX77693_CHARGER_NAME "max77693-charger"
  15. static const char *max77693_charger_model = "MAX77693";
  16. static const char *max77693_charger_manufacturer = "Maxim Integrated";
  17. struct max77693_charger {
  18. struct device *dev;
  19. struct max77693_dev *max77693;
  20. struct power_supply *charger;
  21. u32 constant_volt;
  22. u32 min_system_volt;
  23. u32 thermal_regulation_temp;
  24. u32 batttery_overcurrent;
  25. u32 charge_input_threshold_volt;
  26. };
  27. static int max77693_get_charger_state(struct regmap *regmap, int *val)
  28. {
  29. int ret;
  30. unsigned int data;
  31. ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  32. if (ret < 0)
  33. return ret;
  34. data &= CHG_DETAILS_01_CHG_MASK;
  35. data >>= CHG_DETAILS_01_CHG_SHIFT;
  36. switch (data) {
  37. case MAX77693_CHARGING_PREQUALIFICATION:
  38. case MAX77693_CHARGING_FAST_CONST_CURRENT:
  39. case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
  40. case MAX77693_CHARGING_TOP_OFF:
  41. /* In high temp the charging current is reduced, but still charging */
  42. case MAX77693_CHARGING_HIGH_TEMP:
  43. *val = POWER_SUPPLY_STATUS_CHARGING;
  44. break;
  45. case MAX77693_CHARGING_DONE:
  46. *val = POWER_SUPPLY_STATUS_FULL;
  47. break;
  48. case MAX77693_CHARGING_TIMER_EXPIRED:
  49. case MAX77693_CHARGING_THERMISTOR_SUSPEND:
  50. *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
  51. break;
  52. case MAX77693_CHARGING_OFF:
  53. case MAX77693_CHARGING_OVER_TEMP:
  54. case MAX77693_CHARGING_WATCHDOG_EXPIRED:
  55. *val = POWER_SUPPLY_STATUS_DISCHARGING;
  56. break;
  57. case MAX77693_CHARGING_RESERVED:
  58. default:
  59. *val = POWER_SUPPLY_STATUS_UNKNOWN;
  60. }
  61. return 0;
  62. }
  63. static int max77693_get_charge_type(struct regmap *regmap, int *val)
  64. {
  65. int ret;
  66. unsigned int data;
  67. ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  68. if (ret < 0)
  69. return ret;
  70. data &= CHG_DETAILS_01_CHG_MASK;
  71. data >>= CHG_DETAILS_01_CHG_SHIFT;
  72. switch (data) {
  73. case MAX77693_CHARGING_PREQUALIFICATION:
  74. /*
  75. * Top-off: trickle or fast? In top-off the current varies between
  76. * 100 and 250 mA. It is higher than prequalification current.
  77. */
  78. case MAX77693_CHARGING_TOP_OFF:
  79. *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  80. break;
  81. case MAX77693_CHARGING_FAST_CONST_CURRENT:
  82. case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
  83. /* In high temp the charging current is reduced, but still charging */
  84. case MAX77693_CHARGING_HIGH_TEMP:
  85. *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
  86. break;
  87. case MAX77693_CHARGING_DONE:
  88. case MAX77693_CHARGING_TIMER_EXPIRED:
  89. case MAX77693_CHARGING_THERMISTOR_SUSPEND:
  90. case MAX77693_CHARGING_OFF:
  91. case MAX77693_CHARGING_OVER_TEMP:
  92. case MAX77693_CHARGING_WATCHDOG_EXPIRED:
  93. *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
  94. break;
  95. case MAX77693_CHARGING_RESERVED:
  96. default:
  97. *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
  98. }
  99. return 0;
  100. }
  101. /*
  102. * Supported health statuses:
  103. * - POWER_SUPPLY_HEALTH_DEAD
  104. * - POWER_SUPPLY_HEALTH_GOOD
  105. * - POWER_SUPPLY_HEALTH_OVERVOLTAGE
  106. * - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
  107. * - POWER_SUPPLY_HEALTH_UNKNOWN
  108. * - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
  109. */
  110. static int max77693_get_battery_health(struct regmap *regmap, int *val)
  111. {
  112. int ret;
  113. unsigned int data;
  114. ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
  115. if (ret < 0)
  116. return ret;
  117. data &= CHG_DETAILS_01_BAT_MASK;
  118. data >>= CHG_DETAILS_01_BAT_SHIFT;
  119. switch (data) {
  120. case MAX77693_BATTERY_NOBAT:
  121. *val = POWER_SUPPLY_HEALTH_DEAD;
  122. break;
  123. case MAX77693_BATTERY_PREQUALIFICATION:
  124. case MAX77693_BATTERY_GOOD:
  125. case MAX77693_BATTERY_LOWVOLTAGE:
  126. *val = POWER_SUPPLY_HEALTH_GOOD;
  127. break;
  128. case MAX77693_BATTERY_TIMER_EXPIRED:
  129. /*
  130. * Took longer to charge than expected, charging suspended.
  131. * Damaged battery?
  132. */
  133. *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
  134. break;
  135. case MAX77693_BATTERY_OVERVOLTAGE:
  136. *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  137. break;
  138. case MAX77693_BATTERY_OVERCURRENT:
  139. *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  140. break;
  141. case MAX77693_BATTERY_RESERVED:
  142. default:
  143. *val = POWER_SUPPLY_HEALTH_UNKNOWN;
  144. break;
  145. }
  146. return 0;
  147. }
  148. static int max77693_get_present(struct regmap *regmap, int *val)
  149. {
  150. unsigned int data;
  151. int ret;
  152. /*
  153. * Read CHG_INT_OK register. High DETBAT bit here should be
  154. * equal to value 0x0 in CHG_DETAILS_01/BAT field.
  155. */
  156. ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
  157. if (ret < 0)
  158. return ret;
  159. *val = (data & CHG_INT_OK_DETBAT_MASK) ? 0 : 1;
  160. return 0;
  161. }
  162. static int max77693_get_online(struct regmap *regmap, int *val)
  163. {
  164. unsigned int data;
  165. int ret;
  166. ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
  167. if (ret < 0)
  168. return ret;
  169. *val = (data & CHG_INT_OK_CHGIN_MASK) ? 1 : 0;
  170. return 0;
  171. }
  172. static enum power_supply_property max77693_charger_props[] = {
  173. POWER_SUPPLY_PROP_STATUS,
  174. POWER_SUPPLY_PROP_CHARGE_TYPE,
  175. POWER_SUPPLY_PROP_HEALTH,
  176. POWER_SUPPLY_PROP_PRESENT,
  177. POWER_SUPPLY_PROP_ONLINE,
  178. POWER_SUPPLY_PROP_MODEL_NAME,
  179. POWER_SUPPLY_PROP_MANUFACTURER,
  180. };
  181. static int max77693_charger_get_property(struct power_supply *psy,
  182. enum power_supply_property psp,
  183. union power_supply_propval *val)
  184. {
  185. struct max77693_charger *chg = power_supply_get_drvdata(psy);
  186. struct regmap *regmap = chg->max77693->regmap;
  187. int ret = 0;
  188. switch (psp) {
  189. case POWER_SUPPLY_PROP_STATUS:
  190. ret = max77693_get_charger_state(regmap, &val->intval);
  191. break;
  192. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  193. ret = max77693_get_charge_type(regmap, &val->intval);
  194. break;
  195. case POWER_SUPPLY_PROP_HEALTH:
  196. ret = max77693_get_battery_health(regmap, &val->intval);
  197. break;
  198. case POWER_SUPPLY_PROP_PRESENT:
  199. ret = max77693_get_present(regmap, &val->intval);
  200. break;
  201. case POWER_SUPPLY_PROP_ONLINE:
  202. ret = max77693_get_online(regmap, &val->intval);
  203. break;
  204. case POWER_SUPPLY_PROP_MODEL_NAME:
  205. val->strval = max77693_charger_model;
  206. break;
  207. case POWER_SUPPLY_PROP_MANUFACTURER:
  208. val->strval = max77693_charger_manufacturer;
  209. break;
  210. default:
  211. return -EINVAL;
  212. }
  213. return ret;
  214. }
  215. static const struct power_supply_desc max77693_charger_desc = {
  216. .name = MAX77693_CHARGER_NAME,
  217. .type = POWER_SUPPLY_TYPE_BATTERY,
  218. .properties = max77693_charger_props,
  219. .num_properties = ARRAY_SIZE(max77693_charger_props),
  220. .get_property = max77693_charger_get_property,
  221. };
  222. static ssize_t device_attr_store(struct device *dev,
  223. struct device_attribute *attr, const char *buf, size_t count,
  224. int (*fn)(struct max77693_charger *, unsigned long))
  225. {
  226. struct max77693_charger *chg = dev_get_drvdata(dev);
  227. unsigned long val;
  228. int ret;
  229. ret = kstrtoul(buf, 10, &val);
  230. if (ret)
  231. return ret;
  232. ret = fn(chg, val);
  233. if (ret)
  234. return ret;
  235. return count;
  236. }
  237. static ssize_t fast_charge_timer_show(struct device *dev,
  238. struct device_attribute *attr, char *buf)
  239. {
  240. struct max77693_charger *chg = dev_get_drvdata(dev);
  241. unsigned int data, val;
  242. int ret;
  243. ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01,
  244. &data);
  245. if (ret < 0)
  246. return ret;
  247. data &= CHG_CNFG_01_FCHGTIME_MASK;
  248. data >>= CHG_CNFG_01_FCHGTIME_SHIFT;
  249. switch (data) {
  250. case 0x1 ... 0x7:
  251. /* Starting from 4 hours, step by 2 hours */
  252. val = 4 + (data - 1) * 2;
  253. break;
  254. case 0x0:
  255. default:
  256. val = 0;
  257. break;
  258. }
  259. return scnprintf(buf, PAGE_SIZE, "%u\n", val);
  260. }
  261. static int max77693_set_fast_charge_timer(struct max77693_charger *chg,
  262. unsigned long hours)
  263. {
  264. unsigned int data;
  265. /*
  266. * 0x00 - disable
  267. * 0x01 - 4h
  268. * 0x02 - 6h
  269. * ...
  270. * 0x07 - 16h
  271. * Round down odd values.
  272. */
  273. switch (hours) {
  274. case 4 ... 16:
  275. data = (hours - 4) / 2 + 1;
  276. break;
  277. case 0:
  278. /* Disable */
  279. data = 0;
  280. break;
  281. default:
  282. return -EINVAL;
  283. }
  284. data <<= CHG_CNFG_01_FCHGTIME_SHIFT;
  285. return regmap_update_bits(chg->max77693->regmap,
  286. MAX77693_CHG_REG_CHG_CNFG_01,
  287. CHG_CNFG_01_FCHGTIME_MASK, data);
  288. }
  289. static ssize_t fast_charge_timer_store(struct device *dev,
  290. struct device_attribute *attr, const char *buf, size_t count)
  291. {
  292. return device_attr_store(dev, attr, buf, count,
  293. max77693_set_fast_charge_timer);
  294. }
  295. static ssize_t top_off_threshold_current_show(struct device *dev,
  296. struct device_attribute *attr, char *buf)
  297. {
  298. struct max77693_charger *chg = dev_get_drvdata(dev);
  299. unsigned int data, val;
  300. int ret;
  301. ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
  302. &data);
  303. if (ret < 0)
  304. return ret;
  305. data &= CHG_CNFG_03_TOITH_MASK;
  306. data >>= CHG_CNFG_03_TOITH_SHIFT;
  307. if (data <= 0x04)
  308. val = 100000 + data * 25000;
  309. else
  310. val = data * 50000;
  311. return scnprintf(buf, PAGE_SIZE, "%u\n", val);
  312. }
  313. static int max77693_set_top_off_threshold_current(struct max77693_charger *chg,
  314. unsigned long uamp)
  315. {
  316. unsigned int data;
  317. if (uamp < 100000 || uamp > 350000)
  318. return -EINVAL;
  319. if (uamp <= 200000)
  320. data = (uamp - 100000) / 25000;
  321. else
  322. /* (200000, 350000> */
  323. data = uamp / 50000;
  324. data <<= CHG_CNFG_03_TOITH_SHIFT;
  325. return regmap_update_bits(chg->max77693->regmap,
  326. MAX77693_CHG_REG_CHG_CNFG_03,
  327. CHG_CNFG_03_TOITH_MASK, data);
  328. }
  329. static ssize_t top_off_threshold_current_store(struct device *dev,
  330. struct device_attribute *attr, const char *buf, size_t count)
  331. {
  332. return device_attr_store(dev, attr, buf, count,
  333. max77693_set_top_off_threshold_current);
  334. }
  335. static ssize_t top_off_timer_show(struct device *dev,
  336. struct device_attribute *attr, char *buf)
  337. {
  338. struct max77693_charger *chg = dev_get_drvdata(dev);
  339. unsigned int data, val;
  340. int ret;
  341. ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
  342. &data);
  343. if (ret < 0)
  344. return ret;
  345. data &= CHG_CNFG_03_TOTIME_MASK;
  346. data >>= CHG_CNFG_03_TOTIME_SHIFT;
  347. val = data * 10;
  348. return scnprintf(buf, PAGE_SIZE, "%u\n", val);
  349. }
  350. static int max77693_set_top_off_timer(struct max77693_charger *chg,
  351. unsigned long minutes)
  352. {
  353. unsigned int data;
  354. if (minutes > 70)
  355. return -EINVAL;
  356. data = minutes / 10;
  357. data <<= CHG_CNFG_03_TOTIME_SHIFT;
  358. return regmap_update_bits(chg->max77693->regmap,
  359. MAX77693_CHG_REG_CHG_CNFG_03,
  360. CHG_CNFG_03_TOTIME_MASK, data);
  361. }
  362. static ssize_t top_off_timer_store(struct device *dev,
  363. struct device_attribute *attr, const char *buf, size_t count)
  364. {
  365. return device_attr_store(dev, attr, buf, count,
  366. max77693_set_top_off_timer);
  367. }
  368. static DEVICE_ATTR_RW(fast_charge_timer);
  369. static DEVICE_ATTR_RW(top_off_threshold_current);
  370. static DEVICE_ATTR_RW(top_off_timer);
  371. static int max77693_set_constant_volt(struct max77693_charger *chg,
  372. unsigned int uvolt)
  373. {
  374. unsigned int data;
  375. /*
  376. * 0x00 - 3.650 V
  377. * 0x01 - 3.675 V
  378. * ...
  379. * 0x1b - 4.325 V
  380. * 0x1c - 4.340 V
  381. * 0x1d - 4.350 V
  382. * 0x1e - 4.375 V
  383. * 0x1f - 4.400 V
  384. */
  385. if (uvolt >= 3650000 && uvolt < 4340000)
  386. data = (uvolt - 3650000) / 25000;
  387. else if (uvolt >= 4340000 && uvolt < 4350000)
  388. data = 0x1c;
  389. else if (uvolt >= 4350000 && uvolt <= 4400000)
  390. data = 0x1d + (uvolt - 4350000) / 25000;
  391. else {
  392. dev_err(chg->dev, "Wrong value for charging constant voltage\n");
  393. return -EINVAL;
  394. }
  395. data <<= CHG_CNFG_04_CHGCVPRM_SHIFT;
  396. dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,
  397. data);
  398. return regmap_update_bits(chg->max77693->regmap,
  399. MAX77693_CHG_REG_CHG_CNFG_04,
  400. CHG_CNFG_04_CHGCVPRM_MASK, data);
  401. }
  402. static int max77693_set_min_system_volt(struct max77693_charger *chg,
  403. unsigned int uvolt)
  404. {
  405. unsigned int data;
  406. if (uvolt < 3000000 || uvolt > 3700000) {
  407. dev_err(chg->dev, "Wrong value for minimum system regulation voltage\n");
  408. return -EINVAL;
  409. }
  410. data = (uvolt - 3000000) / 100000;
  411. data <<= CHG_CNFG_04_MINVSYS_SHIFT;
  412. dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",
  413. uvolt, data);
  414. return regmap_update_bits(chg->max77693->regmap,
  415. MAX77693_CHG_REG_CHG_CNFG_04,
  416. CHG_CNFG_04_MINVSYS_MASK, data);
  417. }
  418. static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg,
  419. unsigned int cels)
  420. {
  421. unsigned int data;
  422. switch (cels) {
  423. case 70:
  424. case 85:
  425. case 100:
  426. case 115:
  427. data = (cels - 70) / 15;
  428. break;
  429. default:
  430. dev_err(chg->dev, "Wrong value for thermal regulation loop temperature\n");
  431. return -EINVAL;
  432. }
  433. data <<= CHG_CNFG_07_REGTEMP_SHIFT;
  434. dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",
  435. cels, data);
  436. return regmap_update_bits(chg->max77693->regmap,
  437. MAX77693_CHG_REG_CHG_CNFG_07,
  438. CHG_CNFG_07_REGTEMP_MASK, data);
  439. }
  440. static int max77693_set_batttery_overcurrent(struct max77693_charger *chg,
  441. unsigned int uamp)
  442. {
  443. unsigned int data;
  444. if (uamp && (uamp < 2000000 || uamp > 3500000)) {
  445. dev_err(chg->dev, "Wrong value for battery overcurrent\n");
  446. return -EINVAL;
  447. }
  448. if (uamp)
  449. data = ((uamp - 2000000) / 250000) + 1;
  450. else
  451. data = 0; /* disable */
  452. data <<= CHG_CNFG_12_B2SOVRC_SHIFT;
  453. dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)\n", uamp, data);
  454. return regmap_update_bits(chg->max77693->regmap,
  455. MAX77693_CHG_REG_CHG_CNFG_12,
  456. CHG_CNFG_12_B2SOVRC_MASK, data);
  457. }
  458. static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg,
  459. unsigned int uvolt)
  460. {
  461. unsigned int data;
  462. switch (uvolt) {
  463. case 4300000:
  464. data = 0x0;
  465. break;
  466. case 4700000:
  467. case 4800000:
  468. case 4900000:
  469. data = (uvolt - 4700000) / 100000;
  470. break;
  471. default:
  472. dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n");
  473. return -EINVAL;
  474. }
  475. data <<= CHG_CNFG_12_VCHGINREG_SHIFT;
  476. dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)\n",
  477. uvolt, data);
  478. return regmap_update_bits(chg->max77693->regmap,
  479. MAX77693_CHG_REG_CHG_CNFG_12,
  480. CHG_CNFG_12_VCHGINREG_MASK, data);
  481. }
  482. /*
  483. * Sets charger registers to proper and safe default values.
  484. */
  485. static int max77693_reg_init(struct max77693_charger *chg)
  486. {
  487. int ret;
  488. unsigned int data;
  489. /* Unlock charger register protection */
  490. data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT);
  491. ret = regmap_update_bits(chg->max77693->regmap,
  492. MAX77693_CHG_REG_CHG_CNFG_06,
  493. CHG_CNFG_06_CHGPROT_MASK, data);
  494. if (ret) {
  495. dev_err(chg->dev, "Error unlocking registers: %d\n", ret);
  496. return ret;
  497. }
  498. ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER);
  499. if (ret)
  500. return ret;
  501. ret = max77693_set_top_off_threshold_current(chg,
  502. DEFAULT_TOP_OFF_THRESHOLD_CURRENT);
  503. if (ret)
  504. return ret;
  505. ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER);
  506. if (ret)
  507. return ret;
  508. ret = max77693_set_constant_volt(chg, chg->constant_volt);
  509. if (ret)
  510. return ret;
  511. ret = max77693_set_min_system_volt(chg, chg->min_system_volt);
  512. if (ret)
  513. return ret;
  514. ret = max77693_set_thermal_regulation_temp(chg,
  515. chg->thermal_regulation_temp);
  516. if (ret)
  517. return ret;
  518. ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent);
  519. if (ret)
  520. return ret;
  521. return max77693_set_charge_input_threshold_volt(chg,
  522. chg->charge_input_threshold_volt);
  523. }
  524. #ifdef CONFIG_OF
  525. static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
  526. {
  527. struct device_node *np = dev->of_node;
  528. if (!np) {
  529. dev_err(dev, "no charger OF node\n");
  530. return -EINVAL;
  531. }
  532. if (of_property_read_u32(np, "maxim,constant-microvolt",
  533. &chg->constant_volt))
  534. chg->constant_volt = DEFAULT_CONSTANT_VOLT;
  535. if (of_property_read_u32(np, "maxim,min-system-microvolt",
  536. &chg->min_system_volt))
  537. chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT;
  538. if (of_property_read_u32(np, "maxim,thermal-regulation-celsius",
  539. &chg->thermal_regulation_temp))
  540. chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP;
  541. if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp",
  542. &chg->batttery_overcurrent))
  543. chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT;
  544. if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt",
  545. &chg->charge_input_threshold_volt))
  546. chg->charge_input_threshold_volt =
  547. DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT;
  548. return 0;
  549. }
  550. #else /* CONFIG_OF */
  551. static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
  552. {
  553. return 0;
  554. }
  555. #endif /* CONFIG_OF */
  556. static int max77693_charger_probe(struct platform_device *pdev)
  557. {
  558. struct max77693_charger *chg;
  559. struct power_supply_config psy_cfg = {};
  560. struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);
  561. int ret;
  562. chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
  563. if (!chg)
  564. return -ENOMEM;
  565. platform_set_drvdata(pdev, chg);
  566. chg->dev = &pdev->dev;
  567. chg->max77693 = max77693;
  568. ret = max77693_dt_init(&pdev->dev, chg);
  569. if (ret)
  570. return ret;
  571. ret = max77693_reg_init(chg);
  572. if (ret)
  573. return ret;
  574. psy_cfg.drv_data = chg;
  575. ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
  576. if (ret) {
  577. dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry\n");
  578. goto err;
  579. }
  580. ret = device_create_file(&pdev->dev,
  581. &dev_attr_top_off_threshold_current);
  582. if (ret) {
  583. dev_err(&pdev->dev, "failed: create top off current sysfs entry\n");
  584. goto err;
  585. }
  586. ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer);
  587. if (ret) {
  588. dev_err(&pdev->dev, "failed: create top off timer sysfs entry\n");
  589. goto err;
  590. }
  591. chg->charger = power_supply_register(&pdev->dev,
  592. &max77693_charger_desc,
  593. &psy_cfg);
  594. if (IS_ERR(chg->charger)) {
  595. dev_err(&pdev->dev, "failed: power supply register\n");
  596. ret = PTR_ERR(chg->charger);
  597. goto err;
  598. }
  599. return 0;
  600. err:
  601. device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
  602. device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
  603. device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
  604. return ret;
  605. }
  606. static int max77693_charger_remove(struct platform_device *pdev)
  607. {
  608. struct max77693_charger *chg = platform_get_drvdata(pdev);
  609. device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
  610. device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
  611. device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
  612. power_supply_unregister(chg->charger);
  613. return 0;
  614. }
  615. static const struct platform_device_id max77693_charger_id[] = {
  616. { "max77693-charger", 0, },
  617. { }
  618. };
  619. MODULE_DEVICE_TABLE(platform, max77693_charger_id);
  620. static struct platform_driver max77693_charger_driver = {
  621. .driver = {
  622. .name = "max77693-charger",
  623. },
  624. .probe = max77693_charger_probe,
  625. .remove = max77693_charger_remove,
  626. .id_table = max77693_charger_id,
  627. };
  628. module_platform_driver(max77693_charger_driver);
  629. MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
  630. MODULE_DESCRIPTION("Maxim 77693 charger driver");
  631. MODULE_LICENSE("GPL");