Commit | Line | Data |
---|---|---|
3b51f47b AS |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | ||
3 | /* | |
4 | * EEPROM driver for RAVE SP | |
5 | * | |
6 | * Copyright (C) 2018 Zodiac Inflight Innovations | |
7 | * | |
8 | */ | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/mfd/rave-sp.h> | |
11 | #include <linux/module.h> | |
12 | #include <linux/nvmem-provider.h> | |
13 | #include <linux/of_device.h> | |
14 | #include <linux/platform_device.h> | |
15 | #include <linux/sizes.h> | |
16 | ||
17 | /** | |
18 | * enum rave_sp_eeprom_access_type - Supported types of EEPROM access | |
19 | * | |
20 | * @RAVE_SP_EEPROM_WRITE: EEPROM write | |
21 | * @RAVE_SP_EEPROM_READ: EEPROM read | |
22 | */ | |
23 | enum rave_sp_eeprom_access_type { | |
24 | RAVE_SP_EEPROM_WRITE = 0, | |
25 | RAVE_SP_EEPROM_READ = 1, | |
26 | }; | |
27 | ||
28 | /** | |
29 | * enum rave_sp_eeprom_header_size - EEPROM command header sizes | |
30 | * | |
31 | * @RAVE_SP_EEPROM_HEADER_SMALL: EEPROM header size for "small" devices (< 8K) | |
32 | * @RAVE_SP_EEPROM_HEADER_BIG: EEPROM header size for "big" devices (> 8K) | |
33 | */ | |
34 | enum rave_sp_eeprom_header_size { | |
35 | RAVE_SP_EEPROM_HEADER_SMALL = 4U, | |
36 | RAVE_SP_EEPROM_HEADER_BIG = 5U, | |
37 | }; | |
26d79b82 | 38 | #define RAVE_SP_EEPROM_HEADER_MAX RAVE_SP_EEPROM_HEADER_BIG |
3b51f47b AS |
39 | |
40 | #define RAVE_SP_EEPROM_PAGE_SIZE 32U | |
41 | ||
42 | /** | |
43 | * struct rave_sp_eeprom_page - RAVE SP EEPROM page | |
44 | * | |
45 | * @type: Access type (see enum rave_sp_eeprom_access_type) | |
46 | * @success: Success flag (Success = 1, Failure = 0) | |
47 | * @data: Read data | |
48 | ||
49 | * Note this structure corresponds to RSP_*_EEPROM payload from RAVE | |
50 | * SP ICD | |
51 | */ | |
52 | struct rave_sp_eeprom_page { | |
53 | u8 type; | |
54 | u8 success; | |
55 | u8 data[RAVE_SP_EEPROM_PAGE_SIZE]; | |
56 | } __packed; | |
57 | ||
58 | /** | |
59 | * struct rave_sp_eeprom - RAVE SP EEPROM device | |
60 | * | |
61 | * @sp: Pointer to parent RAVE SP device | |
62 | * @mutex: Lock protecting access to EEPROM | |
63 | * @address: EEPROM device address | |
64 | * @header_size: Size of EEPROM command header for this device | |
65 | * @dev: Pointer to corresponding struct device used for logging | |
66 | */ | |
67 | struct rave_sp_eeprom { | |
68 | struct rave_sp *sp; | |
69 | struct mutex mutex; | |
70 | u8 address; | |
71 | unsigned int header_size; | |
72 | struct device *dev; | |
73 | }; | |
74 | ||
75 | /** | |
76 | * rave_sp_eeprom_io - Low-level part of EEPROM page access | |
77 | * | |
78 | * @eeprom: EEPROM device to write to | |
79 | * @type: EEPROM access type (read or write) | |
80 | * @idx: number of the EEPROM page | |
81 | * @page: Data to write or buffer to store result (via page->data) | |
82 | * | |
83 | * This function does all of the low-level work required to perform a | |
84 | * EEPROM access. This includes formatting correct command payload, | |
85 | * sending it and checking received results. | |
86 | * | |
87 | * Returns zero in case of success or negative error code in | |
88 | * case of failure. | |
89 | */ | |
90 | static int rave_sp_eeprom_io(struct rave_sp_eeprom *eeprom, | |
91 | enum rave_sp_eeprom_access_type type, | |
92 | u16 idx, | |
93 | struct rave_sp_eeprom_page *page) | |
94 | { | |
95 | const bool is_write = type == RAVE_SP_EEPROM_WRITE; | |
96 | const unsigned int data_size = is_write ? sizeof(page->data) : 0; | |
97 | const unsigned int cmd_size = eeprom->header_size + data_size; | |
98 | const unsigned int rsp_size = | |
99 | is_write ? sizeof(*page) - sizeof(page->data) : sizeof(*page); | |
100 | unsigned int offset = 0; | |
26d79b82 | 101 | u8 cmd[RAVE_SP_EEPROM_HEADER_MAX + sizeof(page->data)]; |
3b51f47b AS |
102 | int ret; |
103 | ||
26d79b82 KC |
104 | if (WARN_ON(cmd_size > sizeof(cmd))) |
105 | return -EINVAL; | |
106 | ||
3b51f47b AS |
107 | cmd[offset++] = eeprom->address; |
108 | cmd[offset++] = 0; | |
109 | cmd[offset++] = type; | |
110 | cmd[offset++] = idx; | |
111 | ||
112 | /* | |
113 | * If there's still room in this command's header it means we | |
114 | * are talkin to EEPROM that uses 16-bit page numbers and we | |
115 | * have to specify index's MSB in payload as well. | |
116 | */ | |
117 | if (offset < eeprom->header_size) | |
118 | cmd[offset++] = idx >> 8; | |
119 | /* | |
120 | * Copy our data to write to command buffer first. In case of | |
121 | * a read data_size should be zero and memcpy would become a | |
122 | * no-op | |
123 | */ | |
124 | memcpy(&cmd[offset], page->data, data_size); | |
125 | ||
126 | ret = rave_sp_exec(eeprom->sp, cmd, cmd_size, page, rsp_size); | |
127 | if (ret) | |
128 | return ret; | |
129 | ||
130 | if (page->type != type) | |
131 | return -EPROTO; | |
132 | ||
133 | if (!page->success) | |
134 | return -EIO; | |
135 | ||
136 | return 0; | |
137 | } | |
138 | ||
139 | /** | |
140 | * rave_sp_eeprom_page_access - Access single EEPROM page | |
141 | * | |
142 | * @eeprom: EEPROM device to access | |
143 | * @type: Access type to perform (read or write) | |
144 | * @offset: Offset within EEPROM to access | |
145 | * @data: Data buffer | |
146 | * @data_len: Size of the data buffer | |
147 | * | |
148 | * This function performs a generic access to a single page or a | |
149 | * portion thereof. Requested access MUST NOT cross the EEPROM page | |
150 | * boundary. | |
151 | * | |
152 | * Returns zero in case of success or negative error code in | |
153 | * case of failure. | |
154 | */ | |
155 | static int | |
156 | rave_sp_eeprom_page_access(struct rave_sp_eeprom *eeprom, | |
157 | enum rave_sp_eeprom_access_type type, | |
158 | unsigned int offset, u8 *data, | |
159 | size_t data_len) | |
160 | { | |
161 | const unsigned int page_offset = offset % RAVE_SP_EEPROM_PAGE_SIZE; | |
162 | const unsigned int page_nr = offset / RAVE_SP_EEPROM_PAGE_SIZE; | |
163 | struct rave_sp_eeprom_page page; | |
164 | int ret; | |
165 | ||
166 | /* | |
167 | * This function will not work if data access we've been asked | |
168 | * to do is crossing EEPROM page boundary. Normally this | |
169 | * should never happen and getting here would indicate a bug | |
170 | * in the code. | |
171 | */ | |
172 | if (WARN_ON(data_len > sizeof(page.data) - page_offset)) | |
173 | return -EINVAL; | |
174 | ||
175 | if (type == RAVE_SP_EEPROM_WRITE) { | |
176 | /* | |
177 | * If doing a partial write we need to do a read first | |
178 | * to fill the rest of the page with correct data. | |
179 | */ | |
180 | if (data_len < RAVE_SP_EEPROM_PAGE_SIZE) { | |
181 | ret = rave_sp_eeprom_io(eeprom, RAVE_SP_EEPROM_READ, | |
182 | page_nr, &page); | |
183 | if (ret) | |
184 | return ret; | |
185 | } | |
186 | ||
187 | memcpy(&page.data[page_offset], data, data_len); | |
188 | } | |
189 | ||
190 | ret = rave_sp_eeprom_io(eeprom, type, page_nr, &page); | |
191 | if (ret) | |
192 | return ret; | |
193 | ||
194 | /* | |
195 | * Since we receive the result of the read via 'page.data' | |
196 | * buffer we need to copy that to 'data' | |
197 | */ | |
198 | if (type == RAVE_SP_EEPROM_READ) | |
199 | memcpy(data, &page.data[page_offset], data_len); | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
204 | /** | |
205 | * rave_sp_eeprom_access - Access EEPROM data | |
206 | * | |
207 | * @eeprom: EEPROM device to access | |
208 | * @type: Access type to perform (read or write) | |
209 | * @offset: Offset within EEPROM to access | |
210 | * @data: Data buffer | |
211 | * @data_len: Size of the data buffer | |
212 | * | |
213 | * This function performs a generic access (either read or write) at | |
214 | * arbitrary offset (not necessary page aligned) of arbitrary length | |
215 | * (is not constrained by EEPROM page size). | |
216 | * | |
217 | * Returns zero in case of success or negative error code in case of | |
218 | * failure. | |
219 | */ | |
220 | static int rave_sp_eeprom_access(struct rave_sp_eeprom *eeprom, | |
221 | enum rave_sp_eeprom_access_type type, | |
222 | unsigned int offset, u8 *data, | |
223 | unsigned int data_len) | |
224 | { | |
225 | unsigned int residue; | |
226 | unsigned int chunk; | |
227 | unsigned int head; | |
228 | int ret; | |
229 | ||
230 | mutex_lock(&eeprom->mutex); | |
231 | ||
232 | head = offset % RAVE_SP_EEPROM_PAGE_SIZE; | |
233 | residue = data_len; | |
234 | ||
235 | do { | |
236 | /* | |
237 | * First iteration, if we are doing an access that is | |
238 | * not 32-byte aligned, we need to access only data up | |
239 | * to a page boundary to avoid corssing it in | |
240 | * rave_sp_eeprom_page_access() | |
241 | */ | |
242 | if (unlikely(head)) { | |
243 | chunk = RAVE_SP_EEPROM_PAGE_SIZE - head; | |
244 | /* | |
245 | * This can only happen once per | |
246 | * rave_sp_eeprom_access() call, so we set | |
247 | * head to zero to process all the other | |
248 | * iterations normally. | |
249 | */ | |
250 | head = 0; | |
251 | } else { | |
252 | chunk = RAVE_SP_EEPROM_PAGE_SIZE; | |
253 | } | |
254 | ||
255 | /* | |
256 | * We should never read more that 'residue' bytes | |
257 | */ | |
258 | chunk = min(chunk, residue); | |
259 | ret = rave_sp_eeprom_page_access(eeprom, type, offset, | |
260 | data, chunk); | |
261 | if (ret) | |
262 | goto out; | |
263 | ||
264 | residue -= chunk; | |
265 | offset += chunk; | |
266 | data += chunk; | |
267 | } while (residue); | |
268 | out: | |
269 | mutex_unlock(&eeprom->mutex); | |
270 | return ret; | |
271 | } | |
272 | ||
273 | static int rave_sp_eeprom_reg_read(void *eeprom, unsigned int offset, | |
274 | void *val, size_t bytes) | |
275 | { | |
276 | return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_READ, | |
277 | offset, val, bytes); | |
278 | } | |
279 | ||
280 | static int rave_sp_eeprom_reg_write(void *eeprom, unsigned int offset, | |
281 | void *val, size_t bytes) | |
282 | { | |
283 | return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_WRITE, | |
284 | offset, val, bytes); | |
285 | } | |
286 | ||
287 | static int rave_sp_eeprom_probe(struct platform_device *pdev) | |
288 | { | |
289 | struct device *dev = &pdev->dev; | |
290 | struct rave_sp *sp = dev_get_drvdata(dev->parent); | |
291 | struct device_node *np = dev->of_node; | |
292 | struct nvmem_config config = { 0 }; | |
293 | struct rave_sp_eeprom *eeprom; | |
294 | struct nvmem_device *nvmem; | |
295 | u32 reg[2], size; | |
296 | ||
297 | if (of_property_read_u32_array(np, "reg", reg, ARRAY_SIZE(reg))) { | |
298 | dev_err(dev, "Failed to parse \"reg\" property\n"); | |
299 | return -EINVAL; | |
300 | } | |
301 | ||
302 | size = reg[1]; | |
303 | /* | |
304 | * Per ICD, we have no more than 2 bytes to specify EEPROM | |
305 | * page. | |
306 | */ | |
307 | if (size > U16_MAX * RAVE_SP_EEPROM_PAGE_SIZE) { | |
308 | dev_err(dev, "Specified size is too big\n"); | |
309 | return -EINVAL; | |
310 | } | |
311 | ||
312 | eeprom = devm_kzalloc(dev, sizeof(*eeprom), GFP_KERNEL); | |
313 | if (!eeprom) | |
314 | return -ENOMEM; | |
315 | ||
316 | eeprom->address = reg[0]; | |
317 | eeprom->sp = sp; | |
318 | eeprom->dev = dev; | |
319 | ||
320 | if (size > SZ_8K) | |
321 | eeprom->header_size = RAVE_SP_EEPROM_HEADER_BIG; | |
322 | else | |
323 | eeprom->header_size = RAVE_SP_EEPROM_HEADER_SMALL; | |
324 | ||
325 | mutex_init(&eeprom->mutex); | |
326 | ||
327 | config.id = -1; | |
328 | of_property_read_string(np, "zii,eeprom-name", &config.name); | |
329 | config.priv = eeprom; | |
330 | config.dev = dev; | |
331 | config.size = size; | |
332 | config.reg_read = rave_sp_eeprom_reg_read; | |
333 | config.reg_write = rave_sp_eeprom_reg_write; | |
334 | config.word_size = 1; | |
335 | config.stride = 1; | |
336 | ||
337 | nvmem = devm_nvmem_register(dev, &config); | |
338 | ||
339 | return PTR_ERR_OR_ZERO(nvmem); | |
340 | } | |
341 | ||
342 | static const struct of_device_id rave_sp_eeprom_of_match[] = { | |
343 | { .compatible = "zii,rave-sp-eeprom" }, | |
344 | {} | |
345 | }; | |
346 | MODULE_DEVICE_TABLE(of, rave_sp_eeprom_of_match); | |
347 | ||
348 | static struct platform_driver rave_sp_eeprom_driver = { | |
349 | .probe = rave_sp_eeprom_probe, | |
350 | .driver = { | |
351 | .name = KBUILD_MODNAME, | |
352 | .of_match_table = rave_sp_eeprom_of_match, | |
353 | }, | |
354 | }; | |
355 | module_platform_driver(rave_sp_eeprom_driver); | |
356 | ||
357 | MODULE_LICENSE("GPL"); | |
358 | MODULE_AUTHOR("Andrey Vostrikov <andrey.vostrikov@cogentembedded.com>"); | |
359 | MODULE_AUTHOR("Nikita Yushchenko <nikita.yoush@cogentembedded.com>"); | |
360 | MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>"); | |
361 | MODULE_DESCRIPTION("RAVE SP EEPROM driver"); |