ds2782_battery.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331
  1. /*
  2. * I2C client/driver for the Maxim/Dallas DS2782 Stand-Alone Fuel Gauge IC
  3. *
  4. * Copyright (C) 2009 Bluewater Systems Ltd
  5. *
  6. * Author: Ryan Mallon <ryan@bluewatersys.com>
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation.
  11. *
  12. */
  13. #include <linux/kernel.h>
  14. #include <linux/module.h>
  15. #include <linux/types.h>
  16. #include <linux/errno.h>
  17. #include <linux/swab.h>
  18. #include <linux/i2c.h>
  19. #include <linux/idr.h>
  20. #include <linux/power_supply.h>
  21. #include <linux/slab.h>
  22. #define DS2782_REG_RARC 0x06 /* Remaining active relative capacity */
  23. #define DS2782_REG_VOLT_MSB 0x0c
  24. #define DS2782_REG_TEMP_MSB 0x0a
  25. #define DS2782_REG_CURRENT_MSB 0x0e
  26. /* EEPROM Block */
  27. #define DS2782_REG_RSNSP 0x69 /* Sense resistor value */
  28. /* Current unit measurement in uA for a 1 milli-ohm sense resistor */
  29. #define DS2782_CURRENT_UNITS 1563
  30. #define to_ds2782_info(x) container_of(x, struct ds2782_info, battery)
  31. struct ds2782_info {
  32. struct i2c_client *client;
  33. struct power_supply battery;
  34. int id;
  35. };
  36. static DEFINE_IDR(battery_id);
  37. static DEFINE_MUTEX(battery_lock);
  38. static inline int ds2782_read_reg(struct ds2782_info *info, int reg, u8 *val)
  39. {
  40. int ret;
  41. ret = i2c_smbus_read_byte_data(info->client, reg);
  42. if (ret < 0) {
  43. dev_err(&info->client->dev, "register read failed\n");
  44. return ret;
  45. }
  46. *val = ret;
  47. return 0;
  48. }
  49. static inline int ds2782_read_reg16(struct ds2782_info *info, int reg_msb,
  50. s16 *val)
  51. {
  52. int ret;
  53. ret = swab16(i2c_smbus_read_word_data(info->client, reg_msb));
  54. if (ret < 0) {
  55. dev_err(&info->client->dev, "register read failed\n");
  56. return ret;
  57. }
  58. *val = ret;
  59. return 0;
  60. }
  61. static int ds2782_get_temp(struct ds2782_info *info, int *temp)
  62. {
  63. s16 raw;
  64. int err;
  65. /*
  66. * Temperature is measured in units of 0.125 degrees celcius, the
  67. * power_supply class measures temperature in tenths of degrees
  68. * celsius. The temperature value is stored as a 10 bit number, plus
  69. * sign in the upper bits of a 16 bit register.
  70. */
  71. err = ds2782_read_reg16(info, DS2782_REG_TEMP_MSB, &raw);
  72. if (err)
  73. return err;
  74. *temp = ((raw / 32) * 125) / 100;
  75. return 0;
  76. }
  77. static int ds2782_get_current(struct ds2782_info *info, int *current_uA)
  78. {
  79. int sense_res;
  80. int err;
  81. u8 sense_res_raw;
  82. s16 raw;
  83. /*
  84. * The units of measurement for current are dependent on the value of
  85. * the sense resistor.
  86. */
  87. err = ds2782_read_reg(info, DS2782_REG_RSNSP, &sense_res_raw);
  88. if (err)
  89. return err;
  90. if (sense_res_raw == 0) {
  91. dev_err(&info->client->dev, "sense resistor value is 0\n");
  92. return -ENXIO;
  93. }
  94. sense_res = 1000 / sense_res_raw;
  95. dev_dbg(&info->client->dev, "sense resistor = %d milli-ohms\n",
  96. sense_res);
  97. err = ds2782_read_reg16(info, DS2782_REG_CURRENT_MSB, &raw);
  98. if (err)
  99. return err;
  100. *current_uA = raw * (DS2782_CURRENT_UNITS / sense_res);
  101. return 0;
  102. }
  103. static int ds2782_get_voltage(struct ds2782_info *info, int *voltage_uA)
  104. {
  105. s16 raw;
  106. int err;
  107. /*
  108. * Voltage is measured in units of 4.88mV. The voltage is stored as
  109. * a 10-bit number plus sign, in the upper bits of a 16-bit register
  110. */
  111. err = ds2782_read_reg16(info, DS2782_REG_VOLT_MSB, &raw);
  112. if (err)
  113. return err;
  114. *voltage_uA = (raw / 32) * 4800;
  115. return 0;
  116. }
  117. static int ds2782_get_capacity(struct ds2782_info *info, int *capacity)
  118. {
  119. int err;
  120. u8 raw;
  121. err = ds2782_read_reg(info, DS2782_REG_RARC, &raw);
  122. if (err)
  123. return err;
  124. *capacity = raw;
  125. return raw;
  126. }
  127. static int ds2782_get_status(struct ds2782_info *info, int *status)
  128. {
  129. int err;
  130. int current_uA;
  131. int capacity;
  132. err = ds2782_get_current(info, &current_uA);
  133. if (err)
  134. return err;
  135. err = ds2782_get_capacity(info, &capacity);
  136. if (err)
  137. return err;
  138. if (capacity == 100)
  139. *status = POWER_SUPPLY_STATUS_FULL;
  140. else if (current_uA == 0)
  141. *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
  142. else if (current_uA < 0)
  143. *status = POWER_SUPPLY_STATUS_DISCHARGING;
  144. else
  145. *status = POWER_SUPPLY_STATUS_CHARGING;
  146. return 0;
  147. }
  148. static int ds2782_battery_get_property(struct power_supply *psy,
  149. enum power_supply_property prop,
  150. union power_supply_propval *val)
  151. {
  152. struct ds2782_info *info = to_ds2782_info(psy);
  153. int ret;
  154. switch (prop) {
  155. case POWER_SUPPLY_PROP_STATUS:
  156. ret = ds2782_get_status(info, &val->intval);
  157. break;
  158. case POWER_SUPPLY_PROP_CAPACITY:
  159. ret = ds2782_get_capacity(info, &val->intval);
  160. break;
  161. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  162. ret = ds2782_get_voltage(info, &val->intval);
  163. break;
  164. case POWER_SUPPLY_PROP_CURRENT_NOW:
  165. ret = ds2782_get_current(info, &val->intval);
  166. break;
  167. case POWER_SUPPLY_PROP_TEMP:
  168. ret = ds2782_get_temp(info, &val->intval);
  169. break;
  170. default:
  171. ret = -EINVAL;
  172. }
  173. return ret;
  174. }
  175. static enum power_supply_property ds2782_battery_props[] = {
  176. POWER_SUPPLY_PROP_STATUS,
  177. POWER_SUPPLY_PROP_CAPACITY,
  178. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  179. POWER_SUPPLY_PROP_CURRENT_NOW,
  180. POWER_SUPPLY_PROP_TEMP,
  181. };
  182. static void ds2782_power_supply_init(struct power_supply *battery)
  183. {
  184. battery->type = POWER_SUPPLY_TYPE_BATTERY;
  185. battery->properties = ds2782_battery_props;
  186. battery->num_properties = ARRAY_SIZE(ds2782_battery_props);
  187. battery->get_property = ds2782_battery_get_property;
  188. battery->external_power_changed = NULL;
  189. }
  190. static int ds2782_battery_remove(struct i2c_client *client)
  191. {
  192. struct ds2782_info *info = i2c_get_clientdata(client);
  193. power_supply_unregister(&info->battery);
  194. kfree(info->battery.name);
  195. mutex_lock(&battery_lock);
  196. idr_remove(&battery_id, info->id);
  197. mutex_unlock(&battery_lock);
  198. i2c_set_clientdata(client, info);
  199. kfree(info);
  200. return 0;
  201. }
  202. static int ds2782_battery_probe(struct i2c_client *client,
  203. const struct i2c_device_id *id)
  204. {
  205. struct ds2782_info *info;
  206. int ret;
  207. int num;
  208. /* Get an ID for this battery */
  209. ret = idr_pre_get(&battery_id, GFP_KERNEL);
  210. if (ret == 0) {
  211. ret = -ENOMEM;
  212. goto fail_id;
  213. }
  214. mutex_lock(&battery_lock);
  215. ret = idr_get_new(&battery_id, client, &num);
  216. mutex_unlock(&battery_lock);
  217. if (ret < 0)
  218. goto fail_id;
  219. info = kzalloc(sizeof(*info), GFP_KERNEL);
  220. if (!info) {
  221. ret = -ENOMEM;
  222. goto fail_info;
  223. }
  224. info->battery.name = kasprintf(GFP_KERNEL, "ds2782-%d", num);
  225. if (!info->battery.name) {
  226. ret = -ENOMEM;
  227. goto fail_name;
  228. }
  229. i2c_set_clientdata(client, info);
  230. info->client = client;
  231. ds2782_power_supply_init(&info->battery);
  232. ret = power_supply_register(&client->dev, &info->battery);
  233. if (ret) {
  234. dev_err(&client->dev, "failed to register battery\n");
  235. goto fail_register;
  236. }
  237. return 0;
  238. fail_register:
  239. kfree(info->battery.name);
  240. fail_name:
  241. i2c_set_clientdata(client, info);
  242. kfree(info);
  243. fail_info:
  244. mutex_lock(&battery_lock);
  245. idr_remove(&battery_id, num);
  246. mutex_unlock(&battery_lock);
  247. fail_id:
  248. return ret;
  249. }
  250. static const struct i2c_device_id ds2782_id[] = {
  251. {"ds2782", 0},
  252. {},
  253. };
  254. static struct i2c_driver ds2782_battery_driver = {
  255. .driver = {
  256. .name = "ds2782-battery",
  257. },
  258. .probe = ds2782_battery_probe,
  259. .remove = ds2782_battery_remove,
  260. .id_table = ds2782_id,
  261. };
  262. static int __init ds2782_init(void)
  263. {
  264. return i2c_add_driver(&ds2782_battery_driver);
  265. }
  266. module_init(ds2782_init);
  267. static void __exit ds2782_exit(void)
  268. {
  269. i2c_del_driver(&ds2782_battery_driver);
  270. }
  271. module_exit(ds2782_exit);
  272. MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
  273. MODULE_DESCRIPTION("Maxim/Dallas DS2782 Stand-Alone Fuel Gauage IC driver");
  274. MODULE_LICENSE("GPL");