qcom_smbb.c 25 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* Copyright (c) 2014, Sony Mobile Communications Inc.
  3. *
  4. * This driver is for the multi-block Switch-Mode Battery Charger and Boost
  5. * (SMBB) hardware, found in Qualcomm PM8941 PMICs. The charger is an
  6. * integrated, single-cell lithium-ion battery charger.
  7. *
  8. * Sub-components:
  9. * - Charger core
  10. * - Buck
  11. * - DC charge-path
  12. * - USB charge-path
  13. * - Battery interface
  14. * - Boost (not implemented)
  15. * - Misc
  16. * - HF-Buck
  17. */
  18. #include <linux/errno.h>
  19. #include <linux/interrupt.h>
  20. #include <linux/kernel.h>
  21. #include <linux/module.h>
  22. #include <linux/mutex.h>
  23. #include <linux/of.h>
  24. #include <linux/platform_device.h>
  25. #include <linux/power_supply.h>
  26. #include <linux/regmap.h>
  27. #include <linux/slab.h>
  28. #include <linux/extcon-provider.h>
  29. #include <linux/regulator/driver.h>
  30. #define SMBB_CHG_VMAX 0x040
  31. #define SMBB_CHG_VSAFE 0x041
  32. #define SMBB_CHG_CFG 0x043
  33. #define SMBB_CHG_IMAX 0x044
  34. #define SMBB_CHG_ISAFE 0x045
  35. #define SMBB_CHG_VIN_MIN 0x047
  36. #define SMBB_CHG_CTRL 0x049
  37. #define CTRL_EN BIT(7)
  38. #define SMBB_CHG_VBAT_WEAK 0x052
  39. #define SMBB_CHG_IBAT_TERM_CHG 0x05b
  40. #define IBAT_TERM_CHG_IEOC BIT(7)
  41. #define IBAT_TERM_CHG_IEOC_BMS BIT(7)
  42. #define IBAT_TERM_CHG_IEOC_CHG 0
  43. #define SMBB_CHG_VBAT_DET 0x05d
  44. #define SMBB_CHG_TCHG_MAX_EN 0x060
  45. #define TCHG_MAX_EN BIT(7)
  46. #define SMBB_CHG_WDOG_TIME 0x062
  47. #define SMBB_CHG_WDOG_EN 0x065
  48. #define WDOG_EN BIT(7)
  49. #define SMBB_BUCK_REG_MODE 0x174
  50. #define BUCK_REG_MODE BIT(0)
  51. #define BUCK_REG_MODE_VBAT BIT(0)
  52. #define BUCK_REG_MODE_VSYS 0
  53. #define SMBB_BAT_PRES_STATUS 0x208
  54. #define PRES_STATUS_BAT_PRES BIT(7)
  55. #define SMBB_BAT_TEMP_STATUS 0x209
  56. #define TEMP_STATUS_OK BIT(7)
  57. #define TEMP_STATUS_HOT BIT(6)
  58. #define SMBB_BAT_BTC_CTRL 0x249
  59. #define BTC_CTRL_COMP_EN BIT(7)
  60. #define BTC_CTRL_COLD_EXT BIT(1)
  61. #define BTC_CTRL_HOT_EXT_N BIT(0)
  62. #define SMBB_USB_IMAX 0x344
  63. #define SMBB_USB_OTG_CTL 0x348
  64. #define OTG_CTL_EN BIT(0)
  65. #define SMBB_USB_ENUM_TIMER_STOP 0x34e
  66. #define ENUM_TIMER_STOP BIT(0)
  67. #define SMBB_USB_SEC_ACCESS 0x3d0
  68. #define SEC_ACCESS_MAGIC 0xa5
  69. #define SMBB_USB_REV_BST 0x3ed
  70. #define REV_BST_CHG_GONE BIT(7)
  71. #define SMBB_DC_IMAX 0x444
  72. #define SMBB_MISC_REV2 0x601
  73. #define SMBB_MISC_BOOT_DONE 0x642
  74. #define BOOT_DONE BIT(7)
  75. #define STATUS_USBIN_VALID BIT(0) /* USB connection is valid */
  76. #define STATUS_DCIN_VALID BIT(1) /* DC connection is valid */
  77. #define STATUS_BAT_HOT BIT(2) /* Battery temp 1=Hot, 0=Cold */
  78. #define STATUS_BAT_OK BIT(3) /* Battery temp OK */
  79. #define STATUS_BAT_PRESENT BIT(4) /* Battery is present */
  80. #define STATUS_CHG_DONE BIT(5) /* Charge cycle is complete */
  81. #define STATUS_CHG_TRKL BIT(6) /* Trickle charging */
  82. #define STATUS_CHG_FAST BIT(7) /* Fast charging */
  83. #define STATUS_CHG_GONE BIT(8) /* No charger is connected */
  84. enum smbb_attr {
  85. ATTR_BAT_ISAFE,
  86. ATTR_BAT_IMAX,
  87. ATTR_USBIN_IMAX,
  88. ATTR_DCIN_IMAX,
  89. ATTR_BAT_VSAFE,
  90. ATTR_BAT_VMAX,
  91. ATTR_BAT_VMIN,
  92. ATTR_CHG_VDET,
  93. ATTR_VIN_MIN,
  94. _ATTR_CNT,
  95. };
  96. struct smbb_charger {
  97. unsigned int revision;
  98. unsigned int addr;
  99. struct device *dev;
  100. struct extcon_dev *edev;
  101. bool dc_disabled;
  102. bool jeita_ext_temp;
  103. unsigned long status;
  104. struct mutex statlock;
  105. unsigned int attr[_ATTR_CNT];
  106. struct power_supply *usb_psy;
  107. struct power_supply *dc_psy;
  108. struct power_supply *bat_psy;
  109. struct regmap *regmap;
  110. struct regulator_desc otg_rdesc;
  111. struct regulator_dev *otg_reg;
  112. };
  113. static const unsigned int smbb_usb_extcon_cable[] = {
  114. EXTCON_USB,
  115. EXTCON_NONE,
  116. };
  117. static int smbb_vbat_weak_fn(unsigned int index)
  118. {
  119. return 2100000 + index * 100000;
  120. }
  121. static int smbb_vin_fn(unsigned int index)
  122. {
  123. if (index > 42)
  124. return 5600000 + (index - 43) * 200000;
  125. return 3400000 + index * 50000;
  126. }
  127. static int smbb_vmax_fn(unsigned int index)
  128. {
  129. return 3240000 + index * 10000;
  130. }
  131. static int smbb_vbat_det_fn(unsigned int index)
  132. {
  133. return 3240000 + index * 20000;
  134. }
  135. static int smbb_imax_fn(unsigned int index)
  136. {
  137. if (index < 2)
  138. return 100000 + index * 50000;
  139. return index * 100000;
  140. }
  141. static int smbb_bat_imax_fn(unsigned int index)
  142. {
  143. return index * 50000;
  144. }
  145. static unsigned int smbb_hw_lookup(unsigned int val, int (*fn)(unsigned int))
  146. {
  147. unsigned int widx;
  148. unsigned int sel;
  149. for (widx = sel = 0; (*fn)(widx) <= val; ++widx)
  150. sel = widx;
  151. return sel;
  152. }
  153. static const struct smbb_charger_attr {
  154. const char *name;
  155. unsigned int reg;
  156. unsigned int safe_reg;
  157. unsigned int max;
  158. unsigned int min;
  159. unsigned int fail_ok;
  160. int (*hw_fn)(unsigned int);
  161. } smbb_charger_attrs[] = {
  162. [ATTR_BAT_ISAFE] = {
  163. .name = "qcom,fast-charge-safe-current",
  164. .reg = SMBB_CHG_ISAFE,
  165. .max = 3000000,
  166. .min = 200000,
  167. .hw_fn = smbb_bat_imax_fn,
  168. .fail_ok = 1,
  169. },
  170. [ATTR_BAT_IMAX] = {
  171. .name = "qcom,fast-charge-current-limit",
  172. .reg = SMBB_CHG_IMAX,
  173. .safe_reg = SMBB_CHG_ISAFE,
  174. .max = 3000000,
  175. .min = 200000,
  176. .hw_fn = smbb_bat_imax_fn,
  177. },
  178. [ATTR_DCIN_IMAX] = {
  179. .name = "qcom,dc-current-limit",
  180. .reg = SMBB_DC_IMAX,
  181. .max = 2500000,
  182. .min = 100000,
  183. .hw_fn = smbb_imax_fn,
  184. },
  185. [ATTR_BAT_VSAFE] = {
  186. .name = "qcom,fast-charge-safe-voltage",
  187. .reg = SMBB_CHG_VSAFE,
  188. .max = 5000000,
  189. .min = 3240000,
  190. .hw_fn = smbb_vmax_fn,
  191. .fail_ok = 1,
  192. },
  193. [ATTR_BAT_VMAX] = {
  194. .name = "qcom,fast-charge-high-threshold-voltage",
  195. .reg = SMBB_CHG_VMAX,
  196. .safe_reg = SMBB_CHG_VSAFE,
  197. .max = 5000000,
  198. .min = 3240000,
  199. .hw_fn = smbb_vmax_fn,
  200. },
  201. [ATTR_BAT_VMIN] = {
  202. .name = "qcom,fast-charge-low-threshold-voltage",
  203. .reg = SMBB_CHG_VBAT_WEAK,
  204. .max = 3600000,
  205. .min = 2100000,
  206. .hw_fn = smbb_vbat_weak_fn,
  207. },
  208. [ATTR_CHG_VDET] = {
  209. .name = "qcom,auto-recharge-threshold-voltage",
  210. .reg = SMBB_CHG_VBAT_DET,
  211. .max = 5000000,
  212. .min = 3240000,
  213. .hw_fn = smbb_vbat_det_fn,
  214. },
  215. [ATTR_VIN_MIN] = {
  216. .name = "qcom,minimum-input-voltage",
  217. .reg = SMBB_CHG_VIN_MIN,
  218. .max = 9600000,
  219. .min = 4200000,
  220. .hw_fn = smbb_vin_fn,
  221. },
  222. [ATTR_USBIN_IMAX] = {
  223. .name = "usb-charge-current-limit",
  224. .reg = SMBB_USB_IMAX,
  225. .max = 2500000,
  226. .min = 100000,
  227. .hw_fn = smbb_imax_fn,
  228. },
  229. };
  230. static int smbb_charger_attr_write(struct smbb_charger *chg,
  231. enum smbb_attr which, unsigned int val)
  232. {
  233. const struct smbb_charger_attr *prop;
  234. unsigned int wval;
  235. unsigned int out;
  236. int rc;
  237. prop = &smbb_charger_attrs[which];
  238. if (val > prop->max || val < prop->min) {
  239. dev_err(chg->dev, "value out of range for %s [%u:%u]\n",
  240. prop->name, prop->min, prop->max);
  241. return -EINVAL;
  242. }
  243. if (prop->safe_reg) {
  244. rc = regmap_read(chg->regmap,
  245. chg->addr + prop->safe_reg, &wval);
  246. if (rc) {
  247. dev_err(chg->dev,
  248. "unable to read safe value for '%s'\n",
  249. prop->name);
  250. return rc;
  251. }
  252. wval = prop->hw_fn(wval);
  253. if (val > wval) {
  254. dev_warn(chg->dev,
  255. "%s above safe value, clamping at %u\n",
  256. prop->name, wval);
  257. val = wval;
  258. }
  259. }
  260. wval = smbb_hw_lookup(val, prop->hw_fn);
  261. rc = regmap_write(chg->regmap, chg->addr + prop->reg, wval);
  262. if (rc) {
  263. dev_err(chg->dev, "unable to update %s", prop->name);
  264. return rc;
  265. }
  266. out = prop->hw_fn(wval);
  267. if (out != val) {
  268. dev_warn(chg->dev,
  269. "%s inaccurate, rounded to %u\n",
  270. prop->name, out);
  271. }
  272. dev_dbg(chg->dev, "%s <= %d\n", prop->name, out);
  273. chg->attr[which] = out;
  274. return 0;
  275. }
  276. static int smbb_charger_attr_read(struct smbb_charger *chg,
  277. enum smbb_attr which)
  278. {
  279. const struct smbb_charger_attr *prop;
  280. unsigned int val;
  281. int rc;
  282. prop = &smbb_charger_attrs[which];
  283. rc = regmap_read(chg->regmap, chg->addr + prop->reg, &val);
  284. if (rc) {
  285. dev_err(chg->dev, "failed to read %s\n", prop->name);
  286. return rc;
  287. }
  288. val = prop->hw_fn(val);
  289. dev_dbg(chg->dev, "%s => %d\n", prop->name, val);
  290. chg->attr[which] = val;
  291. return 0;
  292. }
  293. static int smbb_charger_attr_parse(struct smbb_charger *chg,
  294. enum smbb_attr which)
  295. {
  296. const struct smbb_charger_attr *prop;
  297. unsigned int val;
  298. int rc;
  299. prop = &smbb_charger_attrs[which];
  300. rc = of_property_read_u32(chg->dev->of_node, prop->name, &val);
  301. if (rc == 0) {
  302. rc = smbb_charger_attr_write(chg, which, val);
  303. if (!rc || !prop->fail_ok)
  304. return rc;
  305. }
  306. return smbb_charger_attr_read(chg, which);
  307. }
  308. static void smbb_set_line_flag(struct smbb_charger *chg, int irq, int flag)
  309. {
  310. bool state;
  311. int ret;
  312. ret = irq_get_irqchip_state(irq, IRQCHIP_STATE_LINE_LEVEL, &state);
  313. if (ret < 0) {
  314. dev_err(chg->dev, "failed to read irq line\n");
  315. return;
  316. }
  317. mutex_lock(&chg->statlock);
  318. if (state)
  319. chg->status |= flag;
  320. else
  321. chg->status &= ~flag;
  322. mutex_unlock(&chg->statlock);
  323. dev_dbg(chg->dev, "status = %03lx\n", chg->status);
  324. }
  325. static irqreturn_t smbb_usb_valid_handler(int irq, void *_data)
  326. {
  327. struct smbb_charger *chg = _data;
  328. smbb_set_line_flag(chg, irq, STATUS_USBIN_VALID);
  329. extcon_set_state_sync(chg->edev, EXTCON_USB,
  330. chg->status & STATUS_USBIN_VALID);
  331. power_supply_changed(chg->usb_psy);
  332. return IRQ_HANDLED;
  333. }
  334. static irqreturn_t smbb_dc_valid_handler(int irq, void *_data)
  335. {
  336. struct smbb_charger *chg = _data;
  337. smbb_set_line_flag(chg, irq, STATUS_DCIN_VALID);
  338. if (!chg->dc_disabled)
  339. power_supply_changed(chg->dc_psy);
  340. return IRQ_HANDLED;
  341. }
  342. static irqreturn_t smbb_bat_temp_handler(int irq, void *_data)
  343. {
  344. struct smbb_charger *chg = _data;
  345. unsigned int val;
  346. int rc;
  347. rc = regmap_read(chg->regmap, chg->addr + SMBB_BAT_TEMP_STATUS, &val);
  348. if (rc)
  349. return IRQ_HANDLED;
  350. mutex_lock(&chg->statlock);
  351. if (val & TEMP_STATUS_OK) {
  352. chg->status |= STATUS_BAT_OK;
  353. } else {
  354. chg->status &= ~STATUS_BAT_OK;
  355. if (val & TEMP_STATUS_HOT)
  356. chg->status |= STATUS_BAT_HOT;
  357. }
  358. mutex_unlock(&chg->statlock);
  359. power_supply_changed(chg->bat_psy);
  360. return IRQ_HANDLED;
  361. }
  362. static irqreturn_t smbb_bat_present_handler(int irq, void *_data)
  363. {
  364. struct smbb_charger *chg = _data;
  365. smbb_set_line_flag(chg, irq, STATUS_BAT_PRESENT);
  366. power_supply_changed(chg->bat_psy);
  367. return IRQ_HANDLED;
  368. }
  369. static irqreturn_t smbb_chg_done_handler(int irq, void *_data)
  370. {
  371. struct smbb_charger *chg = _data;
  372. smbb_set_line_flag(chg, irq, STATUS_CHG_DONE);
  373. power_supply_changed(chg->bat_psy);
  374. return IRQ_HANDLED;
  375. }
  376. static irqreturn_t smbb_chg_gone_handler(int irq, void *_data)
  377. {
  378. struct smbb_charger *chg = _data;
  379. smbb_set_line_flag(chg, irq, STATUS_CHG_GONE);
  380. power_supply_changed(chg->bat_psy);
  381. power_supply_changed(chg->usb_psy);
  382. if (!chg->dc_disabled)
  383. power_supply_changed(chg->dc_psy);
  384. return IRQ_HANDLED;
  385. }
  386. static irqreturn_t smbb_chg_fast_handler(int irq, void *_data)
  387. {
  388. struct smbb_charger *chg = _data;
  389. smbb_set_line_flag(chg, irq, STATUS_CHG_FAST);
  390. power_supply_changed(chg->bat_psy);
  391. return IRQ_HANDLED;
  392. }
  393. static irqreturn_t smbb_chg_trkl_handler(int irq, void *_data)
  394. {
  395. struct smbb_charger *chg = _data;
  396. smbb_set_line_flag(chg, irq, STATUS_CHG_TRKL);
  397. power_supply_changed(chg->bat_psy);
  398. return IRQ_HANDLED;
  399. }
  400. static const struct smbb_irq {
  401. const char *name;
  402. irqreturn_t (*handler)(int, void *);
  403. } smbb_charger_irqs[] = {
  404. { "chg-done", smbb_chg_done_handler },
  405. { "chg-fast", smbb_chg_fast_handler },
  406. { "chg-trkl", smbb_chg_trkl_handler },
  407. { "bat-temp-ok", smbb_bat_temp_handler },
  408. { "bat-present", smbb_bat_present_handler },
  409. { "chg-gone", smbb_chg_gone_handler },
  410. { "usb-valid", smbb_usb_valid_handler },
  411. { "dc-valid", smbb_dc_valid_handler },
  412. };
  413. static int smbb_usbin_get_property(struct power_supply *psy,
  414. enum power_supply_property psp,
  415. union power_supply_propval *val)
  416. {
  417. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  418. int rc = 0;
  419. switch (psp) {
  420. case POWER_SUPPLY_PROP_ONLINE:
  421. mutex_lock(&chg->statlock);
  422. val->intval = !(chg->status & STATUS_CHG_GONE) &&
  423. (chg->status & STATUS_USBIN_VALID);
  424. mutex_unlock(&chg->statlock);
  425. break;
  426. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
  427. val->intval = chg->attr[ATTR_USBIN_IMAX];
  428. break;
  429. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
  430. val->intval = 2500000;
  431. break;
  432. default:
  433. rc = -EINVAL;
  434. break;
  435. }
  436. return rc;
  437. }
  438. static int smbb_usbin_set_property(struct power_supply *psy,
  439. enum power_supply_property psp,
  440. const union power_supply_propval *val)
  441. {
  442. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  443. int rc;
  444. switch (psp) {
  445. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
  446. rc = smbb_charger_attr_write(chg, ATTR_USBIN_IMAX,
  447. val->intval);
  448. break;
  449. default:
  450. rc = -EINVAL;
  451. break;
  452. }
  453. return rc;
  454. }
  455. static int smbb_dcin_get_property(struct power_supply *psy,
  456. enum power_supply_property psp,
  457. union power_supply_propval *val)
  458. {
  459. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  460. int rc = 0;
  461. switch (psp) {
  462. case POWER_SUPPLY_PROP_ONLINE:
  463. mutex_lock(&chg->statlock);
  464. val->intval = !(chg->status & STATUS_CHG_GONE) &&
  465. (chg->status & STATUS_DCIN_VALID);
  466. mutex_unlock(&chg->statlock);
  467. break;
  468. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
  469. val->intval = chg->attr[ATTR_DCIN_IMAX];
  470. break;
  471. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
  472. val->intval = 2500000;
  473. break;
  474. default:
  475. rc = -EINVAL;
  476. break;
  477. }
  478. return rc;
  479. }
  480. static int smbb_dcin_set_property(struct power_supply *psy,
  481. enum power_supply_property psp,
  482. const union power_supply_propval *val)
  483. {
  484. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  485. int rc;
  486. switch (psp) {
  487. case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
  488. rc = smbb_charger_attr_write(chg, ATTR_DCIN_IMAX,
  489. val->intval);
  490. break;
  491. default:
  492. rc = -EINVAL;
  493. break;
  494. }
  495. return rc;
  496. }
  497. static int smbb_charger_writable_property(struct power_supply *psy,
  498. enum power_supply_property psp)
  499. {
  500. return psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT;
  501. }
  502. static int smbb_battery_get_property(struct power_supply *psy,
  503. enum power_supply_property psp,
  504. union power_supply_propval *val)
  505. {
  506. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  507. unsigned long status;
  508. int rc = 0;
  509. mutex_lock(&chg->statlock);
  510. status = chg->status;
  511. mutex_unlock(&chg->statlock);
  512. switch (psp) {
  513. case POWER_SUPPLY_PROP_STATUS:
  514. if (status & STATUS_CHG_GONE)
  515. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  516. else if (!(status & (STATUS_DCIN_VALID | STATUS_USBIN_VALID)))
  517. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  518. else if (status & STATUS_CHG_DONE)
  519. val->intval = POWER_SUPPLY_STATUS_FULL;
  520. else if (!(status & STATUS_BAT_OK))
  521. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  522. else if (status & (STATUS_CHG_FAST | STATUS_CHG_TRKL))
  523. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  524. else /* everything is ok for charging, but we are not... */
  525. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  526. break;
  527. case POWER_SUPPLY_PROP_HEALTH:
  528. if (status & STATUS_BAT_OK)
  529. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  530. else if (status & STATUS_BAT_HOT)
  531. val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
  532. else
  533. val->intval = POWER_SUPPLY_HEALTH_COLD;
  534. break;
  535. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  536. if (status & STATUS_CHG_FAST)
  537. val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
  538. else if (status & STATUS_CHG_TRKL)
  539. val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  540. else
  541. val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
  542. break;
  543. case POWER_SUPPLY_PROP_PRESENT:
  544. val->intval = !!(status & STATUS_BAT_PRESENT);
  545. break;
  546. case POWER_SUPPLY_PROP_CURRENT_MAX:
  547. val->intval = chg->attr[ATTR_BAT_IMAX];
  548. break;
  549. case POWER_SUPPLY_PROP_VOLTAGE_MAX:
  550. val->intval = chg->attr[ATTR_BAT_VMAX];
  551. break;
  552. case POWER_SUPPLY_PROP_TECHNOLOGY:
  553. /* this charger is a single-cell lithium-ion battery charger
  554. * only. If you hook up some other technology, there will be
  555. * fireworks.
  556. */
  557. val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
  558. break;
  559. case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
  560. val->intval = 3000000; /* single-cell li-ion low end */
  561. break;
  562. default:
  563. rc = -EINVAL;
  564. break;
  565. }
  566. return rc;
  567. }
  568. static int smbb_battery_set_property(struct power_supply *psy,
  569. enum power_supply_property psp,
  570. const union power_supply_propval *val)
  571. {
  572. struct smbb_charger *chg = power_supply_get_drvdata(psy);
  573. int rc;
  574. switch (psp) {
  575. case POWER_SUPPLY_PROP_CURRENT_MAX:
  576. rc = smbb_charger_attr_write(chg, ATTR_BAT_IMAX, val->intval);
  577. break;
  578. case POWER_SUPPLY_PROP_VOLTAGE_MAX:
  579. rc = smbb_charger_attr_write(chg, ATTR_BAT_VMAX, val->intval);
  580. break;
  581. default:
  582. rc = -EINVAL;
  583. break;
  584. }
  585. return rc;
  586. }
  587. static int smbb_battery_writable_property(struct power_supply *psy,
  588. enum power_supply_property psp)
  589. {
  590. switch (psp) {
  591. case POWER_SUPPLY_PROP_CURRENT_MAX:
  592. case POWER_SUPPLY_PROP_VOLTAGE_MAX:
  593. return 1;
  594. default:
  595. return 0;
  596. }
  597. }
  598. static enum power_supply_property smbb_charger_properties[] = {
  599. POWER_SUPPLY_PROP_ONLINE,
  600. POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
  601. POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
  602. };
  603. static enum power_supply_property smbb_battery_properties[] = {
  604. POWER_SUPPLY_PROP_STATUS,
  605. POWER_SUPPLY_PROP_HEALTH,
  606. POWER_SUPPLY_PROP_PRESENT,
  607. POWER_SUPPLY_PROP_CHARGE_TYPE,
  608. POWER_SUPPLY_PROP_CURRENT_MAX,
  609. POWER_SUPPLY_PROP_VOLTAGE_MAX,
  610. POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  611. POWER_SUPPLY_PROP_TECHNOLOGY,
  612. };
  613. static const struct reg_off_mask_default {
  614. unsigned int offset;
  615. unsigned int mask;
  616. unsigned int value;
  617. unsigned int rev_mask;
  618. } smbb_charger_setup[] = {
  619. /* The bootloader is supposed to set this... make sure anyway. */
  620. { SMBB_MISC_BOOT_DONE, BOOT_DONE, BOOT_DONE },
  621. /* Disable software timer */
  622. { SMBB_CHG_TCHG_MAX_EN, TCHG_MAX_EN, 0 },
  623. /* Clear and disable watchdog */
  624. { SMBB_CHG_WDOG_TIME, 0xff, 160 },
  625. { SMBB_CHG_WDOG_EN, WDOG_EN, 0 },
  626. /* Use charger based EoC detection */
  627. { SMBB_CHG_IBAT_TERM_CHG, IBAT_TERM_CHG_IEOC, IBAT_TERM_CHG_IEOC_CHG },
  628. /* Disable GSM PA load adjustment.
  629. * The PA signal is incorrectly connected on v2.
  630. */
  631. { SMBB_CHG_CFG, 0xff, 0x00, BIT(3) },
  632. /* Use VBAT (not VSYS) to compensate for IR drop during fast charging */
  633. { SMBB_BUCK_REG_MODE, BUCK_REG_MODE, BUCK_REG_MODE_VBAT },
  634. /* Enable battery temperature comparators */
  635. { SMBB_BAT_BTC_CTRL, BTC_CTRL_COMP_EN, BTC_CTRL_COMP_EN },
  636. /* Stop USB enumeration timer */
  637. { SMBB_USB_ENUM_TIMER_STOP, ENUM_TIMER_STOP, ENUM_TIMER_STOP },
  638. #if 0 /* FIXME supposedly only to disable hardware ARB termination */
  639. { SMBB_USB_SEC_ACCESS, SEC_ACCESS_MAGIC },
  640. { SMBB_USB_REV_BST, 0xff, REV_BST_CHG_GONE },
  641. #endif
  642. /* Stop USB enumeration timer, again */
  643. { SMBB_USB_ENUM_TIMER_STOP, ENUM_TIMER_STOP, ENUM_TIMER_STOP },
  644. /* Enable charging */
  645. { SMBB_CHG_CTRL, CTRL_EN, CTRL_EN },
  646. };
  647. static char *smbb_bif[] = { "smbb-bif" };
  648. static const struct power_supply_desc bat_psy_desc = {
  649. .name = "smbb-bif",
  650. .type = POWER_SUPPLY_TYPE_BATTERY,
  651. .properties = smbb_battery_properties,
  652. .num_properties = ARRAY_SIZE(smbb_battery_properties),
  653. .get_property = smbb_battery_get_property,
  654. .set_property = smbb_battery_set_property,
  655. .property_is_writeable = smbb_battery_writable_property,
  656. };
  657. static const struct power_supply_desc usb_psy_desc = {
  658. .name = "smbb-usbin",
  659. .type = POWER_SUPPLY_TYPE_USB,
  660. .properties = smbb_charger_properties,
  661. .num_properties = ARRAY_SIZE(smbb_charger_properties),
  662. .get_property = smbb_usbin_get_property,
  663. .set_property = smbb_usbin_set_property,
  664. .property_is_writeable = smbb_charger_writable_property,
  665. };
  666. static const struct power_supply_desc dc_psy_desc = {
  667. .name = "smbb-dcin",
  668. .type = POWER_SUPPLY_TYPE_MAINS,
  669. .properties = smbb_charger_properties,
  670. .num_properties = ARRAY_SIZE(smbb_charger_properties),
  671. .get_property = smbb_dcin_get_property,
  672. .set_property = smbb_dcin_set_property,
  673. .property_is_writeable = smbb_charger_writable_property,
  674. };
  675. static int smbb_chg_otg_enable(struct regulator_dev *rdev)
  676. {
  677. struct smbb_charger *chg = rdev_get_drvdata(rdev);
  678. int rc;
  679. rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_USB_OTG_CTL,
  680. OTG_CTL_EN, OTG_CTL_EN);
  681. if (rc)
  682. dev_err(chg->dev, "failed to update OTG_CTL\n");
  683. return rc;
  684. }
  685. static int smbb_chg_otg_disable(struct regulator_dev *rdev)
  686. {
  687. struct smbb_charger *chg = rdev_get_drvdata(rdev);
  688. int rc;
  689. rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_USB_OTG_CTL,
  690. OTG_CTL_EN, 0);
  691. if (rc)
  692. dev_err(chg->dev, "failed to update OTG_CTL\n");
  693. return rc;
  694. }
  695. static int smbb_chg_otg_is_enabled(struct regulator_dev *rdev)
  696. {
  697. struct smbb_charger *chg = rdev_get_drvdata(rdev);
  698. unsigned int value = 0;
  699. int rc;
  700. rc = regmap_read(chg->regmap, chg->addr + SMBB_USB_OTG_CTL, &value);
  701. if (rc)
  702. dev_err(chg->dev, "failed to read OTG_CTL\n");
  703. return !!(value & OTG_CTL_EN);
  704. }
  705. static const struct regulator_ops smbb_chg_otg_ops = {
  706. .enable = smbb_chg_otg_enable,
  707. .disable = smbb_chg_otg_disable,
  708. .is_enabled = smbb_chg_otg_is_enabled,
  709. };
  710. static int smbb_charger_probe(struct platform_device *pdev)
  711. {
  712. struct power_supply_config bat_cfg = {};
  713. struct power_supply_config usb_cfg = {};
  714. struct power_supply_config dc_cfg = {};
  715. struct smbb_charger *chg;
  716. struct regulator_config config = { };
  717. int rc, i;
  718. chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
  719. if (!chg)
  720. return -ENOMEM;
  721. chg->dev = &pdev->dev;
  722. mutex_init(&chg->statlock);
  723. chg->regmap = dev_get_regmap(pdev->dev.parent, NULL);
  724. if (!chg->regmap) {
  725. dev_err(&pdev->dev, "failed to locate regmap\n");
  726. return -ENODEV;
  727. }
  728. rc = of_property_read_u32(pdev->dev.of_node, "reg", &chg->addr);
  729. if (rc) {
  730. dev_err(&pdev->dev, "missing or invalid 'reg' property\n");
  731. return rc;
  732. }
  733. rc = regmap_read(chg->regmap, chg->addr + SMBB_MISC_REV2, &chg->revision);
  734. if (rc) {
  735. dev_err(&pdev->dev, "unable to read revision\n");
  736. return rc;
  737. }
  738. chg->revision += 1;
  739. if (chg->revision != 2 && chg->revision != 3) {
  740. dev_err(&pdev->dev, "v1 hardware not supported\n");
  741. return -ENODEV;
  742. }
  743. dev_info(&pdev->dev, "Initializing SMBB rev %u", chg->revision);
  744. chg->dc_disabled = of_property_read_bool(pdev->dev.of_node, "qcom,disable-dc");
  745. for (i = 0; i < _ATTR_CNT; ++i) {
  746. rc = smbb_charger_attr_parse(chg, i);
  747. if (rc) {
  748. dev_err(&pdev->dev, "failed to parse/apply settings\n");
  749. return rc;
  750. }
  751. }
  752. bat_cfg.drv_data = chg;
  753. bat_cfg.of_node = pdev->dev.of_node;
  754. chg->bat_psy = devm_power_supply_register(&pdev->dev,
  755. &bat_psy_desc,
  756. &bat_cfg);
  757. if (IS_ERR(chg->bat_psy)) {
  758. dev_err(&pdev->dev, "failed to register battery\n");
  759. return PTR_ERR(chg->bat_psy);
  760. }
  761. usb_cfg.drv_data = chg;
  762. usb_cfg.supplied_to = smbb_bif;
  763. usb_cfg.num_supplicants = ARRAY_SIZE(smbb_bif);
  764. chg->usb_psy = devm_power_supply_register(&pdev->dev,
  765. &usb_psy_desc,
  766. &usb_cfg);
  767. if (IS_ERR(chg->usb_psy)) {
  768. dev_err(&pdev->dev, "failed to register USB power supply\n");
  769. return PTR_ERR(chg->usb_psy);
  770. }
  771. chg->edev = devm_extcon_dev_allocate(&pdev->dev, smbb_usb_extcon_cable);
  772. if (IS_ERR(chg->edev)) {
  773. dev_err(&pdev->dev, "failed to allocate extcon device\n");
  774. return -ENOMEM;
  775. }
  776. rc = devm_extcon_dev_register(&pdev->dev, chg->edev);
  777. if (rc < 0) {
  778. dev_err(&pdev->dev, "failed to register extcon device\n");
  779. return rc;
  780. }
  781. if (!chg->dc_disabled) {
  782. dc_cfg.drv_data = chg;
  783. dc_cfg.supplied_to = smbb_bif;
  784. dc_cfg.num_supplicants = ARRAY_SIZE(smbb_bif);
  785. chg->dc_psy = devm_power_supply_register(&pdev->dev,
  786. &dc_psy_desc,
  787. &dc_cfg);
  788. if (IS_ERR(chg->dc_psy)) {
  789. dev_err(&pdev->dev, "failed to register DC power supply\n");
  790. return PTR_ERR(chg->dc_psy);
  791. }
  792. }
  793. for (i = 0; i < ARRAY_SIZE(smbb_charger_irqs); ++i) {
  794. int irq;
  795. irq = platform_get_irq_byname(pdev, smbb_charger_irqs[i].name);
  796. if (irq < 0) {
  797. dev_err(&pdev->dev, "failed to get irq '%s'\n",
  798. smbb_charger_irqs[i].name);
  799. return irq;
  800. }
  801. smbb_charger_irqs[i].handler(irq, chg);
  802. rc = devm_request_threaded_irq(&pdev->dev, irq, NULL,
  803. smbb_charger_irqs[i].handler, IRQF_ONESHOT,
  804. smbb_charger_irqs[i].name, chg);
  805. if (rc) {
  806. dev_err(&pdev->dev, "failed to request irq '%s'\n",
  807. smbb_charger_irqs[i].name);
  808. return rc;
  809. }
  810. }
  811. /*
  812. * otg regulator is used to control VBUS voltage direction
  813. * when USB switches between host and gadget mode
  814. */
  815. chg->otg_rdesc.id = -1;
  816. chg->otg_rdesc.name = "otg-vbus";
  817. chg->otg_rdesc.ops = &smbb_chg_otg_ops;
  818. chg->otg_rdesc.owner = THIS_MODULE;
  819. chg->otg_rdesc.type = REGULATOR_VOLTAGE;
  820. chg->otg_rdesc.supply_name = "usb-otg-in";
  821. chg->otg_rdesc.of_match = "otg-vbus";
  822. config.dev = &pdev->dev;
  823. config.driver_data = chg;
  824. chg->otg_reg = devm_regulator_register(&pdev->dev, &chg->otg_rdesc,
  825. &config);
  826. if (IS_ERR(chg->otg_reg))
  827. return PTR_ERR(chg->otg_reg);
  828. chg->jeita_ext_temp = of_property_read_bool(pdev->dev.of_node,
  829. "qcom,jeita-extended-temp-range");
  830. /* Set temperature range to [35%:70%] or [25%:80%] accordingly */
  831. rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_BAT_BTC_CTRL,
  832. BTC_CTRL_COLD_EXT | BTC_CTRL_HOT_EXT_N,
  833. chg->jeita_ext_temp ?
  834. BTC_CTRL_COLD_EXT :
  835. BTC_CTRL_HOT_EXT_N);
  836. if (rc) {
  837. dev_err(&pdev->dev,
  838. "unable to set %s temperature range\n",
  839. chg->jeita_ext_temp ? "JEITA extended" : "normal");
  840. return rc;
  841. }
  842. for (i = 0; i < ARRAY_SIZE(smbb_charger_setup); ++i) {
  843. const struct reg_off_mask_default *r = &smbb_charger_setup[i];
  844. if (r->rev_mask & BIT(chg->revision))
  845. continue;
  846. rc = regmap_update_bits(chg->regmap, chg->addr + r->offset,
  847. r->mask, r->value);
  848. if (rc) {
  849. dev_err(&pdev->dev,
  850. "unable to initializing charging, bailing\n");
  851. return rc;
  852. }
  853. }
  854. platform_set_drvdata(pdev, chg);
  855. return 0;
  856. }
  857. static int smbb_charger_remove(struct platform_device *pdev)
  858. {
  859. struct smbb_charger *chg;
  860. chg = platform_get_drvdata(pdev);
  861. regmap_update_bits(chg->regmap, chg->addr + SMBB_CHG_CTRL, CTRL_EN, 0);
  862. return 0;
  863. }
  864. static const struct of_device_id smbb_charger_id_table[] = {
  865. { .compatible = "qcom,pm8941-charger" },
  866. { }
  867. };
  868. MODULE_DEVICE_TABLE(of, smbb_charger_id_table);
  869. static struct platform_driver smbb_charger_driver = {
  870. .probe = smbb_charger_probe,
  871. .remove = smbb_charger_remove,
  872. .driver = {
  873. .name = "qcom-smbb",
  874. .of_match_table = smbb_charger_id_table,
  875. },
  876. };
  877. module_platform_driver(smbb_charger_driver);
  878. MODULE_DESCRIPTION("Qualcomm Switch-Mode Battery Charger and Boost driver");
  879. MODULE_LICENSE("GPL v2");