max14577_charger.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648
  1. // SPDX-License-Identifier: GPL-2.0+
  2. //
  3. // max14577_charger.c - Battery charger driver for the Maxim 14577/77836
  4. //
  5. // Copyright (C) 2013,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/mfd/max14577-private.h>
  11. #include <linux/mfd/max14577.h>
  12. struct max14577_charger {
  13. struct device *dev;
  14. struct max14577 *max14577;
  15. struct power_supply *charger;
  16. struct max14577_charger_platform_data *pdata;
  17. };
  18. /*
  19. * Helper function for mapping values of STATUS2/CHGTYP register on max14577
  20. * and max77836 chipsets to enum maxim_muic_charger_type.
  21. */
  22. static enum max14577_muic_charger_type maxim_get_charger_type(
  23. enum maxim_device_type dev_type, u8 val) {
  24. switch (val) {
  25. case MAX14577_CHARGER_TYPE_NONE:
  26. case MAX14577_CHARGER_TYPE_USB:
  27. case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
  28. case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
  29. case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
  30. case MAX14577_CHARGER_TYPE_SPECIAL_1A:
  31. return val;
  32. case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
  33. case MAX14577_CHARGER_TYPE_RESERVED:
  34. if (dev_type == MAXIM_DEVICE_TYPE_MAX77836)
  35. val |= 0x8;
  36. return val;
  37. default:
  38. WARN_ONCE(1, "max14577: Unsupported chgtyp register value 0x%02x", val);
  39. return val;
  40. }
  41. }
  42. static int max14577_get_charger_state(struct max14577_charger *chg, int *val)
  43. {
  44. struct regmap *rmap = chg->max14577->regmap;
  45. int ret;
  46. u8 reg_data;
  47. /*
  48. * Charging occurs only if:
  49. * - CHGCTRL2/MBCHOSTEN == 1
  50. * - STATUS2/CGMBC == 1
  51. *
  52. * TODO:
  53. * - handle FULL after Top-off timer (EOC register may be off
  54. * and the charger won't be charging although MBCHOSTEN is on)
  55. * - handle properly dead-battery charging (respect timer)
  56. * - handle timers (fast-charge and prequal) /MBCCHGERR/
  57. */
  58. ret = max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, &reg_data);
  59. if (ret < 0)
  60. goto out;
  61. if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0) {
  62. *val = POWER_SUPPLY_STATUS_DISCHARGING;
  63. goto out;
  64. }
  65. ret = max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, &reg_data);
  66. if (ret < 0)
  67. goto out;
  68. if (reg_data & STATUS3_CGMBC_MASK) {
  69. /* Charger or USB-cable is connected */
  70. if (reg_data & STATUS3_EOC_MASK)
  71. *val = POWER_SUPPLY_STATUS_FULL;
  72. else
  73. *val = POWER_SUPPLY_STATUS_CHARGING;
  74. goto out;
  75. }
  76. *val = POWER_SUPPLY_STATUS_DISCHARGING;
  77. out:
  78. return ret;
  79. }
  80. /*
  81. * Supported charge types:
  82. * - POWER_SUPPLY_CHARGE_TYPE_NONE
  83. * - POWER_SUPPLY_CHARGE_TYPE_FAST
  84. */
  85. static int max14577_get_charge_type(struct max14577_charger *chg, int *val)
  86. {
  87. int ret, charging;
  88. /*
  89. * TODO: CHARGE_TYPE_TRICKLE (VCHGR_RC or EOC)?
  90. * As spec says:
  91. * [after reaching EOC interrupt]
  92. * "When the battery is fully charged, the 30-minute (typ)
  93. * top-off timer starts. The device continues to trickle
  94. * charge the battery until the top-off timer runs out."
  95. */
  96. ret = max14577_get_charger_state(chg, &charging);
  97. if (ret < 0)
  98. return ret;
  99. if (charging == POWER_SUPPLY_STATUS_CHARGING)
  100. *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
  101. else
  102. *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
  103. return 0;
  104. }
  105. static int max14577_get_online(struct max14577_charger *chg, int *val)
  106. {
  107. struct regmap *rmap = chg->max14577->regmap;
  108. u8 reg_data;
  109. int ret;
  110. enum max14577_muic_charger_type chg_type;
  111. ret = max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data);
  112. if (ret < 0)
  113. return ret;
  114. reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT);
  115. chg_type = maxim_get_charger_type(chg->max14577->dev_type, reg_data);
  116. switch (chg_type) {
  117. case MAX14577_CHARGER_TYPE_USB:
  118. case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
  119. case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
  120. case MAX14577_CHARGER_TYPE_SPECIAL_1A:
  121. case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
  122. case MAX77836_CHARGER_TYPE_SPECIAL_BIAS:
  123. *val = 1;
  124. break;
  125. case MAX14577_CHARGER_TYPE_NONE:
  126. case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
  127. case MAX14577_CHARGER_TYPE_RESERVED:
  128. case MAX77836_CHARGER_TYPE_RESERVED:
  129. default:
  130. *val = 0;
  131. }
  132. return 0;
  133. }
  134. /*
  135. * Supported health statuses:
  136. * - POWER_SUPPLY_HEALTH_DEAD
  137. * - POWER_SUPPLY_HEALTH_OVERVOLTAGE
  138. * - POWER_SUPPLY_HEALTH_GOOD
  139. */
  140. static int max14577_get_battery_health(struct max14577_charger *chg, int *val)
  141. {
  142. struct regmap *rmap = chg->max14577->regmap;
  143. int ret;
  144. u8 reg_data;
  145. enum max14577_muic_charger_type chg_type;
  146. ret = max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, &reg_data);
  147. if (ret < 0)
  148. goto out;
  149. reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT);
  150. chg_type = maxim_get_charger_type(chg->max14577->dev_type, reg_data);
  151. if (chg_type == MAX14577_CHARGER_TYPE_DEAD_BATTERY) {
  152. *val = POWER_SUPPLY_HEALTH_DEAD;
  153. goto out;
  154. }
  155. ret = max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, &reg_data);
  156. if (ret < 0)
  157. goto out;
  158. if (reg_data & STATUS3_OVP_MASK) {
  159. *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  160. goto out;
  161. }
  162. /* Not dead, not overvoltage */
  163. *val = POWER_SUPPLY_HEALTH_GOOD;
  164. out:
  165. return ret;
  166. }
  167. /*
  168. * Always returns 1.
  169. * The max14577 chip doesn't report any status of battery presence.
  170. * Lets assume that it will always be used with some battery.
  171. */
  172. static int max14577_get_present(struct max14577_charger *chg, int *val)
  173. {
  174. *val = 1;
  175. return 0;
  176. }
  177. static int max14577_set_fast_charge_timer(struct max14577_charger *chg,
  178. unsigned long hours)
  179. {
  180. u8 reg_data;
  181. switch (hours) {
  182. case 5 ... 7:
  183. reg_data = hours - 3;
  184. break;
  185. case 0:
  186. /* Disable */
  187. reg_data = 0x7;
  188. break;
  189. default:
  190. dev_err(chg->dev, "Wrong value for Fast-Charge Timer: %lu\n",
  191. hours);
  192. return -EINVAL;
  193. }
  194. reg_data <<= CHGCTRL1_TCHW_SHIFT;
  195. return max14577_update_reg(chg->max14577->regmap,
  196. MAX14577_REG_CHGCTRL1, CHGCTRL1_TCHW_MASK, reg_data);
  197. }
  198. static int max14577_init_constant_voltage(struct max14577_charger *chg,
  199. unsigned int uvolt)
  200. {
  201. u8 reg_data;
  202. if (uvolt < MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN ||
  203. uvolt > MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX)
  204. return -EINVAL;
  205. if (uvolt == 4200000)
  206. reg_data = 0x0;
  207. else if (uvolt == MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX)
  208. reg_data = 0x1f;
  209. else if (uvolt <= 4280000) {
  210. unsigned int val = uvolt;
  211. val -= MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN;
  212. val /= MAXIM_CHARGER_CONSTANT_VOLTAGE_STEP;
  213. if (uvolt <= 4180000)
  214. reg_data = 0x1 + val;
  215. else
  216. reg_data = val; /* Fix for gap between 4.18V and 4.22V */
  217. } else
  218. return -EINVAL;
  219. reg_data <<= CHGCTRL3_MBCCVWRC_SHIFT;
  220. return max14577_write_reg(chg->max14577->regmap,
  221. MAX14577_CHG_REG_CHG_CTRL3, reg_data);
  222. }
  223. static int max14577_init_eoc(struct max14577_charger *chg,
  224. unsigned int uamp)
  225. {
  226. unsigned int current_bits = 0xf;
  227. u8 reg_data;
  228. switch (chg->max14577->dev_type) {
  229. case MAXIM_DEVICE_TYPE_MAX77836:
  230. if (uamp < 5000)
  231. return -EINVAL; /* Requested current is too low */
  232. if (uamp >= 7500 && uamp < 10000)
  233. current_bits = 0x0;
  234. else if (uamp <= 50000) {
  235. /* <5000, 7499> and <10000, 50000> */
  236. current_bits = uamp / 5000;
  237. } else {
  238. uamp = min(uamp, 100000U) - 50000U;
  239. current_bits = 0xa + uamp / 10000;
  240. }
  241. break;
  242. case MAXIM_DEVICE_TYPE_MAX14577:
  243. default:
  244. if (uamp < MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN)
  245. return -EINVAL; /* Requested current is too low */
  246. uamp = min(uamp, MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX);
  247. uamp -= MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN;
  248. current_bits = uamp / MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP;
  249. break;
  250. }
  251. reg_data = current_bits << CHGCTRL5_EOCS_SHIFT;
  252. return max14577_update_reg(chg->max14577->regmap,
  253. MAX14577_CHG_REG_CHG_CTRL5, CHGCTRL5_EOCS_MASK,
  254. reg_data);
  255. }
  256. static int max14577_init_fast_charge(struct max14577_charger *chg,
  257. unsigned int uamp)
  258. {
  259. u8 reg_data;
  260. int ret;
  261. const struct maxim_charger_current *limits =
  262. &maxim_charger_currents[chg->max14577->dev_type];
  263. ret = maxim_charger_calc_reg_current(limits, uamp, uamp, &reg_data);
  264. if (ret) {
  265. dev_err(chg->dev, "Wrong value for fast charge: %u\n", uamp);
  266. return ret;
  267. }
  268. return max14577_update_reg(chg->max14577->regmap,
  269. MAX14577_CHG_REG_CHG_CTRL4,
  270. CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK,
  271. reg_data);
  272. }
  273. /*
  274. * Sets charger registers to proper and safe default values.
  275. * Some of these values are equal to defaults in MAX14577E
  276. * data sheet but there are minor differences.
  277. */
  278. static int max14577_charger_reg_init(struct max14577_charger *chg)
  279. {
  280. struct regmap *rmap = chg->max14577->regmap;
  281. u8 reg_data;
  282. int ret;
  283. /*
  284. * Charger-Type Manual Detection, default off (set CHGTYPMAN to 0)
  285. * Charger-Detection Enable, default on (set CHGDETEN to 1)
  286. * Combined mask of CHGDETEN and CHGTYPMAN will zero the CHGTYPMAN bit
  287. */
  288. reg_data = 0x1 << CDETCTRL1_CHGDETEN_SHIFT;
  289. max14577_update_reg(rmap, MAX14577_REG_CDETCTRL1,
  290. CDETCTRL1_CHGDETEN_MASK | CDETCTRL1_CHGTYPMAN_MASK,
  291. reg_data);
  292. /*
  293. * Wall-Adapter Rapid Charge, default on
  294. * Battery-Charger, default on
  295. */
  296. reg_data = 0x1 << CHGCTRL2_VCHGR_RC_SHIFT;
  297. reg_data |= 0x1 << CHGCTRL2_MBCHOSTEN_SHIFT;
  298. max14577_write_reg(rmap, MAX14577_REG_CHGCTRL2, reg_data);
  299. /* Auto Charging Stop, default off */
  300. reg_data = 0x0 << CHGCTRL6_AUTOSTOP_SHIFT;
  301. max14577_write_reg(rmap, MAX14577_REG_CHGCTRL6, reg_data);
  302. ret = max14577_init_constant_voltage(chg, chg->pdata->constant_uvolt);
  303. if (ret)
  304. return ret;
  305. ret = max14577_init_eoc(chg, chg->pdata->eoc_uamp);
  306. if (ret)
  307. return ret;
  308. ret = max14577_init_fast_charge(chg, chg->pdata->fast_charge_uamp);
  309. if (ret)
  310. return ret;
  311. ret = max14577_set_fast_charge_timer(chg,
  312. MAXIM_CHARGER_FAST_CHARGE_TIMER_DEFAULT);
  313. if (ret)
  314. return ret;
  315. /* Initialize Overvoltage-Protection Threshold */
  316. switch (chg->pdata->ovp_uvolt) {
  317. case 7500000:
  318. reg_data = 0x0;
  319. break;
  320. case 6000000:
  321. case 6500000:
  322. case 7000000:
  323. reg_data = 0x1 + (chg->pdata->ovp_uvolt - 6000000) / 500000;
  324. break;
  325. default:
  326. dev_err(chg->dev, "Wrong value for OVP: %u\n",
  327. chg->pdata->ovp_uvolt);
  328. return -EINVAL;
  329. }
  330. reg_data <<= CHGCTRL7_OTPCGHCVS_SHIFT;
  331. max14577_write_reg(rmap, MAX14577_REG_CHGCTRL7, reg_data);
  332. return 0;
  333. }
  334. /* Support property from charger */
  335. static enum power_supply_property max14577_charger_props[] = {
  336. POWER_SUPPLY_PROP_STATUS,
  337. POWER_SUPPLY_PROP_CHARGE_TYPE,
  338. POWER_SUPPLY_PROP_HEALTH,
  339. POWER_SUPPLY_PROP_PRESENT,
  340. POWER_SUPPLY_PROP_ONLINE,
  341. POWER_SUPPLY_PROP_MODEL_NAME,
  342. POWER_SUPPLY_PROP_MANUFACTURER,
  343. };
  344. static const char * const model_names[] = {
  345. [MAXIM_DEVICE_TYPE_UNKNOWN] = "MAX14577-like",
  346. [MAXIM_DEVICE_TYPE_MAX14577] = "MAX14577",
  347. [MAXIM_DEVICE_TYPE_MAX77836] = "MAX77836",
  348. };
  349. static const char *manufacturer = "Maxim Integrated";
  350. static int max14577_charger_get_property(struct power_supply *psy,
  351. enum power_supply_property psp,
  352. union power_supply_propval *val)
  353. {
  354. struct max14577_charger *chg = power_supply_get_drvdata(psy);
  355. int ret = 0;
  356. switch (psp) {
  357. case POWER_SUPPLY_PROP_STATUS:
  358. ret = max14577_get_charger_state(chg, &val->intval);
  359. break;
  360. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  361. ret = max14577_get_charge_type(chg, &val->intval);
  362. break;
  363. case POWER_SUPPLY_PROP_HEALTH:
  364. ret = max14577_get_battery_health(chg, &val->intval);
  365. break;
  366. case POWER_SUPPLY_PROP_PRESENT:
  367. ret = max14577_get_present(chg, &val->intval);
  368. break;
  369. case POWER_SUPPLY_PROP_ONLINE:
  370. ret = max14577_get_online(chg, &val->intval);
  371. break;
  372. case POWER_SUPPLY_PROP_MODEL_NAME:
  373. BUILD_BUG_ON(ARRAY_SIZE(model_names) != MAXIM_DEVICE_TYPE_NUM);
  374. val->strval = model_names[chg->max14577->dev_type];
  375. break;
  376. case POWER_SUPPLY_PROP_MANUFACTURER:
  377. val->strval = manufacturer;
  378. break;
  379. default:
  380. return -EINVAL;
  381. }
  382. return ret;
  383. }
  384. static const struct power_supply_desc max14577_charger_desc = {
  385. .name = "max14577-charger",
  386. .type = POWER_SUPPLY_TYPE_BATTERY,
  387. .properties = max14577_charger_props,
  388. .num_properties = ARRAY_SIZE(max14577_charger_props),
  389. .get_property = max14577_charger_get_property,
  390. };
  391. #ifdef CONFIG_OF
  392. static struct max14577_charger_platform_data *max14577_charger_dt_init(
  393. struct platform_device *pdev)
  394. {
  395. struct max14577_charger_platform_data *pdata;
  396. struct device_node *np = pdev->dev.of_node;
  397. int ret;
  398. if (!np) {
  399. dev_err(&pdev->dev, "No charger OF node\n");
  400. return ERR_PTR(-EINVAL);
  401. }
  402. pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  403. if (!pdata)
  404. return ERR_PTR(-ENOMEM);
  405. ret = of_property_read_u32(np, "maxim,constant-uvolt",
  406. &pdata->constant_uvolt);
  407. if (ret) {
  408. dev_err(&pdev->dev, "Cannot parse maxim,constant-uvolt field from DT\n");
  409. return ERR_PTR(ret);
  410. }
  411. ret = of_property_read_u32(np, "maxim,fast-charge-uamp",
  412. &pdata->fast_charge_uamp);
  413. if (ret) {
  414. dev_err(&pdev->dev, "Cannot parse maxim,fast-charge-uamp field from DT\n");
  415. return ERR_PTR(ret);
  416. }
  417. ret = of_property_read_u32(np, "maxim,eoc-uamp", &pdata->eoc_uamp);
  418. if (ret) {
  419. dev_err(&pdev->dev, "Cannot parse maxim,eoc-uamp field from DT\n");
  420. return ERR_PTR(ret);
  421. }
  422. ret = of_property_read_u32(np, "maxim,ovp-uvolt", &pdata->ovp_uvolt);
  423. if (ret) {
  424. dev_err(&pdev->dev, "Cannot parse maxim,ovp-uvolt field from DT\n");
  425. return ERR_PTR(ret);
  426. }
  427. return pdata;
  428. }
  429. #else /* CONFIG_OF */
  430. static struct max14577_charger_platform_data *max14577_charger_dt_init(
  431. struct platform_device *pdev)
  432. {
  433. return NULL;
  434. }
  435. #endif /* CONFIG_OF */
  436. static ssize_t show_fast_charge_timer(struct device *dev,
  437. struct device_attribute *attr, char *buf)
  438. {
  439. struct max14577_charger *chg = dev_get_drvdata(dev);
  440. u8 reg_data;
  441. int ret;
  442. unsigned int val;
  443. ret = max14577_read_reg(chg->max14577->regmap, MAX14577_REG_CHGCTRL1,
  444. &reg_data);
  445. if (ret)
  446. return ret;
  447. reg_data &= CHGCTRL1_TCHW_MASK;
  448. reg_data >>= CHGCTRL1_TCHW_SHIFT;
  449. switch (reg_data) {
  450. case 0x2 ... 0x4:
  451. val = reg_data + 3;
  452. break;
  453. case 0x7:
  454. val = 0;
  455. break;
  456. default:
  457. val = 5;
  458. break;
  459. }
  460. return scnprintf(buf, PAGE_SIZE, "%u\n", val);
  461. }
  462. static ssize_t store_fast_charge_timer(struct device *dev,
  463. struct device_attribute *attr, const char *buf, size_t count)
  464. {
  465. struct max14577_charger *chg = dev_get_drvdata(dev);
  466. unsigned long val;
  467. int ret;
  468. ret = kstrtoul(buf, 10, &val);
  469. if (ret)
  470. return ret;
  471. ret = max14577_set_fast_charge_timer(chg, val);
  472. if (ret)
  473. return ret;
  474. return count;
  475. }
  476. static DEVICE_ATTR(fast_charge_timer, S_IRUGO | S_IWUSR,
  477. show_fast_charge_timer, store_fast_charge_timer);
  478. static int max14577_charger_probe(struct platform_device *pdev)
  479. {
  480. struct max14577_charger *chg;
  481. struct power_supply_config psy_cfg = {};
  482. struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
  483. int ret;
  484. chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
  485. if (!chg)
  486. return -ENOMEM;
  487. platform_set_drvdata(pdev, chg);
  488. chg->dev = &pdev->dev;
  489. chg->max14577 = max14577;
  490. chg->pdata = max14577_charger_dt_init(pdev);
  491. if (IS_ERR_OR_NULL(chg->pdata))
  492. return PTR_ERR(chg->pdata);
  493. ret = max14577_charger_reg_init(chg);
  494. if (ret)
  495. return ret;
  496. ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
  497. if (ret) {
  498. dev_err(&pdev->dev, "failed: create sysfs entry\n");
  499. return ret;
  500. }
  501. psy_cfg.drv_data = chg;
  502. chg->charger = power_supply_register(&pdev->dev, &max14577_charger_desc,
  503. &psy_cfg);
  504. if (IS_ERR(chg->charger)) {
  505. dev_err(&pdev->dev, "failed: power supply register\n");
  506. ret = PTR_ERR(chg->charger);
  507. goto err;
  508. }
  509. /* Check for valid values for charger */
  510. BUILD_BUG_ON(MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN +
  511. MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP * 0xf !=
  512. MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX);
  513. return 0;
  514. err:
  515. device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
  516. return ret;
  517. }
  518. static int max14577_charger_remove(struct platform_device *pdev)
  519. {
  520. struct max14577_charger *chg = platform_get_drvdata(pdev);
  521. device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
  522. power_supply_unregister(chg->charger);
  523. return 0;
  524. }
  525. static const struct platform_device_id max14577_charger_id[] = {
  526. { "max14577-charger", MAXIM_DEVICE_TYPE_MAX14577, },
  527. { "max77836-charger", MAXIM_DEVICE_TYPE_MAX77836, },
  528. { }
  529. };
  530. MODULE_DEVICE_TABLE(platform, max14577_charger_id);
  531. static const struct of_device_id of_max14577_charger_dt_match[] = {
  532. { .compatible = "maxim,max14577-charger",
  533. .data = (void *)MAXIM_DEVICE_TYPE_MAX14577, },
  534. { .compatible = "maxim,max77836-charger",
  535. .data = (void *)MAXIM_DEVICE_TYPE_MAX77836, },
  536. { },
  537. };
  538. MODULE_DEVICE_TABLE(of, of_max14577_charger_dt_match);
  539. static struct platform_driver max14577_charger_driver = {
  540. .driver = {
  541. .name = "max14577-charger",
  542. .of_match_table = of_max14577_charger_dt_match,
  543. },
  544. .probe = max14577_charger_probe,
  545. .remove = max14577_charger_remove,
  546. .id_table = max14577_charger_id,
  547. };
  548. module_platform_driver(max14577_charger_driver);
  549. MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
  550. MODULE_DESCRIPTION("Maxim 14577/77836 charger driver");
  551. MODULE_LICENSE("GPL");