Loading...
1/*
2 * Register map access API - SPMI support
3 *
4 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
5 *
6 * Based on regmap-i2c.c:
7 * Copyright 2011 Wolfson Microelectronics plc
8 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 and
12 * only version 2 as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 */
20#include <linux/regmap.h>
21#include <linux/spmi.h>
22#include <linux/module.h>
23#include <linux/init.h>
24
25static int regmap_spmi_base_read(void *context,
26 const void *reg, size_t reg_size,
27 void *val, size_t val_size)
28{
29 u8 addr = *(u8 *)reg;
30 int err = 0;
31
32 BUG_ON(reg_size != 1);
33
34 while (val_size-- && !err)
35 err = spmi_register_read(context, addr++, val++);
36
37 return err;
38}
39
40static int regmap_spmi_base_gather_write(void *context,
41 const void *reg, size_t reg_size,
42 const void *val, size_t val_size)
43{
44 const u8 *data = val;
45 u8 addr = *(u8 *)reg;
46 int err = 0;
47
48 BUG_ON(reg_size != 1);
49
50 /*
51 * SPMI defines a more bandwidth-efficient 'Register 0 Write' sequence,
52 * use it when possible.
53 */
54 if (addr == 0 && val_size) {
55 err = spmi_register_zero_write(context, *data);
56 if (err)
57 goto err_out;
58
59 data++;
60 addr++;
61 val_size--;
62 }
63
64 while (val_size) {
65 err = spmi_register_write(context, addr, *data);
66 if (err)
67 goto err_out;
68
69 data++;
70 addr++;
71 val_size--;
72 }
73
74err_out:
75 return err;
76}
77
78static int regmap_spmi_base_write(void *context, const void *data,
79 size_t count)
80{
81 BUG_ON(count < 1);
82 return regmap_spmi_base_gather_write(context, data, 1, data + 1,
83 count - 1);
84}
85
86static struct regmap_bus regmap_spmi_base = {
87 .read = regmap_spmi_base_read,
88 .write = regmap_spmi_base_write,
89 .gather_write = regmap_spmi_base_gather_write,
90 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
91 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
92};
93
94/**
95 * regmap_init_spmi_base(): Create regmap for the Base register space
96 * @sdev: SPMI device that will be interacted with
97 * @config: Configuration for register map
98 *
99 * The return value will be an ERR_PTR() on error or a valid pointer to
100 * a struct regmap.
101 */
102struct regmap *regmap_init_spmi_base(struct spmi_device *sdev,
103 const struct regmap_config *config)
104{
105 return regmap_init(&sdev->dev, ®map_spmi_base, sdev, config);
106}
107EXPORT_SYMBOL_GPL(regmap_init_spmi_base);
108
109/**
110 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
111 * @sdev: SPMI device that will be interacted with
112 * @config: Configuration for register map
113 *
114 * The return value will be an ERR_PTR() on error or a valid pointer
115 * to a struct regmap. The regmap will be automatically freed by the
116 * device management code.
117 */
118struct regmap *devm_regmap_init_spmi_base(struct spmi_device *sdev,
119 const struct regmap_config *config)
120{
121 return devm_regmap_init(&sdev->dev, ®map_spmi_base, sdev, config);
122}
123EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_base);
124
125static int regmap_spmi_ext_read(void *context,
126 const void *reg, size_t reg_size,
127 void *val, size_t val_size)
128{
129 int err = 0;
130 size_t len;
131 u16 addr;
132
133 BUG_ON(reg_size != 2);
134
135 addr = *(u16 *)reg;
136
137 /*
138 * Split accesses into two to take advantage of the more
139 * bandwidth-efficient 'Extended Register Read' command when possible
140 */
141 while (addr <= 0xFF && val_size) {
142 len = min_t(size_t, val_size, 16);
143
144 err = spmi_ext_register_read(context, addr, val, len);
145 if (err)
146 goto err_out;
147
148 addr += len;
149 val += len;
150 val_size -= len;
151 }
152
153 while (val_size) {
154 len = min_t(size_t, val_size, 8);
155
156 err = spmi_ext_register_readl(context, addr, val, val_size);
157 if (err)
158 goto err_out;
159
160 addr += len;
161 val += len;
162 val_size -= len;
163 }
164
165err_out:
166 return err;
167}
168
169static int regmap_spmi_ext_gather_write(void *context,
170 const void *reg, size_t reg_size,
171 const void *val, size_t val_size)
172{
173 int err = 0;
174 size_t len;
175 u16 addr;
176
177 BUG_ON(reg_size != 2);
178
179 addr = *(u16 *)reg;
180
181 while (addr <= 0xFF && val_size) {
182 len = min_t(size_t, val_size, 16);
183
184 err = spmi_ext_register_write(context, addr, val, len);
185 if (err)
186 goto err_out;
187
188 addr += len;
189 val += len;
190 val_size -= len;
191 }
192
193 while (val_size) {
194 len = min_t(size_t, val_size, 8);
195
196 err = spmi_ext_register_writel(context, addr, val, len);
197 if (err)
198 goto err_out;
199
200 addr += len;
201 val += len;
202 val_size -= len;
203 }
204
205err_out:
206 return err;
207}
208
209static int regmap_spmi_ext_write(void *context, const void *data,
210 size_t count)
211{
212 BUG_ON(count < 2);
213 return regmap_spmi_ext_gather_write(context, data, 2, data + 2,
214 count - 2);
215}
216
217static struct regmap_bus regmap_spmi_ext = {
218 .read = regmap_spmi_ext_read,
219 .write = regmap_spmi_ext_write,
220 .gather_write = regmap_spmi_ext_gather_write,
221 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
222 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
223};
224
225/**
226 * regmap_init_spmi_ext(): Create regmap for Ext register space
227 * @sdev: Device that will be interacted with
228 * @config: Configuration for register map
229 *
230 * The return value will be an ERR_PTR() on error or a valid pointer to
231 * a struct regmap.
232 */
233struct regmap *regmap_init_spmi_ext(struct spmi_device *sdev,
234 const struct regmap_config *config)
235{
236 return regmap_init(&sdev->dev, ®map_spmi_ext, sdev, config);
237}
238EXPORT_SYMBOL_GPL(regmap_init_spmi_ext);
239
240/**
241 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
242 * @sdev: SPMI device that will be interacted with
243 * @config: Configuration for register map
244 *
245 * The return value will be an ERR_PTR() on error or a valid pointer
246 * to a struct regmap. The regmap will be automatically freed by the
247 * device management code.
248 */
249struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *sdev,
250 const struct regmap_config *config)
251{
252 return devm_regmap_init(&sdev->dev, ®map_spmi_ext, sdev, config);
253}
254EXPORT_SYMBOL_GPL(devm_regmap_init_spmi_ext);
255
256MODULE_LICENSE("GPL");
1/*
2 * Register map access API - SPMI support
3 *
4 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
5 *
6 * Based on regmap-i2c.c:
7 * Copyright 2011 Wolfson Microelectronics plc
8 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 and
12 * only version 2 as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 */
20#include <linux/regmap.h>
21#include <linux/spmi.h>
22#include <linux/module.h>
23#include <linux/init.h>
24
25static int regmap_spmi_base_read(void *context,
26 const void *reg, size_t reg_size,
27 void *val, size_t val_size)
28{
29 u8 addr = *(u8 *)reg;
30 int err = 0;
31
32 BUG_ON(reg_size != 1);
33
34 while (val_size-- && !err)
35 err = spmi_register_read(context, addr++, val++);
36
37 return err;
38}
39
40static int regmap_spmi_base_gather_write(void *context,
41 const void *reg, size_t reg_size,
42 const void *val, size_t val_size)
43{
44 const u8 *data = val;
45 u8 addr = *(u8 *)reg;
46 int err = 0;
47
48 BUG_ON(reg_size != 1);
49
50 /*
51 * SPMI defines a more bandwidth-efficient 'Register 0 Write' sequence,
52 * use it when possible.
53 */
54 if (addr == 0 && val_size) {
55 err = spmi_register_zero_write(context, *data);
56 if (err)
57 goto err_out;
58
59 data++;
60 addr++;
61 val_size--;
62 }
63
64 while (val_size) {
65 err = spmi_register_write(context, addr, *data);
66 if (err)
67 goto err_out;
68
69 data++;
70 addr++;
71 val_size--;
72 }
73
74err_out:
75 return err;
76}
77
78static int regmap_spmi_base_write(void *context, const void *data,
79 size_t count)
80{
81 BUG_ON(count < 1);
82 return regmap_spmi_base_gather_write(context, data, 1, data + 1,
83 count - 1);
84}
85
86static struct regmap_bus regmap_spmi_base = {
87 .read = regmap_spmi_base_read,
88 .write = regmap_spmi_base_write,
89 .gather_write = regmap_spmi_base_gather_write,
90 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
91 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
92};
93
94struct regmap *__regmap_init_spmi_base(struct spmi_device *sdev,
95 const struct regmap_config *config,
96 struct lock_class_key *lock_key,
97 const char *lock_name)
98{
99 return __regmap_init(&sdev->dev, ®map_spmi_base, sdev, config,
100 lock_key, lock_name);
101}
102EXPORT_SYMBOL_GPL(__regmap_init_spmi_base);
103
104struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *sdev,
105 const struct regmap_config *config,
106 struct lock_class_key *lock_key,
107 const char *lock_name)
108{
109 return __devm_regmap_init(&sdev->dev, ®map_spmi_base, sdev, config,
110 lock_key, lock_name);
111}
112EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_base);
113
114static int regmap_spmi_ext_read(void *context,
115 const void *reg, size_t reg_size,
116 void *val, size_t val_size)
117{
118 int err = 0;
119 size_t len;
120 u16 addr;
121
122 BUG_ON(reg_size != 2);
123
124 addr = *(u16 *)reg;
125
126 /*
127 * Split accesses into two to take advantage of the more
128 * bandwidth-efficient 'Extended Register Read' command when possible
129 */
130 while (addr <= 0xFF && val_size) {
131 len = min_t(size_t, val_size, 16);
132
133 err = spmi_ext_register_read(context, addr, val, len);
134 if (err)
135 goto err_out;
136
137 addr += len;
138 val += len;
139 val_size -= len;
140 }
141
142 while (val_size) {
143 len = min_t(size_t, val_size, 8);
144
145 err = spmi_ext_register_readl(context, addr, val, len);
146 if (err)
147 goto err_out;
148
149 addr += len;
150 val += len;
151 val_size -= len;
152 }
153
154err_out:
155 return err;
156}
157
158static int regmap_spmi_ext_gather_write(void *context,
159 const void *reg, size_t reg_size,
160 const void *val, size_t val_size)
161{
162 int err = 0;
163 size_t len;
164 u16 addr;
165
166 BUG_ON(reg_size != 2);
167
168 addr = *(u16 *)reg;
169
170 while (addr <= 0xFF && val_size) {
171 len = min_t(size_t, val_size, 16);
172
173 err = spmi_ext_register_write(context, addr, val, len);
174 if (err)
175 goto err_out;
176
177 addr += len;
178 val += len;
179 val_size -= len;
180 }
181
182 while (val_size) {
183 len = min_t(size_t, val_size, 8);
184
185 err = spmi_ext_register_writel(context, addr, val, len);
186 if (err)
187 goto err_out;
188
189 addr += len;
190 val += len;
191 val_size -= len;
192 }
193
194err_out:
195 return err;
196}
197
198static int regmap_spmi_ext_write(void *context, const void *data,
199 size_t count)
200{
201 BUG_ON(count < 2);
202 return regmap_spmi_ext_gather_write(context, data, 2, data + 2,
203 count - 2);
204}
205
206static struct regmap_bus regmap_spmi_ext = {
207 .read = regmap_spmi_ext_read,
208 .write = regmap_spmi_ext_write,
209 .gather_write = regmap_spmi_ext_gather_write,
210 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
211 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
212};
213
214struct regmap *__regmap_init_spmi_ext(struct spmi_device *sdev,
215 const struct regmap_config *config,
216 struct lock_class_key *lock_key,
217 const char *lock_name)
218{
219 return __regmap_init(&sdev->dev, ®map_spmi_ext, sdev, config,
220 lock_key, lock_name);
221}
222EXPORT_SYMBOL_GPL(__regmap_init_spmi_ext);
223
224struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *sdev,
225 const struct regmap_config *config,
226 struct lock_class_key *lock_key,
227 const char *lock_name)
228{
229 return __devm_regmap_init(&sdev->dev, ®map_spmi_ext, sdev, config,
230 lock_key, lock_name);
231}
232EXPORT_SYMBOL_GPL(__devm_regmap_init_spmi_ext);
233
234MODULE_LICENSE("GPL");