Merge remote-tracking branch 'regmap/fix/core' into regmap-linus
[muen/linux.git] / drivers / base / regmap / regmap-i2c.c
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
19 static 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
38 static 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
50 static struct regmap_bus regmap_smbus_byte = {
51         .reg_write = regmap_smbus_byte_reg_write,
52         .reg_read = regmap_smbus_byte_reg_read,
53 };
54
55 static 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
74 static 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
86 static struct regmap_bus regmap_smbus_word = {
87         .reg_write = regmap_smbus_word_reg_write,
88         .reg_read = regmap_smbus_word_reg_read,
89 };
90
91 static 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
110 static 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
122 static 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
127 static 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
142 static 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
176 static 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
204 static 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
212 static 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
228 static 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
250 static 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
257 static 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 &regmap_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 &regmap_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 &regmap_smbus_word;
272                 case REGMAP_ENDIAN_BIG:
273                         return &regmap_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 &regmap_smbus_byte;
281
282         return ERR_PTR(-ENOTSUPP);
283 }
284
285 struct 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 }
298 EXPORT_SYMBOL_GPL(__regmap_init_i2c);
299
300 struct 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 }
313 EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
314
315 MODULE_LICENSE("GPL");