regmap-w1.c 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // Register map access API - W1 (1-Wire) support
  4. //
  5. // Copyright (c) 2017 Radioavionica Corporation
  6. // Author: Alex A. Mihaylov <minimumlaw@rambler.ru>
  7. #include <linux/regmap.h>
  8. #include <linux/module.h>
  9. #include <linux/w1.h>
  10. #include "internal.h"
  11. #define W1_CMD_READ_DATA 0x69
  12. #define W1_CMD_WRITE_DATA 0x6C
  13. /*
  14. * 1-Wire slaves registers with addess 8 bit and data 8 bit
  15. */
  16. static int w1_reg_a8_v8_read(void *context, unsigned int reg, unsigned int *val)
  17. {
  18. struct device *dev = context;
  19. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  20. int ret = 0;
  21. if (reg > 255)
  22. return -EINVAL;
  23. mutex_lock(&sl->master->bus_mutex);
  24. if (!w1_reset_select_slave(sl)) {
  25. w1_write_8(sl->master, W1_CMD_READ_DATA);
  26. w1_write_8(sl->master, reg);
  27. *val = w1_read_8(sl->master);
  28. } else {
  29. ret = -ENODEV;
  30. }
  31. mutex_unlock(&sl->master->bus_mutex);
  32. return ret;
  33. }
  34. static int w1_reg_a8_v8_write(void *context, unsigned int reg, unsigned int val)
  35. {
  36. struct device *dev = context;
  37. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  38. int ret = 0;
  39. if (reg > 255)
  40. return -EINVAL;
  41. mutex_lock(&sl->master->bus_mutex);
  42. if (!w1_reset_select_slave(sl)) {
  43. w1_write_8(sl->master, W1_CMD_WRITE_DATA);
  44. w1_write_8(sl->master, reg);
  45. w1_write_8(sl->master, val);
  46. } else {
  47. ret = -ENODEV;
  48. }
  49. mutex_unlock(&sl->master->bus_mutex);
  50. return ret;
  51. }
  52. /*
  53. * 1-Wire slaves registers with addess 8 bit and data 16 bit
  54. */
  55. static int w1_reg_a8_v16_read(void *context, unsigned int reg,
  56. unsigned int *val)
  57. {
  58. struct device *dev = context;
  59. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  60. int ret = 0;
  61. if (reg > 255)
  62. return -EINVAL;
  63. mutex_lock(&sl->master->bus_mutex);
  64. if (!w1_reset_select_slave(sl)) {
  65. w1_write_8(sl->master, W1_CMD_READ_DATA);
  66. w1_write_8(sl->master, reg);
  67. *val = w1_read_8(sl->master);
  68. *val |= w1_read_8(sl->master)<<8;
  69. } else {
  70. ret = -ENODEV;
  71. }
  72. mutex_unlock(&sl->master->bus_mutex);
  73. return ret;
  74. }
  75. static int w1_reg_a8_v16_write(void *context, unsigned int reg,
  76. unsigned int val)
  77. {
  78. struct device *dev = context;
  79. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  80. int ret = 0;
  81. if (reg > 255)
  82. return -EINVAL;
  83. mutex_lock(&sl->master->bus_mutex);
  84. if (!w1_reset_select_slave(sl)) {
  85. w1_write_8(sl->master, W1_CMD_WRITE_DATA);
  86. w1_write_8(sl->master, reg);
  87. w1_write_8(sl->master, val & 0x00FF);
  88. w1_write_8(sl->master, val>>8 & 0x00FF);
  89. } else {
  90. ret = -ENODEV;
  91. }
  92. mutex_unlock(&sl->master->bus_mutex);
  93. return ret;
  94. }
  95. /*
  96. * 1-Wire slaves registers with addess 16 bit and data 16 bit
  97. */
  98. static int w1_reg_a16_v16_read(void *context, unsigned int reg,
  99. unsigned int *val)
  100. {
  101. struct device *dev = context;
  102. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  103. int ret = 0;
  104. if (reg > 65535)
  105. return -EINVAL;
  106. mutex_lock(&sl->master->bus_mutex);
  107. if (!w1_reset_select_slave(sl)) {
  108. w1_write_8(sl->master, W1_CMD_READ_DATA);
  109. w1_write_8(sl->master, reg & 0x00FF);
  110. w1_write_8(sl->master, reg>>8 & 0x00FF);
  111. *val = w1_read_8(sl->master);
  112. *val |= w1_read_8(sl->master)<<8;
  113. } else {
  114. ret = -ENODEV;
  115. }
  116. mutex_unlock(&sl->master->bus_mutex);
  117. return ret;
  118. }
  119. static int w1_reg_a16_v16_write(void *context, unsigned int reg,
  120. unsigned int val)
  121. {
  122. struct device *dev = context;
  123. struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
  124. int ret = 0;
  125. if (reg > 65535)
  126. return -EINVAL;
  127. mutex_lock(&sl->master->bus_mutex);
  128. if (!w1_reset_select_slave(sl)) {
  129. w1_write_8(sl->master, W1_CMD_WRITE_DATA);
  130. w1_write_8(sl->master, reg & 0x00FF);
  131. w1_write_8(sl->master, reg>>8 & 0x00FF);
  132. w1_write_8(sl->master, val & 0x00FF);
  133. w1_write_8(sl->master, val>>8 & 0x00FF);
  134. } else {
  135. ret = -ENODEV;
  136. }
  137. mutex_unlock(&sl->master->bus_mutex);
  138. return ret;
  139. }
  140. /*
  141. * Various types of supported bus addressing
  142. */
  143. static struct regmap_bus regmap_w1_bus_a8_v8 = {
  144. .reg_read = w1_reg_a8_v8_read,
  145. .reg_write = w1_reg_a8_v8_write,
  146. };
  147. static struct regmap_bus regmap_w1_bus_a8_v16 = {
  148. .reg_read = w1_reg_a8_v16_read,
  149. .reg_write = w1_reg_a8_v16_write,
  150. };
  151. static struct regmap_bus regmap_w1_bus_a16_v16 = {
  152. .reg_read = w1_reg_a16_v16_read,
  153. .reg_write = w1_reg_a16_v16_write,
  154. };
  155. static const struct regmap_bus *regmap_get_w1_bus(struct device *w1_dev,
  156. const struct regmap_config *config)
  157. {
  158. if (config->reg_bits == 8 && config->val_bits == 8)
  159. return &regmap_w1_bus_a8_v8;
  160. if (config->reg_bits == 8 && config->val_bits == 16)
  161. return &regmap_w1_bus_a8_v16;
  162. if (config->reg_bits == 16 && config->val_bits == 16)
  163. return &regmap_w1_bus_a16_v16;
  164. return ERR_PTR(-ENOTSUPP);
  165. }
  166. struct regmap *__regmap_init_w1(struct device *w1_dev,
  167. const struct regmap_config *config,
  168. struct lock_class_key *lock_key,
  169. const char *lock_name)
  170. {
  171. const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
  172. if (IS_ERR(bus))
  173. return ERR_CAST(bus);
  174. return __regmap_init(w1_dev, bus, w1_dev, config,
  175. lock_key, lock_name);
  176. }
  177. EXPORT_SYMBOL_GPL(__regmap_init_w1);
  178. struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
  179. const struct regmap_config *config,
  180. struct lock_class_key *lock_key,
  181. const char *lock_name)
  182. {
  183. const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
  184. if (IS_ERR(bus))
  185. return ERR_CAST(bus);
  186. return __devm_regmap_init(w1_dev, bus, w1_dev, config,
  187. lock_key, lock_name);
  188. }
  189. EXPORT_SYMBOL_GPL(__devm_regmap_init_w1);
  190. MODULE_LICENSE("GPL");