Loading...
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
8#include <linux/regmap.h>
9#include <linux/module.h>
10#include <linux/w1.h>
11
12#include "internal.h"
13
14#define W1_CMD_READ_DATA 0x69
15#define W1_CMD_WRITE_DATA 0x6C
16
17/*
18 * 1-Wire slaves registers with addess 8 bit and data 8 bit
19 */
20
21static int w1_reg_a8_v8_read(void *context, unsigned int reg, unsigned int *val)
22{
23 struct device *dev = context;
24 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
25 int ret = 0;
26
27 if (reg > 255)
28 return -EINVAL;
29
30 mutex_lock(&sl->master->bus_mutex);
31 if (!w1_reset_select_slave(sl)) {
32 w1_write_8(sl->master, W1_CMD_READ_DATA);
33 w1_write_8(sl->master, reg);
34 *val = w1_read_8(sl->master);
35 } else {
36 ret = -ENODEV;
37 }
38 mutex_unlock(&sl->master->bus_mutex);
39
40 return ret;
41}
42
43static int w1_reg_a8_v8_write(void *context, unsigned int reg, unsigned int val)
44{
45 struct device *dev = context;
46 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
47 int ret = 0;
48
49 if (reg > 255)
50 return -EINVAL;
51
52 mutex_lock(&sl->master->bus_mutex);
53 if (!w1_reset_select_slave(sl)) {
54 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
55 w1_write_8(sl->master, reg);
56 w1_write_8(sl->master, val);
57 } else {
58 ret = -ENODEV;
59 }
60 mutex_unlock(&sl->master->bus_mutex);
61
62 return ret;
63}
64
65/*
66 * 1-Wire slaves registers with addess 8 bit and data 16 bit
67 */
68
69static int w1_reg_a8_v16_read(void *context, unsigned int reg,
70 unsigned int *val)
71{
72 struct device *dev = context;
73 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
74 int ret = 0;
75
76 if (reg > 255)
77 return -EINVAL;
78
79 mutex_lock(&sl->master->bus_mutex);
80 if (!w1_reset_select_slave(sl)) {
81 w1_write_8(sl->master, W1_CMD_READ_DATA);
82 w1_write_8(sl->master, reg);
83 *val = w1_read_8(sl->master);
84 *val |= w1_read_8(sl->master)<<8;
85 } else {
86 ret = -ENODEV;
87 }
88 mutex_unlock(&sl->master->bus_mutex);
89
90 return ret;
91}
92
93static int w1_reg_a8_v16_write(void *context, unsigned int reg,
94 unsigned int val)
95{
96 struct device *dev = context;
97 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
98 int ret = 0;
99
100 if (reg > 255)
101 return -EINVAL;
102
103 mutex_lock(&sl->master->bus_mutex);
104 if (!w1_reset_select_slave(sl)) {
105 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
106 w1_write_8(sl->master, reg);
107 w1_write_8(sl->master, val & 0x00FF);
108 w1_write_8(sl->master, val>>8 & 0x00FF);
109 } else {
110 ret = -ENODEV;
111 }
112 mutex_unlock(&sl->master->bus_mutex);
113
114 return ret;
115}
116
117/*
118 * 1-Wire slaves registers with addess 16 bit and data 16 bit
119 */
120
121static int w1_reg_a16_v16_read(void *context, unsigned int reg,
122 unsigned int *val)
123{
124 struct device *dev = context;
125 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
126 int ret = 0;
127
128 if (reg > 65535)
129 return -EINVAL;
130
131 mutex_lock(&sl->master->bus_mutex);
132 if (!w1_reset_select_slave(sl)) {
133 w1_write_8(sl->master, W1_CMD_READ_DATA);
134 w1_write_8(sl->master, reg & 0x00FF);
135 w1_write_8(sl->master, reg>>8 & 0x00FF);
136 *val = w1_read_8(sl->master);
137 *val |= w1_read_8(sl->master)<<8;
138 } else {
139 ret = -ENODEV;
140 }
141 mutex_unlock(&sl->master->bus_mutex);
142
143 return ret;
144}
145
146static int w1_reg_a16_v16_write(void *context, unsigned int reg,
147 unsigned int val)
148{
149 struct device *dev = context;
150 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
151 int ret = 0;
152
153 if (reg > 65535)
154 return -EINVAL;
155
156 mutex_lock(&sl->master->bus_mutex);
157 if (!w1_reset_select_slave(sl)) {
158 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
159 w1_write_8(sl->master, reg & 0x00FF);
160 w1_write_8(sl->master, reg>>8 & 0x00FF);
161 w1_write_8(sl->master, val & 0x00FF);
162 w1_write_8(sl->master, val>>8 & 0x00FF);
163 } else {
164 ret = -ENODEV;
165 }
166 mutex_unlock(&sl->master->bus_mutex);
167
168 return ret;
169}
170
171/*
172 * Various types of supported bus addressing
173 */
174
175static const struct regmap_bus regmap_w1_bus_a8_v8 = {
176 .reg_read = w1_reg_a8_v8_read,
177 .reg_write = w1_reg_a8_v8_write,
178};
179
180static const struct regmap_bus regmap_w1_bus_a8_v16 = {
181 .reg_read = w1_reg_a8_v16_read,
182 .reg_write = w1_reg_a8_v16_write,
183};
184
185static const struct regmap_bus regmap_w1_bus_a16_v16 = {
186 .reg_read = w1_reg_a16_v16_read,
187 .reg_write = w1_reg_a16_v16_write,
188};
189
190static const struct regmap_bus *regmap_get_w1_bus(struct device *w1_dev,
191 const struct regmap_config *config)
192{
193 if (config->reg_bits == 8 && config->val_bits == 8)
194 return ®map_w1_bus_a8_v8;
195
196 if (config->reg_bits == 8 && config->val_bits == 16)
197 return ®map_w1_bus_a8_v16;
198
199 if (config->reg_bits == 16 && config->val_bits == 16)
200 return ®map_w1_bus_a16_v16;
201
202 return ERR_PTR(-ENOTSUPP);
203}
204
205struct regmap *__regmap_init_w1(struct device *w1_dev,
206 const struct regmap_config *config,
207 struct lock_class_key *lock_key,
208 const char *lock_name)
209{
210
211 const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
212
213 if (IS_ERR(bus))
214 return ERR_CAST(bus);
215
216 return __regmap_init(w1_dev, bus, w1_dev, config,
217 lock_key, lock_name);
218}
219EXPORT_SYMBOL_GPL(__regmap_init_w1);
220
221struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
222 const struct regmap_config *config,
223 struct lock_class_key *lock_key,
224 const char *lock_name)
225{
226
227 const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
228
229 if (IS_ERR(bus))
230 return ERR_CAST(bus);
231
232 return __devm_regmap_init(w1_dev, bus, w1_dev, config,
233 lock_key, lock_name);
234}
235EXPORT_SYMBOL_GPL(__devm_regmap_init_w1);
236
237MODULE_LICENSE("GPL");
1/*
2 * Register map access API - W1 (1-Wire) support
3 *
4 * Copyright (c) 2017 Radioavionica Corporation
5 * Author: Alex A. Mihaylov <minimumlaw@rambler.ru>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation
10 */
11
12#include <linux/regmap.h>
13#include <linux/module.h>
14#include <linux/w1.h>
15
16#include "internal.h"
17
18#define W1_CMD_READ_DATA 0x69
19#define W1_CMD_WRITE_DATA 0x6C
20
21/*
22 * 1-Wire slaves registers with addess 8 bit and data 8 bit
23 */
24
25static int w1_reg_a8_v8_read(void *context, unsigned int reg, unsigned int *val)
26{
27 struct device *dev = context;
28 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
29 int ret = 0;
30
31 if (reg > 255)
32 return -EINVAL;
33
34 mutex_lock(&sl->master->bus_mutex);
35 if (!w1_reset_select_slave(sl)) {
36 w1_write_8(sl->master, W1_CMD_READ_DATA);
37 w1_write_8(sl->master, reg);
38 *val = w1_read_8(sl->master);
39 } else {
40 ret = -ENODEV;
41 }
42 mutex_unlock(&sl->master->bus_mutex);
43
44 return ret;
45}
46
47static int w1_reg_a8_v8_write(void *context, unsigned int reg, unsigned int val)
48{
49 struct device *dev = context;
50 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
51 int ret = 0;
52
53 if (reg > 255)
54 return -EINVAL;
55
56 mutex_lock(&sl->master->bus_mutex);
57 if (!w1_reset_select_slave(sl)) {
58 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
59 w1_write_8(sl->master, reg);
60 w1_write_8(sl->master, val);
61 } else {
62 ret = -ENODEV;
63 }
64 mutex_unlock(&sl->master->bus_mutex);
65
66 return ret;
67}
68
69/*
70 * 1-Wire slaves registers with addess 8 bit and data 16 bit
71 */
72
73static int w1_reg_a8_v16_read(void *context, unsigned int reg,
74 unsigned int *val)
75{
76 struct device *dev = context;
77 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
78 int ret = 0;
79
80 if (reg > 255)
81 return -EINVAL;
82
83 mutex_lock(&sl->master->bus_mutex);
84 if (!w1_reset_select_slave(sl)) {
85 w1_write_8(sl->master, W1_CMD_READ_DATA);
86 w1_write_8(sl->master, reg);
87 *val = w1_read_8(sl->master);
88 *val |= w1_read_8(sl->master)<<8;
89 } else {
90 ret = -ENODEV;
91 }
92 mutex_unlock(&sl->master->bus_mutex);
93
94 return ret;
95}
96
97static int w1_reg_a8_v16_write(void *context, unsigned int reg,
98 unsigned int val)
99{
100 struct device *dev = context;
101 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
102 int ret = 0;
103
104 if (reg > 255)
105 return -EINVAL;
106
107 mutex_lock(&sl->master->bus_mutex);
108 if (!w1_reset_select_slave(sl)) {
109 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
110 w1_write_8(sl->master, reg);
111 w1_write_8(sl->master, val & 0x00FF);
112 w1_write_8(sl->master, val>>8 & 0x00FF);
113 } else {
114 ret = -ENODEV;
115 }
116 mutex_unlock(&sl->master->bus_mutex);
117
118 return ret;
119}
120
121/*
122 * 1-Wire slaves registers with addess 16 bit and data 16 bit
123 */
124
125static int w1_reg_a16_v16_read(void *context, unsigned int reg,
126 unsigned int *val)
127{
128 struct device *dev = context;
129 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
130 int ret = 0;
131
132 if (reg > 65535)
133 return -EINVAL;
134
135 mutex_lock(&sl->master->bus_mutex);
136 if (!w1_reset_select_slave(sl)) {
137 w1_write_8(sl->master, W1_CMD_READ_DATA);
138 w1_write_8(sl->master, reg & 0x00FF);
139 w1_write_8(sl->master, reg>>8 & 0x00FF);
140 *val = w1_read_8(sl->master);
141 *val |= w1_read_8(sl->master)<<8;
142 } else {
143 ret = -ENODEV;
144 }
145 mutex_unlock(&sl->master->bus_mutex);
146
147 return ret;
148}
149
150static int w1_reg_a16_v16_write(void *context, unsigned int reg,
151 unsigned int val)
152{
153 struct device *dev = context;
154 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
155 int ret = 0;
156
157 if (reg > 65535)
158 return -EINVAL;
159
160 mutex_lock(&sl->master->bus_mutex);
161 if (!w1_reset_select_slave(sl)) {
162 w1_write_8(sl->master, W1_CMD_WRITE_DATA);
163 w1_write_8(sl->master, reg & 0x00FF);
164 w1_write_8(sl->master, reg>>8 & 0x00FF);
165 w1_write_8(sl->master, val & 0x00FF);
166 w1_write_8(sl->master, val>>8 & 0x00FF);
167 } else {
168 ret = -ENODEV;
169 }
170 mutex_unlock(&sl->master->bus_mutex);
171
172 return ret;
173}
174
175/*
176 * Various types of supported bus addressing
177 */
178
179static struct regmap_bus regmap_w1_bus_a8_v8 = {
180 .reg_read = w1_reg_a8_v8_read,
181 .reg_write = w1_reg_a8_v8_write,
182};
183
184static struct regmap_bus regmap_w1_bus_a8_v16 = {
185 .reg_read = w1_reg_a8_v16_read,
186 .reg_write = w1_reg_a8_v16_write,
187};
188
189static struct regmap_bus regmap_w1_bus_a16_v16 = {
190 .reg_read = w1_reg_a16_v16_read,
191 .reg_write = w1_reg_a16_v16_write,
192};
193
194static const struct regmap_bus *regmap_get_w1_bus(struct device *w1_dev,
195 const struct regmap_config *config)
196{
197 if (config->reg_bits == 8 && config->val_bits == 8)
198 return ®map_w1_bus_a8_v8;
199
200 if (config->reg_bits == 8 && config->val_bits == 16)
201 return ®map_w1_bus_a8_v16;
202
203 if (config->reg_bits == 16 && config->val_bits == 16)
204 return ®map_w1_bus_a16_v16;
205
206 return ERR_PTR(-ENOTSUPP);
207}
208
209struct regmap *__regmap_init_w1(struct device *w1_dev,
210 const struct regmap_config *config,
211 struct lock_class_key *lock_key,
212 const char *lock_name)
213{
214
215 const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
216
217 if (IS_ERR(bus))
218 return ERR_CAST(bus);
219
220 return __regmap_init(w1_dev, bus, w1_dev, config,
221 lock_key, lock_name);
222
223 return NULL;
224}
225EXPORT_SYMBOL_GPL(__regmap_init_w1);
226
227struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
228 const struct regmap_config *config,
229 struct lock_class_key *lock_key,
230 const char *lock_name)
231{
232
233 const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
234
235 if (IS_ERR(bus))
236 return ERR_CAST(bus);
237
238 return __devm_regmap_init(w1_dev, bus, w1_dev, config,
239 lock_key, lock_name);
240
241 return NULL;
242}
243EXPORT_SYMBOL_GPL(__devm_regmap_init_w1);
244
245MODULE_LICENSE("GPL");