sbs-manager.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for SBS compliant Smart Battery System Managers
  4. *
  5. * The device communicates via i2c at address 0x0a and multiplexes access to up
  6. * to four smart batteries at address 0x0b.
  7. *
  8. * Via sysfs interface the online state and charge type are presented.
  9. *
  10. * Datasheet SBSM: http://sbs-forum.org/specs/sbsm100b.pdf
  11. * Datasheet LTC1760: http://cds.linear.com/docs/en/datasheet/1760fb.pdf
  12. *
  13. * Karl-Heinz Schneider <karl-heinz@schneider-inet.de>
  14. */
  15. #include <linux/gpio.h>
  16. #include <linux/module.h>
  17. #include <linux/i2c.h>
  18. #include <linux/i2c-mux.h>
  19. #include <linux/power_supply.h>
  20. #include <linux/property.h>
  21. #define SBSM_MAX_BATS 4
  22. #define SBSM_RETRY_CNT 3
  23. /* registers addresses */
  24. #define SBSM_CMD_BATSYSSTATE 0x01
  25. #define SBSM_CMD_BATSYSSTATECONT 0x02
  26. #define SBSM_CMD_BATSYSINFO 0x04
  27. #define SBSM_CMD_LTC 0x3c
  28. #define SBSM_MASK_BAT_SUPPORTED GENMASK(3, 0)
  29. #define SBSM_MASK_CHARGE_BAT GENMASK(7, 4)
  30. #define SBSM_BIT_AC_PRESENT BIT(0)
  31. #define SBSM_BIT_TURBO BIT(7)
  32. #define SBSM_SMB_BAT_OFFSET 11
  33. struct sbsm_data {
  34. struct i2c_client *client;
  35. struct i2c_mux_core *muxc;
  36. struct power_supply *psy;
  37. u8 cur_chan; /* currently selected channel */
  38. struct gpio_chip chip;
  39. bool is_ltc1760; /* special capabilities */
  40. unsigned int supported_bats;
  41. unsigned int last_state;
  42. unsigned int last_state_cont;
  43. };
  44. static enum power_supply_property sbsm_props[] = {
  45. POWER_SUPPLY_PROP_ONLINE,
  46. POWER_SUPPLY_PROP_CHARGE_TYPE,
  47. };
  48. static int sbsm_read_word(struct i2c_client *client, u8 address)
  49. {
  50. int reg, retries;
  51. for (retries = SBSM_RETRY_CNT; retries > 0; retries--) {
  52. reg = i2c_smbus_read_word_data(client, address);
  53. if (reg >= 0)
  54. break;
  55. }
  56. if (reg < 0) {
  57. dev_err(&client->dev, "failed to read register 0x%02x\n",
  58. address);
  59. }
  60. return reg;
  61. }
  62. static int sbsm_write_word(struct i2c_client *client, u8 address, u16 word)
  63. {
  64. int ret, retries;
  65. for (retries = SBSM_RETRY_CNT; retries > 0; retries--) {
  66. ret = i2c_smbus_write_word_data(client, address, word);
  67. if (ret >= 0)
  68. break;
  69. }
  70. if (ret < 0)
  71. dev_err(&client->dev, "failed to write to register 0x%02x\n",
  72. address);
  73. return ret;
  74. }
  75. static int sbsm_get_property(struct power_supply *psy,
  76. enum power_supply_property psp,
  77. union power_supply_propval *val)
  78. {
  79. struct sbsm_data *data = power_supply_get_drvdata(psy);
  80. int regval = 0;
  81. switch (psp) {
  82. case POWER_SUPPLY_PROP_ONLINE:
  83. regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATECONT);
  84. if (regval < 0)
  85. return regval;
  86. val->intval = !!(regval & SBSM_BIT_AC_PRESENT);
  87. break;
  88. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  89. regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE);
  90. if (regval < 0)
  91. return regval;
  92. if ((regval & SBSM_MASK_CHARGE_BAT) == 0) {
  93. val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
  94. return 0;
  95. }
  96. val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  97. if (data->is_ltc1760) {
  98. /* charge mode fast if turbo is active */
  99. regval = sbsm_read_word(data->client, SBSM_CMD_LTC);
  100. if (regval < 0)
  101. return regval;
  102. else if (regval & SBSM_BIT_TURBO)
  103. val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
  104. }
  105. break;
  106. default:
  107. return -EINVAL;
  108. }
  109. return 0;
  110. }
  111. static int sbsm_prop_is_writeable(struct power_supply *psy,
  112. enum power_supply_property psp)
  113. {
  114. struct sbsm_data *data = power_supply_get_drvdata(psy);
  115. return (psp == POWER_SUPPLY_PROP_CHARGE_TYPE) && data->is_ltc1760;
  116. }
  117. static int sbsm_set_property(struct power_supply *psy,
  118. enum power_supply_property psp,
  119. const union power_supply_propval *val)
  120. {
  121. struct sbsm_data *data = power_supply_get_drvdata(psy);
  122. int ret = -EINVAL;
  123. u16 regval;
  124. switch (psp) {
  125. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  126. /* write 1 to TURBO if type fast is given */
  127. if (!data->is_ltc1760)
  128. break;
  129. regval = val->intval ==
  130. POWER_SUPPLY_CHARGE_TYPE_FAST ? SBSM_BIT_TURBO : 0;
  131. ret = sbsm_write_word(data->client, SBSM_CMD_LTC, regval);
  132. break;
  133. default:
  134. break;
  135. }
  136. return ret;
  137. }
  138. /*
  139. * Switch to battery
  140. * Parameter chan is directly the content of SMB_BAT* nibble
  141. */
  142. static int sbsm_select(struct i2c_mux_core *muxc, u32 chan)
  143. {
  144. struct sbsm_data *data = i2c_mux_priv(muxc);
  145. struct device *dev = &data->client->dev;
  146. int ret = 0;
  147. u16 reg;
  148. if (data->cur_chan == chan)
  149. return ret;
  150. /* chan goes from 1 ... 4 */
  151. reg = BIT(SBSM_SMB_BAT_OFFSET + chan);
  152. ret = sbsm_write_word(data->client, SBSM_CMD_BATSYSSTATE, reg);
  153. if (ret)
  154. dev_err(dev, "Failed to select channel %i\n", chan);
  155. else
  156. data->cur_chan = chan;
  157. return ret;
  158. }
  159. static int sbsm_gpio_get_value(struct gpio_chip *gc, unsigned int off)
  160. {
  161. struct sbsm_data *data = gpiochip_get_data(gc);
  162. int ret;
  163. ret = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE);
  164. if (ret < 0)
  165. return ret;
  166. return ret & BIT(off);
  167. }
  168. /*
  169. * This needs to be defined or the GPIO lib fails to register the pin.
  170. * But the 'gpio' is always an input.
  171. */
  172. static int sbsm_gpio_direction_input(struct gpio_chip *gc, unsigned int off)
  173. {
  174. return 0;
  175. }
  176. static int sbsm_do_alert(struct device *dev, void *d)
  177. {
  178. struct i2c_client *client = i2c_verify_client(dev);
  179. struct i2c_driver *driver;
  180. if (!client || client->addr != 0x0b)
  181. return 0;
  182. device_lock(dev);
  183. if (client->dev.driver) {
  184. driver = to_i2c_driver(client->dev.driver);
  185. if (driver->alert)
  186. driver->alert(client, I2C_PROTOCOL_SMBUS_ALERT, 0);
  187. else
  188. dev_warn(&client->dev, "no driver alert()!\n");
  189. } else {
  190. dev_dbg(&client->dev, "alert with no driver\n");
  191. }
  192. device_unlock(dev);
  193. return -EBUSY;
  194. }
  195. static void sbsm_alert(struct i2c_client *client, enum i2c_alert_protocol prot,
  196. unsigned int d)
  197. {
  198. struct sbsm_data *sbsm = i2c_get_clientdata(client);
  199. int ret, i, irq_bat = 0, state = 0;
  200. ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATE);
  201. if (ret >= 0) {
  202. irq_bat = ret ^ sbsm->last_state;
  203. sbsm->last_state = ret;
  204. state = ret;
  205. }
  206. ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATECONT);
  207. if ((ret >= 0) &&
  208. ((ret ^ sbsm->last_state_cont) & SBSM_BIT_AC_PRESENT)) {
  209. irq_bat |= sbsm->supported_bats & state;
  210. power_supply_changed(sbsm->psy);
  211. }
  212. sbsm->last_state_cont = ret;
  213. for (i = 0; i < SBSM_MAX_BATS; i++) {
  214. if (irq_bat & BIT(i)) {
  215. device_for_each_child(&sbsm->muxc->adapter[i]->dev,
  216. NULL, sbsm_do_alert);
  217. }
  218. }
  219. }
  220. static int sbsm_gpio_setup(struct sbsm_data *data)
  221. {
  222. struct gpio_chip *gc = &data->chip;
  223. struct i2c_client *client = data->client;
  224. struct device *dev = &client->dev;
  225. int ret;
  226. if (!device_property_present(dev, "gpio-controller"))
  227. return 0;
  228. ret = sbsm_read_word(client, SBSM_CMD_BATSYSSTATE);
  229. if (ret < 0)
  230. return ret;
  231. data->last_state = ret;
  232. ret = sbsm_read_word(client, SBSM_CMD_BATSYSSTATECONT);
  233. if (ret < 0)
  234. return ret;
  235. data->last_state_cont = ret;
  236. gc->get = sbsm_gpio_get_value;
  237. gc->direction_input = sbsm_gpio_direction_input;
  238. gc->can_sleep = true;
  239. gc->base = -1;
  240. gc->ngpio = SBSM_MAX_BATS;
  241. gc->label = client->name;
  242. gc->parent = dev;
  243. gc->owner = THIS_MODULE;
  244. ret = devm_gpiochip_add_data(dev, gc, data);
  245. if (ret) {
  246. dev_err(dev, "devm_gpiochip_add_data failed: %d\n", ret);
  247. return ret;
  248. }
  249. return ret;
  250. }
  251. static const struct power_supply_desc sbsm_default_psy_desc = {
  252. .type = POWER_SUPPLY_TYPE_MAINS,
  253. .properties = sbsm_props,
  254. .num_properties = ARRAY_SIZE(sbsm_props),
  255. .get_property = &sbsm_get_property,
  256. .set_property = &sbsm_set_property,
  257. .property_is_writeable = &sbsm_prop_is_writeable,
  258. };
  259. static int sbsm_probe(struct i2c_client *client,
  260. const struct i2c_device_id *id)
  261. {
  262. struct i2c_adapter *adapter = client->adapter;
  263. struct sbsm_data *data;
  264. struct device *dev = &client->dev;
  265. struct power_supply_desc *psy_desc;
  266. struct power_supply_config psy_cfg = {};
  267. int ret = 0, i;
  268. /* Device listens only at address 0x0a */
  269. if (client->addr != 0x0a)
  270. return -EINVAL;
  271. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
  272. return -EPFNOSUPPORT;
  273. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  274. if (!data)
  275. return -ENOMEM;
  276. i2c_set_clientdata(client, data);
  277. data->client = client;
  278. data->is_ltc1760 = !!strstr(id->name, "ltc1760");
  279. ret = sbsm_read_word(client, SBSM_CMD_BATSYSINFO);
  280. if (ret < 0)
  281. return ret;
  282. data->supported_bats = ret & SBSM_MASK_BAT_SUPPORTED;
  283. data->muxc = i2c_mux_alloc(adapter, dev, SBSM_MAX_BATS, 0,
  284. I2C_MUX_LOCKED, &sbsm_select, NULL);
  285. if (!data->muxc) {
  286. dev_err(dev, "failed to alloc i2c mux\n");
  287. ret = -ENOMEM;
  288. goto err_mux_alloc;
  289. }
  290. data->muxc->priv = data;
  291. /* register muxed i2c channels. One for each supported battery */
  292. for (i = 0; i < SBSM_MAX_BATS; ++i) {
  293. if (data->supported_bats & BIT(i)) {
  294. ret = i2c_mux_add_adapter(data->muxc, 0, i + 1, 0);
  295. if (ret)
  296. break;
  297. }
  298. }
  299. if (ret) {
  300. dev_err(dev, "failed to register i2c mux channel %d\n", i + 1);
  301. goto err_mux_register;
  302. }
  303. psy_desc = devm_kmemdup(dev, &sbsm_default_psy_desc,
  304. sizeof(struct power_supply_desc),
  305. GFP_KERNEL);
  306. if (!psy_desc) {
  307. ret = -ENOMEM;
  308. goto err_psy;
  309. }
  310. psy_desc->name = devm_kasprintf(dev, GFP_KERNEL, "sbsm-%s",
  311. dev_name(&client->dev));
  312. if (!psy_desc->name) {
  313. ret = -ENOMEM;
  314. goto err_psy;
  315. }
  316. ret = sbsm_gpio_setup(data);
  317. if (ret < 0)
  318. goto err_psy;
  319. psy_cfg.drv_data = data;
  320. psy_cfg.of_node = dev->of_node;
  321. data->psy = devm_power_supply_register(dev, psy_desc, &psy_cfg);
  322. if (IS_ERR(data->psy)) {
  323. ret = PTR_ERR(data->psy);
  324. dev_err(dev, "failed to register power supply %s\n",
  325. psy_desc->name);
  326. goto err_psy;
  327. }
  328. return 0;
  329. err_psy:
  330. err_mux_register:
  331. i2c_mux_del_adapters(data->muxc);
  332. err_mux_alloc:
  333. return ret;
  334. }
  335. static int sbsm_remove(struct i2c_client *client)
  336. {
  337. struct sbsm_data *data = i2c_get_clientdata(client);
  338. i2c_mux_del_adapters(data->muxc);
  339. return 0;
  340. }
  341. static const struct i2c_device_id sbsm_ids[] = {
  342. { "sbs-manager", 0 },
  343. { "ltc1760", 0 },
  344. { }
  345. };
  346. MODULE_DEVICE_TABLE(i2c, sbsm_ids);
  347. #ifdef CONFIG_OF
  348. static const struct of_device_id sbsm_dt_ids[] = {
  349. { .compatible = "sbs,sbs-manager" },
  350. { .compatible = "lltc,ltc1760" },
  351. { }
  352. };
  353. MODULE_DEVICE_TABLE(of, sbsm_dt_ids);
  354. #endif
  355. static struct i2c_driver sbsm_driver = {
  356. .driver = {
  357. .name = "sbsm",
  358. .of_match_table = of_match_ptr(sbsm_dt_ids),
  359. },
  360. .probe = sbsm_probe,
  361. .remove = sbsm_remove,
  362. .alert = sbsm_alert,
  363. .id_table = sbsm_ids
  364. };
  365. module_i2c_driver(sbsm_driver);
  366. MODULE_LICENSE("GPL");
  367. MODULE_AUTHOR("Karl-Heinz Schneider <karl-heinz@schneider-inet.de>");
  368. MODULE_DESCRIPTION("SBSM Smart Battery System Manager");