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