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.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 };
38 #define RAVE_SP_EEPROM_HEADER_MAX	RAVE_SP_EEPROM_HEADER_BIG
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;
101 	u8 cmd[RAVE_SP_EEPROM_HEADER_MAX + sizeof(page->data)];
102 	int ret;
103 
104 	if (WARN_ON(cmd_size > sizeof(cmd)))
105 		return -EINVAL;
106 
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");
362