sbs-charger.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (c) 2016, Prodys S.L.
  4. *
  5. * This adds support for sbs-charger compilant chips as defined here:
  6. * http://sbs-forum.org/specs/sbc110.pdf
  7. *
  8. * Implemetation based on sbs-battery.c
  9. */
  10. #include <linux/init.h>
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/err.h>
  14. #include <linux/power_supply.h>
  15. #include <linux/i2c.h>
  16. #include <linux/slab.h>
  17. #include <linux/interrupt.h>
  18. #include <linux/gpio.h>
  19. #include <linux/regmap.h>
  20. #include <linux/of_gpio.h>
  21. #include <linux/bitops.h>
  22. #define SBS_CHARGER_REG_SPEC_INFO 0x11
  23. #define SBS_CHARGER_REG_STATUS 0x13
  24. #define SBS_CHARGER_REG_ALARM_WARNING 0x16
  25. #define SBS_CHARGER_STATUS_CHARGE_INHIBITED BIT(1)
  26. #define SBS_CHARGER_STATUS_RES_COLD BIT(9)
  27. #define SBS_CHARGER_STATUS_RES_HOT BIT(10)
  28. #define SBS_CHARGER_STATUS_BATTERY_PRESENT BIT(14)
  29. #define SBS_CHARGER_STATUS_AC_PRESENT BIT(15)
  30. #define SBS_CHARGER_POLL_TIME 500
  31. struct sbs_info {
  32. struct i2c_client *client;
  33. struct power_supply *power_supply;
  34. struct regmap *regmap;
  35. struct delayed_work work;
  36. unsigned int last_state;
  37. };
  38. static int sbs_get_property(struct power_supply *psy,
  39. enum power_supply_property psp,
  40. union power_supply_propval *val)
  41. {
  42. struct sbs_info *chip = power_supply_get_drvdata(psy);
  43. unsigned int reg;
  44. reg = chip->last_state;
  45. switch (psp) {
  46. case POWER_SUPPLY_PROP_PRESENT:
  47. val->intval = !!(reg & SBS_CHARGER_STATUS_BATTERY_PRESENT);
  48. break;
  49. case POWER_SUPPLY_PROP_ONLINE:
  50. val->intval = !!(reg & SBS_CHARGER_STATUS_AC_PRESENT);
  51. break;
  52. case POWER_SUPPLY_PROP_STATUS:
  53. val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
  54. if (!(reg & SBS_CHARGER_STATUS_BATTERY_PRESENT))
  55. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  56. else if (reg & SBS_CHARGER_STATUS_AC_PRESENT &&
  57. !(reg & SBS_CHARGER_STATUS_CHARGE_INHIBITED))
  58. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  59. else
  60. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  61. break;
  62. case POWER_SUPPLY_PROP_HEALTH:
  63. if (reg & SBS_CHARGER_STATUS_RES_COLD)
  64. val->intval = POWER_SUPPLY_HEALTH_COLD;
  65. if (reg & SBS_CHARGER_STATUS_RES_HOT)
  66. val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
  67. else
  68. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  69. break;
  70. default:
  71. return -EINVAL;
  72. }
  73. return 0;
  74. }
  75. static int sbs_check_state(struct sbs_info *chip)
  76. {
  77. unsigned int reg;
  78. int ret;
  79. ret = regmap_read(chip->regmap, SBS_CHARGER_REG_STATUS, &reg);
  80. if (!ret && reg != chip->last_state) {
  81. chip->last_state = reg;
  82. power_supply_changed(chip->power_supply);
  83. return 1;
  84. }
  85. return 0;
  86. }
  87. static void sbs_delayed_work(struct work_struct *work)
  88. {
  89. struct sbs_info *chip = container_of(work, struct sbs_info, work.work);
  90. sbs_check_state(chip);
  91. schedule_delayed_work(&chip->work,
  92. msecs_to_jiffies(SBS_CHARGER_POLL_TIME));
  93. }
  94. static irqreturn_t sbs_irq_thread(int irq, void *data)
  95. {
  96. struct sbs_info *chip = data;
  97. int ret;
  98. ret = sbs_check_state(chip);
  99. return ret ? IRQ_HANDLED : IRQ_NONE;
  100. }
  101. static enum power_supply_property sbs_properties[] = {
  102. POWER_SUPPLY_PROP_STATUS,
  103. POWER_SUPPLY_PROP_PRESENT,
  104. POWER_SUPPLY_PROP_ONLINE,
  105. POWER_SUPPLY_PROP_HEALTH,
  106. };
  107. static bool sbs_readable_reg(struct device *dev, unsigned int reg)
  108. {
  109. return reg >= SBS_CHARGER_REG_SPEC_INFO;
  110. }
  111. static bool sbs_volatile_reg(struct device *dev, unsigned int reg)
  112. {
  113. switch (reg) {
  114. case SBS_CHARGER_REG_STATUS:
  115. return true;
  116. }
  117. return false;
  118. }
  119. static const struct regmap_config sbs_regmap = {
  120. .reg_bits = 8,
  121. .val_bits = 16,
  122. .max_register = SBS_CHARGER_REG_ALARM_WARNING,
  123. .readable_reg = sbs_readable_reg,
  124. .volatile_reg = sbs_volatile_reg,
  125. .val_format_endian = REGMAP_ENDIAN_LITTLE, /* since based on SMBus */
  126. };
  127. static const struct power_supply_desc sbs_desc = {
  128. .name = "sbs-charger",
  129. .type = POWER_SUPPLY_TYPE_MAINS,
  130. .properties = sbs_properties,
  131. .num_properties = ARRAY_SIZE(sbs_properties),
  132. .get_property = sbs_get_property,
  133. };
  134. static int sbs_probe(struct i2c_client *client,
  135. const struct i2c_device_id *id)
  136. {
  137. struct power_supply_config psy_cfg = {};
  138. struct sbs_info *chip;
  139. int ret, val;
  140. chip = devm_kzalloc(&client->dev, sizeof(struct sbs_info), GFP_KERNEL);
  141. if (!chip)
  142. return -ENOMEM;
  143. chip->client = client;
  144. psy_cfg.of_node = client->dev.of_node;
  145. psy_cfg.drv_data = chip;
  146. i2c_set_clientdata(client, chip);
  147. chip->regmap = devm_regmap_init_i2c(client, &sbs_regmap);
  148. if (IS_ERR(chip->regmap))
  149. return PTR_ERR(chip->regmap);
  150. /*
  151. * Before we register, we need to make sure we can actually talk
  152. * to the battery.
  153. */
  154. ret = regmap_read(chip->regmap, SBS_CHARGER_REG_STATUS, &val);
  155. if (ret) {
  156. dev_err(&client->dev, "Failed to get device status\n");
  157. return ret;
  158. }
  159. chip->last_state = val;
  160. chip->power_supply = devm_power_supply_register(&client->dev, &sbs_desc,
  161. &psy_cfg);
  162. if (IS_ERR(chip->power_supply)) {
  163. dev_err(&client->dev, "Failed to register power supply\n");
  164. return PTR_ERR(chip->power_supply);
  165. }
  166. /*
  167. * The sbs-charger spec doesn't impose the use of an interrupt. So in
  168. * the case it wasn't provided we use polling in order get the charger's
  169. * status.
  170. */
  171. if (client->irq) {
  172. ret = devm_request_threaded_irq(&client->dev, client->irq,
  173. NULL, sbs_irq_thread,
  174. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  175. dev_name(&client->dev), chip);
  176. if (ret) {
  177. dev_err(&client->dev, "Failed to request irq, %d\n", ret);
  178. return ret;
  179. }
  180. } else {
  181. INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
  182. schedule_delayed_work(&chip->work,
  183. msecs_to_jiffies(SBS_CHARGER_POLL_TIME));
  184. }
  185. dev_info(&client->dev,
  186. "%s: smart charger device registered\n", client->name);
  187. return 0;
  188. }
  189. static int sbs_remove(struct i2c_client *client)
  190. {
  191. struct sbs_info *chip = i2c_get_clientdata(client);
  192. cancel_delayed_work_sync(&chip->work);
  193. return 0;
  194. }
  195. #ifdef CONFIG_OF
  196. static const struct of_device_id sbs_dt_ids[] = {
  197. { .compatible = "sbs,sbs-charger" },
  198. { },
  199. };
  200. MODULE_DEVICE_TABLE(of, sbs_dt_ids);
  201. #endif
  202. static const struct i2c_device_id sbs_id[] = {
  203. { "sbs-charger", 0 },
  204. { }
  205. };
  206. MODULE_DEVICE_TABLE(i2c, sbs_id);
  207. static struct i2c_driver sbs_driver = {
  208. .probe = sbs_probe,
  209. .remove = sbs_remove,
  210. .id_table = sbs_id,
  211. .driver = {
  212. .name = "sbs-charger",
  213. .of_match_table = of_match_ptr(sbs_dt_ids),
  214. },
  215. };
  216. module_i2c_driver(sbs_driver);
  217. MODULE_AUTHOR("Nicolas Saenz Julienne <nicolassaenzj@gmail.com>");
  218. MODULE_DESCRIPTION("SBS smart charger driver");
  219. MODULE_LICENSE("GPL v2");