Loading...
1/*
2 * Register map access API - I2C support
3 *
4 * Copyright 2011 Wolfson Microelectronics plc
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.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/regmap.h>
14#include <linux/i2c.h>
15#include <linux/module.h>
16#include <linux/init.h>
17
18static int regmap_i2c_write(struct device *dev, const void *data, size_t count)
19{
20 struct i2c_client *i2c = to_i2c_client(dev);
21 int ret;
22
23 ret = i2c_master_send(i2c, data, count);
24 if (ret == count)
25 return 0;
26 else if (ret < 0)
27 return ret;
28 else
29 return -EIO;
30}
31
32static int regmap_i2c_gather_write(struct device *dev,
33 const void *reg, size_t reg_size,
34 const void *val, size_t val_size)
35{
36 struct i2c_client *i2c = to_i2c_client(dev);
37 struct i2c_msg xfer[2];
38 int ret;
39
40 /* If the I2C controller can't do a gather tell the core, it
41 * will substitute in a linear write for us.
42 */
43 if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_PROTOCOL_MANGLING))
44 return -ENOTSUPP;
45
46 xfer[0].addr = i2c->addr;
47 xfer[0].flags = 0;
48 xfer[0].len = reg_size;
49 xfer[0].buf = (void *)reg;
50
51 xfer[1].addr = i2c->addr;
52 xfer[1].flags = I2C_M_NOSTART;
53 xfer[1].len = val_size;
54 xfer[1].buf = (void *)val;
55
56 ret = i2c_transfer(i2c->adapter, xfer, 2);
57 if (ret == 2)
58 return 0;
59 if (ret < 0)
60 return ret;
61 else
62 return -EIO;
63}
64
65static int regmap_i2c_read(struct device *dev,
66 const void *reg, size_t reg_size,
67 void *val, size_t val_size)
68{
69 struct i2c_client *i2c = to_i2c_client(dev);
70 struct i2c_msg xfer[2];
71 int ret;
72
73 xfer[0].addr = i2c->addr;
74 xfer[0].flags = 0;
75 xfer[0].len = reg_size;
76 xfer[0].buf = (void *)reg;
77
78 xfer[1].addr = i2c->addr;
79 xfer[1].flags = I2C_M_RD;
80 xfer[1].len = val_size;
81 xfer[1].buf = val;
82
83 ret = i2c_transfer(i2c->adapter, xfer, 2);
84 if (ret == 2)
85 return 0;
86 else if (ret < 0)
87 return ret;
88 else
89 return -EIO;
90}
91
92static struct regmap_bus regmap_i2c = {
93 .type = &i2c_bus_type,
94 .write = regmap_i2c_write,
95 .gather_write = regmap_i2c_gather_write,
96 .read = regmap_i2c_read,
97 .owner = THIS_MODULE,
98};
99
100/**
101 * regmap_init_i2c(): Initialise register map
102 *
103 * @i2c: Device that will be interacted with
104 * @config: Configuration for register map
105 *
106 * The return value will be an ERR_PTR() on error or a valid pointer to
107 * a struct regmap.
108 */
109struct regmap *regmap_init_i2c(struct i2c_client *i2c,
110 const struct regmap_config *config)
111{
112 return regmap_init(&i2c->dev, ®map_i2c, config);
113}
114EXPORT_SYMBOL_GPL(regmap_init_i2c);
115
116MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0
2//
3// Register map access API - I2C support
4//
5// Copyright 2011 Wolfson Microelectronics plc
6//
7// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8
9#include <linux/regmap.h>
10#include <linux/i2c.h>
11#include <linux/module.h>
12
13#include "internal.h"
14
15static int regmap_smbus_byte_reg_read(void *context, unsigned int reg,
16 unsigned int *val)
17{
18 struct device *dev = context;
19 struct i2c_client *i2c = to_i2c_client(dev);
20 int ret;
21
22 if (reg > 0xff)
23 return -EINVAL;
24
25 ret = i2c_smbus_read_byte_data(i2c, reg);
26 if (ret < 0)
27 return ret;
28
29 *val = ret;
30
31 return 0;
32}
33
34static int regmap_smbus_byte_reg_write(void *context, unsigned int reg,
35 unsigned int val)
36{
37 struct device *dev = context;
38 struct i2c_client *i2c = to_i2c_client(dev);
39
40 if (val > 0xff || reg > 0xff)
41 return -EINVAL;
42
43 return i2c_smbus_write_byte_data(i2c, reg, val);
44}
45
46static struct regmap_bus regmap_smbus_byte = {
47 .reg_write = regmap_smbus_byte_reg_write,
48 .reg_read = regmap_smbus_byte_reg_read,
49};
50
51static int regmap_smbus_word_reg_read(void *context, unsigned int reg,
52 unsigned int *val)
53{
54 struct device *dev = context;
55 struct i2c_client *i2c = to_i2c_client(dev);
56 int ret;
57
58 if (reg > 0xff)
59 return -EINVAL;
60
61 ret = i2c_smbus_read_word_data(i2c, reg);
62 if (ret < 0)
63 return ret;
64
65 *val = ret;
66
67 return 0;
68}
69
70static int regmap_smbus_word_reg_write(void *context, unsigned int reg,
71 unsigned int val)
72{
73 struct device *dev = context;
74 struct i2c_client *i2c = to_i2c_client(dev);
75
76 if (val > 0xffff || reg > 0xff)
77 return -EINVAL;
78
79 return i2c_smbus_write_word_data(i2c, reg, val);
80}
81
82static struct regmap_bus regmap_smbus_word = {
83 .reg_write = regmap_smbus_word_reg_write,
84 .reg_read = regmap_smbus_word_reg_read,
85};
86
87static int regmap_smbus_word_read_swapped(void *context, unsigned int reg,
88 unsigned int *val)
89{
90 struct device *dev = context;
91 struct i2c_client *i2c = to_i2c_client(dev);
92 int ret;
93
94 if (reg > 0xff)
95 return -EINVAL;
96
97 ret = i2c_smbus_read_word_swapped(i2c, reg);
98 if (ret < 0)
99 return ret;
100
101 *val = ret;
102
103 return 0;
104}
105
106static int regmap_smbus_word_write_swapped(void *context, unsigned int reg,
107 unsigned int val)
108{
109 struct device *dev = context;
110 struct i2c_client *i2c = to_i2c_client(dev);
111
112 if (val > 0xffff || reg > 0xff)
113 return -EINVAL;
114
115 return i2c_smbus_write_word_swapped(i2c, reg, val);
116}
117
118static struct regmap_bus regmap_smbus_word_swapped = {
119 .reg_write = regmap_smbus_word_write_swapped,
120 .reg_read = regmap_smbus_word_read_swapped,
121};
122
123static int regmap_i2c_write(void *context, const void *data, size_t count)
124{
125 struct device *dev = context;
126 struct i2c_client *i2c = to_i2c_client(dev);
127 int ret;
128
129 ret = i2c_master_send(i2c, data, count);
130 if (ret == count)
131 return 0;
132 else if (ret < 0)
133 return ret;
134 else
135 return -EIO;
136}
137
138static int regmap_i2c_gather_write(void *context,
139 const void *reg, size_t reg_size,
140 const void *val, size_t val_size)
141{
142 struct device *dev = context;
143 struct i2c_client *i2c = to_i2c_client(dev);
144 struct i2c_msg xfer[2];
145 int ret;
146
147 /* If the I2C controller can't do a gather tell the core, it
148 * will substitute in a linear write for us.
149 */
150 if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_NOSTART))
151 return -ENOTSUPP;
152
153 xfer[0].addr = i2c->addr;
154 xfer[0].flags = 0;
155 xfer[0].len = reg_size;
156 xfer[0].buf = (void *)reg;
157
158 xfer[1].addr = i2c->addr;
159 xfer[1].flags = I2C_M_NOSTART;
160 xfer[1].len = val_size;
161 xfer[1].buf = (void *)val;
162
163 ret = i2c_transfer(i2c->adapter, xfer, 2);
164 if (ret == 2)
165 return 0;
166 if (ret < 0)
167 return ret;
168 else
169 return -EIO;
170}
171
172static int regmap_i2c_read(void *context,
173 const void *reg, size_t reg_size,
174 void *val, size_t val_size)
175{
176 struct device *dev = context;
177 struct i2c_client *i2c = to_i2c_client(dev);
178 struct i2c_msg xfer[2];
179 int ret;
180
181 xfer[0].addr = i2c->addr;
182 xfer[0].flags = 0;
183 xfer[0].len = reg_size;
184 xfer[0].buf = (void *)reg;
185
186 xfer[1].addr = i2c->addr;
187 xfer[1].flags = I2C_M_RD;
188 xfer[1].len = val_size;
189 xfer[1].buf = val;
190
191 ret = i2c_transfer(i2c->adapter, xfer, 2);
192 if (ret == 2)
193 return 0;
194 else if (ret < 0)
195 return ret;
196 else
197 return -EIO;
198}
199
200static struct regmap_bus regmap_i2c = {
201 .write = regmap_i2c_write,
202 .gather_write = regmap_i2c_gather_write,
203 .read = regmap_i2c_read,
204 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
205 .val_format_endian_default = REGMAP_ENDIAN_BIG,
206};
207
208static int regmap_i2c_smbus_i2c_write(void *context, const void *data,
209 size_t count)
210{
211 struct device *dev = context;
212 struct i2c_client *i2c = to_i2c_client(dev);
213
214 if (count < 1)
215 return -EINVAL;
216
217 --count;
218 return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count,
219 ((u8 *)data + 1));
220}
221
222static int regmap_i2c_smbus_i2c_read(void *context, const void *reg,
223 size_t reg_size, void *val,
224 size_t val_size)
225{
226 struct device *dev = context;
227 struct i2c_client *i2c = to_i2c_client(dev);
228 int ret;
229
230 if (reg_size != 1 || val_size < 1)
231 return -EINVAL;
232
233 ret = i2c_smbus_read_i2c_block_data(i2c, ((u8 *)reg)[0], val_size, val);
234 if (ret == val_size)
235 return 0;
236 else if (ret < 0)
237 return ret;
238 else
239 return -EIO;
240}
241
242static struct regmap_bus regmap_i2c_smbus_i2c_block = {
243 .write = regmap_i2c_smbus_i2c_write,
244 .read = regmap_i2c_smbus_i2c_read,
245 .max_raw_read = I2C_SMBUS_BLOCK_MAX,
246 .max_raw_write = I2C_SMBUS_BLOCK_MAX,
247};
248
249static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
250 const struct regmap_config *config)
251{
252 if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
253 return ®map_i2c;
254 else if (config->val_bits == 8 && config->reg_bits == 8 &&
255 i2c_check_functionality(i2c->adapter,
256 I2C_FUNC_SMBUS_I2C_BLOCK))
257 return ®map_i2c_smbus_i2c_block;
258 else if (config->val_bits == 16 && config->reg_bits == 8 &&
259 i2c_check_functionality(i2c->adapter,
260 I2C_FUNC_SMBUS_WORD_DATA))
261 switch (regmap_get_val_endian(&i2c->dev, NULL, config)) {
262 case REGMAP_ENDIAN_LITTLE:
263 return ®map_smbus_word;
264 case REGMAP_ENDIAN_BIG:
265 return ®map_smbus_word_swapped;
266 default: /* everything else is not supported */
267 break;
268 }
269 else if (config->val_bits == 8 && config->reg_bits == 8 &&
270 i2c_check_functionality(i2c->adapter,
271 I2C_FUNC_SMBUS_BYTE_DATA))
272 return ®map_smbus_byte;
273
274 return ERR_PTR(-ENOTSUPP);
275}
276
277struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
278 const struct regmap_config *config,
279 struct lock_class_key *lock_key,
280 const char *lock_name)
281{
282 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
283
284 if (IS_ERR(bus))
285 return ERR_CAST(bus);
286
287 return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
288 lock_key, lock_name);
289}
290EXPORT_SYMBOL_GPL(__regmap_init_i2c);
291
292struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
293 const struct regmap_config *config,
294 struct lock_class_key *lock_key,
295 const char *lock_name)
296{
297 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
298
299 if (IS_ERR(bus))
300 return ERR_CAST(bus);
301
302 return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
303 lock_key, lock_name);
304}
305EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
306
307MODULE_LICENSE("GPL");