/drivers/w1/slaves/w1_ds2780.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C · 239 lines · 177 code · 48 blank · 14 comment · 24 complexity · 19e0171f03d7fbcdcdc14bf3dbbf0a69 MD5 · raw file

  1. /*
  2. * 1-Wire implementation for the ds2780 chip
  3. *
  4. * Copyright (C) 2010 Indesign, LLC
  5. *
  6. * Author: Clifton Barnes <cabarnes@indesign-llc.com>
  7. *
  8. * Based on w1-ds2760 driver
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License version 2 as
  12. * published by the Free Software Foundation.
  13. *
  14. */
  15. #include <linux/kernel.h>
  16. #include <linux/module.h>
  17. #include <linux/device.h>
  18. #include <linux/types.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/mutex.h>
  21. #include <linux/idr.h>
  22. #include "../w1.h"
  23. #include "../w1_int.h"
  24. #include "../w1_family.h"
  25. #include "w1_ds2780.h"
  26. static int w1_ds2780_do_io(struct device *dev, char *buf, int addr,
  27. size_t count, int io)
  28. {
  29. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  30. if (addr > DS2780_DATA_SIZE || addr < 0)
  31. return 0;
  32. count = min_t(int, count, DS2780_DATA_SIZE - addr);
  33. if (w1_reset_select_slave(sl) == 0) {
  34. if (io) {
  35. w1_write_8(sl->master, W1_DS2780_WRITE_DATA);
  36. w1_write_8(sl->master, addr);
  37. w1_write_block(sl->master, buf, count);
  38. } else {
  39. w1_write_8(sl->master, W1_DS2780_READ_DATA);
  40. w1_write_8(sl->master, addr);
  41. count = w1_read_block(sl->master, buf, count);
  42. }
  43. }
  44. return count;
  45. }
  46. int w1_ds2780_io(struct device *dev, char *buf, int addr, size_t count,
  47. int io)
  48. {
  49. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  50. int ret;
  51. if (!dev)
  52. return -ENODEV;
  53. mutex_lock(&sl->master->mutex);
  54. ret = w1_ds2780_do_io(dev, buf, addr, count, io);
  55. mutex_unlock(&sl->master->mutex);
  56. return ret;
  57. }
  58. EXPORT_SYMBOL(w1_ds2780_io);
  59. int w1_ds2780_io_nolock(struct device *dev, char *buf, int addr, size_t count,
  60. int io)
  61. {
  62. int ret;
  63. if (!dev)
  64. return -ENODEV;
  65. ret = w1_ds2780_do_io(dev, buf, addr, count, io);
  66. return ret;
  67. }
  68. EXPORT_SYMBOL(w1_ds2780_io_nolock);
  69. int w1_ds2780_eeprom_cmd(struct device *dev, int addr, int cmd)
  70. {
  71. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  72. if (!dev)
  73. return -EINVAL;
  74. mutex_lock(&sl->master->mutex);
  75. if (w1_reset_select_slave(sl) == 0) {
  76. w1_write_8(sl->master, cmd);
  77. w1_write_8(sl->master, addr);
  78. }
  79. mutex_unlock(&sl->master->mutex);
  80. return 0;
  81. }
  82. EXPORT_SYMBOL(w1_ds2780_eeprom_cmd);
  83. static ssize_t w1_ds2780_read_bin(struct file *filp,
  84. struct kobject *kobj,
  85. struct bin_attribute *bin_attr,
  86. char *buf, loff_t off, size_t count)
  87. {
  88. struct device *dev = container_of(kobj, struct device, kobj);
  89. return w1_ds2780_io(dev, buf, off, count, 0);
  90. }
  91. static struct bin_attribute w1_ds2780_bin_attr = {
  92. .attr = {
  93. .name = "w1_slave",
  94. .mode = S_IRUGO,
  95. },
  96. .size = DS2780_DATA_SIZE,
  97. .read = w1_ds2780_read_bin,
  98. };
  99. static DEFINE_IDR(bat_idr);
  100. static DEFINE_MUTEX(bat_idr_lock);
  101. static int new_bat_id(void)
  102. {
  103. int ret;
  104. while (1) {
  105. int id;
  106. ret = idr_pre_get(&bat_idr, GFP_KERNEL);
  107. if (ret == 0)
  108. return -ENOMEM;
  109. mutex_lock(&bat_idr_lock);
  110. ret = idr_get_new(&bat_idr, NULL, &id);
  111. mutex_unlock(&bat_idr_lock);
  112. if (ret == 0) {
  113. ret = id & MAX_ID_MASK;
  114. break;
  115. } else if (ret == -EAGAIN) {
  116. continue;
  117. } else {
  118. break;
  119. }
  120. }
  121. return ret;
  122. }
  123. static void release_bat_id(int id)
  124. {
  125. mutex_lock(&bat_idr_lock);
  126. idr_remove(&bat_idr, id);
  127. mutex_unlock(&bat_idr_lock);
  128. }
  129. static int w1_ds2780_add_slave(struct w1_slave *sl)
  130. {
  131. int ret;
  132. int id;
  133. struct platform_device *pdev;
  134. id = new_bat_id();
  135. if (id < 0) {
  136. ret = id;
  137. goto noid;
  138. }
  139. pdev = platform_device_alloc("ds2780-battery", id);
  140. if (!pdev) {
  141. ret = -ENOMEM;
  142. goto pdev_alloc_failed;
  143. }
  144. pdev->dev.parent = &sl->dev;
  145. ret = platform_device_add(pdev);
  146. if (ret)
  147. goto pdev_add_failed;
  148. ret = sysfs_create_bin_file(&sl->dev.kobj, &w1_ds2780_bin_attr);
  149. if (ret)
  150. goto bin_attr_failed;
  151. dev_set_drvdata(&sl->dev, pdev);
  152. return 0;
  153. bin_attr_failed:
  154. pdev_add_failed:
  155. platform_device_unregister(pdev);
  156. pdev_alloc_failed:
  157. release_bat_id(id);
  158. noid:
  159. return ret;
  160. }
  161. static void w1_ds2780_remove_slave(struct w1_slave *sl)
  162. {
  163. struct platform_device *pdev = dev_get_drvdata(&sl->dev);
  164. int id = pdev->id;
  165. platform_device_unregister(pdev);
  166. release_bat_id(id);
  167. sysfs_remove_bin_file(&sl->dev.kobj, &w1_ds2780_bin_attr);
  168. }
  169. static struct w1_family_ops w1_ds2780_fops = {
  170. .add_slave = w1_ds2780_add_slave,
  171. .remove_slave = w1_ds2780_remove_slave,
  172. };
  173. static struct w1_family w1_ds2780_family = {
  174. .fid = W1_FAMILY_DS2780,
  175. .fops = &w1_ds2780_fops,
  176. };
  177. static int __init w1_ds2780_init(void)
  178. {
  179. idr_init(&bat_idr);
  180. return w1_register_family(&w1_ds2780_family);
  181. }
  182. static void __exit w1_ds2780_exit(void)
  183. {
  184. w1_unregister_family(&w1_ds2780_family);
  185. idr_destroy(&bat_idr);
  186. }
  187. module_init(w1_ds2780_init);
  188. module_exit(w1_ds2780_exit);
  189. MODULE_LICENSE("GPL");
  190. MODULE_AUTHOR("Clifton Barnes <cabarnes@indesign-llc.com>");
  191. MODULE_DESCRIPTION("1-wire Driver for Maxim/Dallas DS2780 Stand-Alone Fuel Gauge IC");