1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  linux/drivers/spi/spi-loopback-test.c
4  *
5  *  (c) Martin Sperl <kernel@martin.sperl.org>
6  *
7  *  Loopback test driver to test several typical spi_message conditions
8  *  that a spi_master driver may encounter
9  *  this can also get used for regression testing
10  */
11 
12 #include <linux/delay.h>
13 #include <linux/kernel.h>
14 #include <linux/ktime.h>
15 #include <linux/list.h>
16 #include <linux/list_sort.h>
17 #include <linux/module.h>
18 #include <linux/of_device.h>
19 #include <linux/printk.h>
20 #include <linux/vmalloc.h>
21 #include <linux/spi/spi.h>
22 
23 #include "spi-test.h"
24 
25 /* flag to only simulate transfers */
26 static int simulate_only;
27 module_param(simulate_only, int, 0);
28 MODULE_PARM_DESC(simulate_only, "if not 0 do not execute the spi message");
29 
30 /* dump spi messages */
31 static int dump_messages;
32 module_param(dump_messages, int, 0);
33 MODULE_PARM_DESC(dump_messages,
34 		 "=1 dump the basic spi_message_structure, " \
35 		 "=2 dump the spi_message_structure including data, " \
36 		 "=3 dump the spi_message structure before and after execution");
37 /* the device is jumpered for loopback - enabling some rx_buf tests */
38 static int loopback;
39 module_param(loopback, int, 0);
40 MODULE_PARM_DESC(loopback,
41 		 "if set enable loopback mode, where the rx_buf "	\
42 		 "is checked to match tx_buf after the spi_message "	\
43 		 "is executed");
44 
45 static int loop_req;
46 module_param(loop_req, int, 0);
47 MODULE_PARM_DESC(loop_req,
48 		 "if set controller will be asked to enable test loop mode. " \
49 		 "If controller supported it, MISO and MOSI will be connected");
50 
51 static int no_cs;
52 module_param(no_cs, int, 0);
53 MODULE_PARM_DESC(no_cs,
54 		 "if set Chip Select (CS) will not be used");
55 
56 /* run tests only for a specific length */
57 static int run_only_iter_len = -1;
58 module_param(run_only_iter_len, int, 0);
59 MODULE_PARM_DESC(run_only_iter_len,
60 		 "only run tests for a length of this number in iterate_len list");
61 
62 /* run only a specific test */
63 static int run_only_test = -1;
64 module_param(run_only_test, int, 0);
65 MODULE_PARM_DESC(run_only_test,
66 		 "only run the test with this number (0-based !)");
67 
68 /* use vmalloc'ed buffers */
69 static int use_vmalloc;
70 module_param(use_vmalloc, int, 0644);
71 MODULE_PARM_DESC(use_vmalloc,
72 		 "use vmalloc'ed buffers instead of kmalloc'ed");
73 
74 /* check rx ranges */
75 static int check_ranges = 1;
76 module_param(check_ranges, int, 0644);
77 MODULE_PARM_DESC(check_ranges,
78 		 "checks rx_buffer pattern are valid");
79 
80 static unsigned int delay_ms = 100;
81 module_param(delay_ms, uint, 0644);
82 MODULE_PARM_DESC(delay_ms,
83 		 "delay between tests, in milliseconds (default: 100)");
84 
85 /* the actual tests to execute */
86 static struct spi_test spi_tests[] = {
87 	{
88 		.description	= "tx/rx-transfer - start of page",
89 		.fill_option	= FILL_COUNT_8,
90 		.iterate_len    = { ITERATE_MAX_LEN },
91 		.iterate_tx_align = ITERATE_ALIGN,
92 		.iterate_rx_align = ITERATE_ALIGN,
93 		.transfer_count = 1,
94 		.transfers		= {
95 			{
96 				.tx_buf = TX(0),
97 				.rx_buf = RX(0),
98 			},
99 		},
100 	},
101 	{
102 		.description	= "tx/rx-transfer - crossing PAGE_SIZE",
103 		.fill_option	= FILL_COUNT_8,
104 		.iterate_len    = { ITERATE_LEN },
105 		.iterate_tx_align = ITERATE_ALIGN,
106 		.iterate_rx_align = ITERATE_ALIGN,
107 		.transfer_count = 1,
108 		.transfers		= {
109 			{
110 				.tx_buf = TX(PAGE_SIZE - 4),
111 				.rx_buf = RX(PAGE_SIZE - 4),
112 			},
113 		},
114 	},
115 	{
116 		.description	= "tx-transfer - only",
117 		.fill_option	= FILL_COUNT_8,
118 		.iterate_len    = { ITERATE_MAX_LEN },
119 		.iterate_tx_align = ITERATE_ALIGN,
120 		.transfer_count = 1,
121 		.transfers		= {
122 			{
123 				.tx_buf = TX(0),
124 			},
125 		},
126 	},
127 	{
128 		.description	= "rx-transfer - only",
129 		.fill_option	= FILL_COUNT_8,
130 		.iterate_len    = { ITERATE_MAX_LEN },
131 		.iterate_rx_align = ITERATE_ALIGN,
132 		.transfer_count = 1,
133 		.transfers		= {
134 			{
135 				.rx_buf = RX(0),
136 			},
137 		},
138 	},
139 	{
140 		.description	= "two tx-transfers - alter both",
141 		.fill_option	= FILL_COUNT_8,
142 		.iterate_len    = { ITERATE_LEN },
143 		.iterate_tx_align = ITERATE_ALIGN,
144 		.iterate_transfer_mask = BIT(0) | BIT(1),
145 		.transfer_count = 2,
146 		.transfers		= {
147 			{
148 				.tx_buf = TX(0),
149 			},
150 			{
151 				/* this is why we cant use ITERATE_MAX_LEN */
152 				.tx_buf = TX(SPI_TEST_MAX_SIZE_HALF),
153 			},
154 		},
155 	},
156 	{
157 		.description	= "two tx-transfers - alter first",
158 		.fill_option	= FILL_COUNT_8,
159 		.iterate_len    = { ITERATE_MAX_LEN },
160 		.iterate_tx_align = ITERATE_ALIGN,
161 		.iterate_transfer_mask = BIT(0),
162 		.transfer_count = 2,
163 		.transfers		= {
164 			{
165 				.tx_buf = TX(64),
166 			},
167 			{
168 				.len = 1,
169 				.tx_buf = TX(0),
170 			},
171 		},
172 	},
173 	{
174 		.description	= "two tx-transfers - alter second",
175 		.fill_option	= FILL_COUNT_8,
176 		.iterate_len    = { ITERATE_MAX_LEN },
177 		.iterate_tx_align = ITERATE_ALIGN,
178 		.iterate_transfer_mask = BIT(1),
179 		.transfer_count = 2,
180 		.transfers		= {
181 			{
182 				.len = 16,
183 				.tx_buf = TX(0),
184 			},
185 			{
186 				.tx_buf = TX(64),
187 			},
188 		},
189 	},
190 	{
191 		.description	= "two transfers tx then rx - alter both",
192 		.fill_option	= FILL_COUNT_8,
193 		.iterate_len    = { ITERATE_MAX_LEN },
194 		.iterate_tx_align = ITERATE_ALIGN,
195 		.iterate_transfer_mask = BIT(0) | BIT(1),
196 		.transfer_count = 2,
197 		.transfers		= {
198 			{
199 				.tx_buf = TX(0),
200 			},
201 			{
202 				.rx_buf = RX(0),
203 			},
204 		},
205 	},
206 	{
207 		.description	= "two transfers tx then rx - alter tx",
208 		.fill_option	= FILL_COUNT_8,
209 		.iterate_len    = { ITERATE_MAX_LEN },
210 		.iterate_tx_align = ITERATE_ALIGN,
211 		.iterate_transfer_mask = BIT(0),
212 		.transfer_count = 2,
213 		.transfers		= {
214 			{
215 				.tx_buf = TX(0),
216 			},
217 			{
218 				.len = 1,
219 				.rx_buf = RX(0),
220 			},
221 		},
222 	},
223 	{
224 		.description	= "two transfers tx then rx - alter rx",
225 		.fill_option	= FILL_COUNT_8,
226 		.iterate_len    = { ITERATE_MAX_LEN },
227 		.iterate_tx_align = ITERATE_ALIGN,
228 		.iterate_transfer_mask = BIT(1),
229 		.transfer_count = 2,
230 		.transfers		= {
231 			{
232 				.len = 1,
233 				.tx_buf = TX(0),
234 			},
235 			{
236 				.rx_buf = RX(0),
237 			},
238 		},
239 	},
240 	{
241 		.description	= "two tx+rx transfers - alter both",
242 		.fill_option	= FILL_COUNT_8,
243 		.iterate_len    = { ITERATE_LEN },
244 		.iterate_tx_align = ITERATE_ALIGN,
245 		.iterate_transfer_mask = BIT(0) | BIT(1),
246 		.transfer_count = 2,
247 		.transfers		= {
248 			{
249 				.tx_buf = TX(0),
250 				.rx_buf = RX(0),
251 			},
252 			{
253 				/* making sure we align without overwrite
254 				 * the reason we can not use ITERATE_MAX_LEN
255 				 */
256 				.tx_buf = TX(SPI_TEST_MAX_SIZE_HALF),
257 				.rx_buf = RX(SPI_TEST_MAX_SIZE_HALF),
258 			},
259 		},
260 	},
261 	{
262 		.description	= "two tx+rx transfers - alter first",
263 		.fill_option	= FILL_COUNT_8,
264 		.iterate_len    = { ITERATE_MAX_LEN },
265 		.iterate_tx_align = ITERATE_ALIGN,
266 		.iterate_transfer_mask = BIT(0),
267 		.transfer_count = 2,
268 		.transfers		= {
269 			{
270 				/* making sure we align without overwrite */
271 				.tx_buf = TX(1024),
272 				.rx_buf = RX(1024),
273 			},
274 			{
275 				.len = 1,
276 				/* making sure we align without overwrite */
277 				.tx_buf = TX(0),
278 				.rx_buf = RX(0),
279 			},
280 		},
281 	},
282 	{
283 		.description	= "two tx+rx transfers - alter second",
284 		.fill_option	= FILL_COUNT_8,
285 		.iterate_len    = { ITERATE_MAX_LEN },
286 		.iterate_tx_align = ITERATE_ALIGN,
287 		.iterate_transfer_mask = BIT(1),
288 		.transfer_count = 2,
289 		.transfers		= {
290 			{
291 				.len = 1,
292 				.tx_buf = TX(0),
293 				.rx_buf = RX(0),
294 			},
295 			{
296 				/* making sure we align without overwrite */
297 				.tx_buf = TX(1024),
298 				.rx_buf = RX(1024),
299 			},
300 		},
301 	},
302 	{
303 		.description	= "two tx+rx transfers - delay after transfer",
304 		.fill_option	= FILL_COUNT_8,
305 		.iterate_len    = { ITERATE_MAX_LEN },
306 		.iterate_transfer_mask = BIT(0) | BIT(1),
307 		.transfer_count = 2,
308 		.transfers		= {
309 			{
310 				.tx_buf = TX(0),
311 				.rx_buf = RX(0),
312 				.delay = {
313 					.value = 1000,
314 					.unit = SPI_DELAY_UNIT_USECS,
315 				},
316 			},
317 			{
318 				.tx_buf = TX(0),
319 				.rx_buf = RX(0),
320 				.delay = {
321 					.value = 1000,
322 					.unit = SPI_DELAY_UNIT_USECS,
323 				},
324 			},
325 		},
326 	},
327 	{
328 		.description	= "three tx+rx transfers with overlapping cache lines",
329 		.fill_option	= FILL_COUNT_8,
330 		/*
331 		 * This should be large enough for the controller driver to
332 		 * choose to transfer it with DMA.
333 		 */
334 		.iterate_len    = { 512, -1 },
335 		.iterate_transfer_mask = BIT(1),
336 		.transfer_count = 3,
337 		.transfers		= {
338 			{
339 				.len = 1,
340 				.tx_buf = TX(0),
341 				.rx_buf = RX(0),
342 			},
343 			{
344 				.tx_buf = TX(1),
345 				.rx_buf = RX(1),
346 			},
347 			{
348 				.len = 1,
349 				.tx_buf = TX(513),
350 				.rx_buf = RX(513),
351 			},
352 		},
353 	},
354 
355 	{ /* end of tests sequence */ }
356 };
357 
358 static int spi_loopback_test_probe(struct spi_device *spi)
359 {
360 	int ret;
361 
362 	if (loop_req || no_cs) {
363 		spi->mode |= loop_req ? SPI_LOOP : 0;
364 		spi->mode |= no_cs ? SPI_NO_CS : 0;
365 		ret = spi_setup(spi);
366 		if (ret) {
367 			dev_err(&spi->dev, "SPI setup with SPI_LOOP or SPI_NO_CS failed (%d)\n",
368 				ret);
369 			return ret;
370 		}
371 	}
372 
373 	dev_info(&spi->dev, "Executing spi-loopback-tests\n");
374 
375 	ret = spi_test_run_tests(spi, spi_tests);
376 
377 	dev_info(&spi->dev, "Finished spi-loopback-tests with return: %i\n",
378 		 ret);
379 
380 	return ret;
381 }
382 
383 /* non const match table to permit to change via a module parameter */
384 static struct of_device_id spi_loopback_test_of_match[] = {
385 	{ .compatible	= "linux,spi-loopback-test", },
386 	{ }
387 };
388 
389 /* allow to override the compatible string via a module_parameter */
390 module_param_string(compatible, spi_loopback_test_of_match[0].compatible,
391 		    sizeof(spi_loopback_test_of_match[0].compatible),
392 		    0000);
393 
394 MODULE_DEVICE_TABLE(of, spi_loopback_test_of_match);
395 
396 static struct spi_driver spi_loopback_test_driver = {
397 	.driver = {
398 		.name = "spi-loopback-test",
399 		.owner = THIS_MODULE,
400 		.of_match_table = spi_loopback_test_of_match,
401 	},
402 	.probe = spi_loopback_test_probe,
403 };
404 
405 module_spi_driver(spi_loopback_test_driver);
406 
407 MODULE_AUTHOR("Martin Sperl <kernel@martin.sperl.org>");
408 MODULE_DESCRIPTION("test spi_driver to check core functionality");
409 MODULE_LICENSE("GPL");
410 
411 /*-------------------------------------------------------------------------*/
412 
413 /* spi_test implementation */
414 
415 #define RANGE_CHECK(ptr, plen, start, slen) \
416 	((ptr >= start) && (ptr + plen <= start + slen))
417 
418 /* we allocate one page more, to allow for offsets */
419 #define SPI_TEST_MAX_SIZE_PLUS (SPI_TEST_MAX_SIZE + PAGE_SIZE)
420 
421 static void spi_test_print_hex_dump(char *pre, const void *ptr, size_t len)
422 {
423 	/* limit the hex_dump */
424 	if (len < 1024) {
425 		print_hex_dump(KERN_INFO, pre,
426 			       DUMP_PREFIX_OFFSET, 16, 1,
427 			       ptr, len, 0);
428 		return;
429 	}
430 	/* print head */
431 	print_hex_dump(KERN_INFO, pre,
432 		       DUMP_PREFIX_OFFSET, 16, 1,
433 		       ptr, 512, 0);
434 	/* print tail */
435 	pr_info("%s truncated - continuing at offset %04zx\n",
436 		pre, len - 512);
437 	print_hex_dump(KERN_INFO, pre,
438 		       DUMP_PREFIX_OFFSET, 16, 1,
439 		       ptr + (len - 512), 512, 0);
440 }
441 
442 static void spi_test_dump_message(struct spi_device *spi,
443 				  struct spi_message *msg,
444 				  bool dump_data)
445 {
446 	struct spi_transfer *xfer;
447 	int i;
448 	u8 b;
449 
450 	dev_info(&spi->dev, "  spi_msg@%pK\n", msg);
451 	if (msg->status)
452 		dev_info(&spi->dev, "    status:        %i\n",
453 			 msg->status);
454 	dev_info(&spi->dev, "    frame_length:  %i\n",
455 		 msg->frame_length);
456 	dev_info(&spi->dev, "    actual_length: %i\n",
457 		 msg->actual_length);
458 
459 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
460 		dev_info(&spi->dev, "    spi_transfer@%pK\n", xfer);
461 		dev_info(&spi->dev, "      len:    %i\n", xfer->len);
462 		dev_info(&spi->dev, "      tx_buf: %pK\n", xfer->tx_buf);
463 		if (dump_data && xfer->tx_buf)
464 			spi_test_print_hex_dump("          TX: ",
465 						xfer->tx_buf,
466 						xfer->len);
467 
468 		dev_info(&spi->dev, "      rx_buf: %pK\n", xfer->rx_buf);
469 		if (dump_data && xfer->rx_buf)
470 			spi_test_print_hex_dump("          RX: ",
471 						xfer->rx_buf,
472 						xfer->len);
473 		/* check for unwritten test pattern on rx_buf */
474 		if (xfer->rx_buf) {
475 			for (i = 0 ; i < xfer->len ; i++) {
476 				b = ((u8 *)xfer->rx_buf)[xfer->len - 1 - i];
477 				if (b != SPI_TEST_PATTERN_UNWRITTEN)
478 					break;
479 			}
480 			if (i)
481 				dev_info(&spi->dev,
482 					 "      rx_buf filled with %02x starts at offset: %i\n",
483 					 SPI_TEST_PATTERN_UNWRITTEN,
484 					 xfer->len - i);
485 		}
486 	}
487 }
488 
489 struct rx_ranges {
490 	struct list_head list;
491 	u8 *start;
492 	u8 *end;
493 };
494 
495 static int rx_ranges_cmp(void *priv, const struct list_head *a,
496 			 const struct list_head *b)
497 {
498 	struct rx_ranges *rx_a = list_entry(a, struct rx_ranges, list);
499 	struct rx_ranges *rx_b = list_entry(b, struct rx_ranges, list);
500 
501 	if (rx_a->start > rx_b->start)
502 		return 1;
503 	if (rx_a->start < rx_b->start)
504 		return -1;
505 	return 0;
506 }
507 
508 static int spi_check_rx_ranges(struct spi_device *spi,
509 			       struct spi_message *msg,
510 			       void *rx)
511 {
512 	struct spi_transfer *xfer;
513 	struct rx_ranges ranges[SPI_TEST_MAX_TRANSFERS], *r;
514 	int i = 0;
515 	LIST_HEAD(ranges_list);
516 	u8 *addr;
517 	int ret = 0;
518 
519 	/* loop over all transfers to fill in the rx_ranges */
520 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
521 		/* if there is no rx, then no check is needed */
522 		if (!xfer->rx_buf)
523 			continue;
524 		/* fill in the rx_range */
525 		if (RANGE_CHECK(xfer->rx_buf, xfer->len,
526 				rx, SPI_TEST_MAX_SIZE_PLUS)) {
527 			ranges[i].start = xfer->rx_buf;
528 			ranges[i].end = xfer->rx_buf + xfer->len;
529 			list_add(&ranges[i].list, &ranges_list);
530 			i++;
531 		}
532 	}
533 
534 	/* if no ranges, then we can return and avoid the checks...*/
535 	if (!i)
536 		return 0;
537 
538 	/* sort the list */
539 	list_sort(NULL, &ranges_list, rx_ranges_cmp);
540 
541 	/* and iterate over all the rx addresses */
542 	for (addr = rx; addr < (u8 *)rx + SPI_TEST_MAX_SIZE_PLUS; addr++) {
543 		/* if we are the DO not write pattern,
544 		 * then continue with the loop...
545 		 */
546 		if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE)
547 			continue;
548 
549 		/* check if we are inside a range */
550 		list_for_each_entry(r, &ranges_list, list) {
551 			/* if so then set to end... */
552 			if ((addr >= r->start) && (addr < r->end))
553 				addr = r->end;
554 		}
555 		/* second test after a (hopefull) translation */
556 		if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE)
557 			continue;
558 
559 		/* if still not found then something has modified too much */
560 		/* we could list the "closest" transfer here... */
561 		dev_err(&spi->dev,
562 			"loopback strangeness - rx changed outside of allowed range at: %pK\n",
563 			addr);
564 		/* do not return, only set ret,
565 		 * so that we list all addresses
566 		 */
567 		ret = -ERANGE;
568 	}
569 
570 	return ret;
571 }
572 
573 static int spi_test_check_elapsed_time(struct spi_device *spi,
574 				       struct spi_test *test)
575 {
576 	int i;
577 	unsigned long long estimated_time = 0;
578 	unsigned long long delay_usecs = 0;
579 
580 	for (i = 0; i < test->transfer_count; i++) {
581 		struct spi_transfer *xfer = test->transfers + i;
582 		unsigned long long nbits = (unsigned long long)BITS_PER_BYTE *
583 					   xfer->len;
584 
585 		delay_usecs += xfer->delay.value;
586 		if (!xfer->speed_hz)
587 			continue;
588 		estimated_time += div_u64(nbits * NSEC_PER_SEC, xfer->speed_hz);
589 	}
590 
591 	estimated_time += delay_usecs * NSEC_PER_USEC;
592 	if (test->elapsed_time < estimated_time) {
593 		dev_err(&spi->dev,
594 			"elapsed time %lld ns is shorter than minimum estimated time %lld ns\n",
595 			test->elapsed_time, estimated_time);
596 
597 		return -EINVAL;
598 	}
599 
600 	return 0;
601 }
602 
603 static int spi_test_check_loopback_result(struct spi_device *spi,
604 					  struct spi_message *msg,
605 					  void *tx, void *rx)
606 {
607 	struct spi_transfer *xfer;
608 	u8 rxb, txb;
609 	size_t i;
610 	int ret;
611 
612 	/* checks rx_buffer pattern are valid with loopback or without */
613 	if (check_ranges) {
614 		ret = spi_check_rx_ranges(spi, msg, rx);
615 		if (ret)
616 			return ret;
617 	}
618 
619 	/* if we run without loopback, then return now */
620 	if (!loopback)
621 		return 0;
622 
623 	/* if applicable to transfer check that rx_buf is equal to tx_buf */
624 	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
625 		/* if there is no rx, then no check is needed */
626 		if (!xfer->len || !xfer->rx_buf)
627 			continue;
628 		/* so depending on tx_buf we need to handle things */
629 		if (xfer->tx_buf) {
630 			for (i = 0; i < xfer->len; i++) {
631 				txb = ((u8 *)xfer->tx_buf)[i];
632 				rxb = ((u8 *)xfer->rx_buf)[i];
633 				if (txb != rxb)
634 					goto mismatch_error;
635 			}
636 		} else {
637 			/* first byte received */
638 			txb = ((u8 *)xfer->rx_buf)[0];
639 			/* first byte may be 0 or xff */
640 			if (!((txb == 0) || (txb == 0xff))) {
641 				dev_err(&spi->dev,
642 					"loopback strangeness - we expect 0x00 or 0xff, but not 0x%02x\n",
643 					txb);
644 				return -EINVAL;
645 			}
646 			/* check that all bytes are identical */
647 			for (i = 1; i < xfer->len; i++) {
648 				rxb = ((u8 *)xfer->rx_buf)[i];
649 				if (rxb != txb)
650 					goto mismatch_error;
651 			}
652 		}
653 	}
654 
655 	return 0;
656 
657 mismatch_error:
658 	dev_err(&spi->dev,
659 		"loopback strangeness - transfer mismatch on byte %04zx - expected 0x%02x, but got 0x%02x\n",
660 		i, txb, rxb);
661 
662 	return -EINVAL;
663 }
664 
665 static int spi_test_translate(struct spi_device *spi,
666 			      void **ptr, size_t len,
667 			      void *tx, void *rx)
668 {
669 	size_t off;
670 
671 	/* return on null */
672 	if (!*ptr)
673 		return 0;
674 
675 	/* in the MAX_SIZE_HALF case modify the pointer */
676 	if (((size_t)*ptr) & SPI_TEST_MAX_SIZE_HALF)
677 		/* move the pointer to the correct range */
678 		*ptr += (SPI_TEST_MAX_SIZE_PLUS / 2) -
679 			SPI_TEST_MAX_SIZE_HALF;
680 
681 	/* RX range
682 	 * - we check against MAX_SIZE_PLUS to allow for automated alignment
683 	 */
684 	if (RANGE_CHECK(*ptr, len,  RX(0), SPI_TEST_MAX_SIZE_PLUS)) {
685 		off = *ptr - RX(0);
686 		*ptr = rx + off;
687 
688 		return 0;
689 	}
690 
691 	/* TX range */
692 	if (RANGE_CHECK(*ptr, len,  TX(0), SPI_TEST_MAX_SIZE_PLUS)) {
693 		off = *ptr - TX(0);
694 		*ptr = tx + off;
695 
696 		return 0;
697 	}
698 
699 	dev_err(&spi->dev,
700 		"PointerRange [%pK:%pK[ not in range [%pK:%pK[ or [%pK:%pK[\n",
701 		*ptr, *ptr + len,
702 		RX(0), RX(SPI_TEST_MAX_SIZE),
703 		TX(0), TX(SPI_TEST_MAX_SIZE));
704 
705 	return -EINVAL;
706 }
707 
708 static int spi_test_fill_pattern(struct spi_device *spi,
709 				 struct spi_test *test)
710 {
711 	struct spi_transfer *xfers = test->transfers;
712 	u8 *tx_buf;
713 	size_t count = 0;
714 	int i, j;
715 
716 #ifdef __BIG_ENDIAN
717 #define GET_VALUE_BYTE(value, index, bytes) \
718 	(value >> (8 * (bytes - 1 - count % bytes)))
719 #else
720 #define GET_VALUE_BYTE(value, index, bytes) \
721 	(value >> (8 * (count % bytes)))
722 #endif
723 
724 	/* fill all transfers with the pattern requested */
725 	for (i = 0; i < test->transfer_count; i++) {
726 		/* fill rx_buf with SPI_TEST_PATTERN_UNWRITTEN */
727 		if (xfers[i].rx_buf)
728 			memset(xfers[i].rx_buf, SPI_TEST_PATTERN_UNWRITTEN,
729 			       xfers[i].len);
730 		/* if tx_buf is NULL then skip */
731 		tx_buf = (u8 *)xfers[i].tx_buf;
732 		if (!tx_buf)
733 			continue;
734 		/* modify all the transfers */
735 		for (j = 0; j < xfers[i].len; j++, tx_buf++, count++) {
736 			/* fill tx */
737 			switch (test->fill_option) {
738 			case FILL_MEMSET_8:
739 				*tx_buf = test->fill_pattern;
740 				break;
741 			case FILL_MEMSET_16:
742 				*tx_buf = GET_VALUE_BYTE(test->fill_pattern,
743 							 count, 2);
744 				break;
745 			case FILL_MEMSET_24:
746 				*tx_buf = GET_VALUE_BYTE(test->fill_pattern,
747 							 count, 3);
748 				break;
749 			case FILL_MEMSET_32:
750 				*tx_buf = GET_VALUE_BYTE(test->fill_pattern,
751 							 count, 4);
752 				break;
753 			case FILL_COUNT_8:
754 				*tx_buf = count;
755 				break;
756 			case FILL_COUNT_16:
757 				*tx_buf = GET_VALUE_BYTE(count, count, 2);
758 				break;
759 			case FILL_COUNT_24:
760 				*tx_buf = GET_VALUE_BYTE(count, count, 3);
761 				break;
762 			case FILL_COUNT_32:
763 				*tx_buf = GET_VALUE_BYTE(count, count, 4);
764 				break;
765 			case FILL_TRANSFER_BYTE_8:
766 				*tx_buf = j;
767 				break;
768 			case FILL_TRANSFER_BYTE_16:
769 				*tx_buf = GET_VALUE_BYTE(j, j, 2);
770 				break;
771 			case FILL_TRANSFER_BYTE_24:
772 				*tx_buf = GET_VALUE_BYTE(j, j, 3);
773 				break;
774 			case FILL_TRANSFER_BYTE_32:
775 				*tx_buf = GET_VALUE_BYTE(j, j, 4);
776 				break;
777 			case FILL_TRANSFER_NUM:
778 				*tx_buf = i;
779 				break;
780 			default:
781 				dev_err(&spi->dev,
782 					"unsupported fill_option: %i\n",
783 					test->fill_option);
784 				return -EINVAL;
785 			}
786 		}
787 	}
788 
789 	return 0;
790 }
791 
792 static int _spi_test_run_iter(struct spi_device *spi,
793 			      struct spi_test *test,
794 			      void *tx, void *rx)
795 {
796 	struct spi_message *msg = &test->msg;
797 	struct spi_transfer *x;
798 	int i, ret;
799 
800 	/* initialize message - zero-filled via static initialization */
801 	spi_message_init_no_memset(msg);
802 
803 	/* fill rx with the DO_NOT_WRITE pattern */
804 	memset(rx, SPI_TEST_PATTERN_DO_NOT_WRITE, SPI_TEST_MAX_SIZE_PLUS);
805 
806 	/* add the individual transfers */
807 	for (i = 0; i < test->transfer_count; i++) {
808 		x = &test->transfers[i];
809 
810 		/* patch the values of tx_buf */
811 		ret = spi_test_translate(spi, (void **)&x->tx_buf, x->len,
812 					 (void *)tx, rx);
813 		if (ret)
814 			return ret;
815 
816 		/* patch the values of rx_buf */
817 		ret = spi_test_translate(spi, &x->rx_buf, x->len,
818 					 (void *)tx, rx);
819 		if (ret)
820 			return ret;
821 
822 		/* and add it to the list */
823 		spi_message_add_tail(x, msg);
824 	}
825 
826 	/* fill in the transfer buffers with pattern */
827 	ret = spi_test_fill_pattern(spi, test);
828 	if (ret)
829 		return ret;
830 
831 	/* and execute */
832 	if (test->execute_msg)
833 		ret = test->execute_msg(spi, test, tx, rx);
834 	else
835 		ret = spi_test_execute_msg(spi, test, tx, rx);
836 
837 	/* handle result */
838 	if (ret == test->expected_return)
839 		return 0;
840 
841 	dev_err(&spi->dev,
842 		"test failed - test returned %i, but we expect %i\n",
843 		ret, test->expected_return);
844 
845 	if (ret)
846 		return ret;
847 
848 	/* if it is 0, as we expected something else,
849 	 * then return something special
850 	 */
851 	return -EFAULT;
852 }
853 
854 static int spi_test_run_iter(struct spi_device *spi,
855 			     const struct spi_test *testtemplate,
856 			     void *tx, void *rx,
857 			     size_t len,
858 			     size_t tx_off,
859 			     size_t rx_off
860 	)
861 {
862 	struct spi_test test;
863 	int i, tx_count, rx_count;
864 
865 	/* copy the test template to test */
866 	memcpy(&test, testtemplate, sizeof(test));
867 
868 	/* if iterate_transfer_mask is not set,
869 	 * then set it to first transfer only
870 	 */
871 	if (!(test.iterate_transfer_mask & (BIT(test.transfer_count) - 1)))
872 		test.iterate_transfer_mask = 1;
873 
874 	/* count number of transfers with tx/rx_buf != NULL */
875 	rx_count = tx_count = 0;
876 	for (i = 0; i < test.transfer_count; i++) {
877 		if (test.transfers[i].tx_buf)
878 			tx_count++;
879 		if (test.transfers[i].rx_buf)
880 			rx_count++;
881 	}
882 
883 	/* in some iteration cases warn and exit early,
884 	 * as there is nothing to do, that has not been tested already...
885 	 */
886 	if (tx_off && (!tx_count)) {
887 		dev_warn_once(&spi->dev,
888 			      "%s: iterate_tx_off configured with tx_buf==NULL - ignoring\n",
889 			      test.description);
890 		return 0;
891 	}
892 	if (rx_off && (!rx_count)) {
893 		dev_warn_once(&spi->dev,
894 			      "%s: iterate_rx_off configured with rx_buf==NULL - ignoring\n",
895 			      test.description);
896 		return 0;
897 	}
898 
899 	/* write out info */
900 	if (!(len || tx_off || rx_off)) {
901 		dev_info(&spi->dev, "Running test %s\n", test.description);
902 	} else {
903 		dev_info(&spi->dev,
904 			 "  with iteration values: len = %zu, tx_off = %zu, rx_off = %zu\n",
905 			 len, tx_off, rx_off);
906 	}
907 
908 	/* update in the values from iteration values */
909 	for (i = 0; i < test.transfer_count; i++) {
910 		/* only when bit in transfer mask is set */
911 		if (!(test.iterate_transfer_mask & BIT(i)))
912 			continue;
913 		test.transfers[i].len = len;
914 		if (test.transfers[i].tx_buf)
915 			test.transfers[i].tx_buf += tx_off;
916 		if (test.transfers[i].rx_buf)
917 			test.transfers[i].rx_buf += rx_off;
918 	}
919 
920 	/* and execute */
921 	return _spi_test_run_iter(spi, &test, tx, rx);
922 }
923 
924 /**
925  * spi_test_execute_msg - default implementation to run a test
926  *
927  * @spi: @spi_device on which to run the @spi_message
928  * @test: the test to execute, which already contains @msg
929  * @tx:   the tx buffer allocated for the test sequence
930  * @rx:   the rx buffer allocated for the test sequence
931  *
932  * Returns: error code of spi_sync as well as basic error checking
933  */
934 int spi_test_execute_msg(struct spi_device *spi, struct spi_test *test,
935 			 void *tx, void *rx)
936 {
937 	struct spi_message *msg = &test->msg;
938 	int ret = 0;
939 	int i;
940 
941 	/* only if we do not simulate */
942 	if (!simulate_only) {
943 		ktime_t start;
944 
945 		/* dump the complete message before and after the transfer */
946 		if (dump_messages == 3)
947 			spi_test_dump_message(spi, msg, true);
948 
949 		start = ktime_get();
950 		/* run spi message */
951 		ret = spi_sync(spi, msg);
952 		test->elapsed_time = ktime_to_ns(ktime_sub(ktime_get(), start));
953 		if (ret == -ETIMEDOUT) {
954 			dev_info(&spi->dev,
955 				 "spi-message timed out - rerunning...\n");
956 			/* rerun after a few explicit schedules */
957 			for (i = 0; i < 16; i++)
958 				schedule();
959 			ret = spi_sync(spi, msg);
960 		}
961 		if (ret) {
962 			dev_err(&spi->dev,
963 				"Failed to execute spi_message: %i\n",
964 				ret);
965 			goto exit;
966 		}
967 
968 		/* do some extra error checks */
969 		if (msg->frame_length != msg->actual_length) {
970 			dev_err(&spi->dev,
971 				"actual length differs from expected\n");
972 			ret = -EIO;
973 			goto exit;
974 		}
975 
976 		/* run rx-buffer tests */
977 		ret = spi_test_check_loopback_result(spi, msg, tx, rx);
978 		if (ret)
979 			goto exit;
980 
981 		ret = spi_test_check_elapsed_time(spi, test);
982 	}
983 
984 	/* if requested or on error dump message (including data) */
985 exit:
986 	if (dump_messages || ret)
987 		spi_test_dump_message(spi, msg,
988 				      (dump_messages >= 2) || (ret));
989 
990 	return ret;
991 }
992 EXPORT_SYMBOL_GPL(spi_test_execute_msg);
993 
994 /**
995  * spi_test_run_test - run an individual spi_test
996  *                     including all the relevant iterations on:
997  *                     length and buffer alignment
998  *
999  * @spi:  the spi_device to send the messages to
1000  * @test: the test which we need to execute
1001  * @tx:   the tx buffer allocated for the test sequence
1002  * @rx:   the rx buffer allocated for the test sequence
1003  *
1004  * Returns: status code of spi_sync or other failures
1005  */
1006 
1007 int spi_test_run_test(struct spi_device *spi, const struct spi_test *test,
1008 		      void *tx, void *rx)
1009 {
1010 	int idx_len;
1011 	size_t len;
1012 	size_t tx_align, rx_align;
1013 	int ret;
1014 
1015 	/* test for transfer limits */
1016 	if (test->transfer_count >= SPI_TEST_MAX_TRANSFERS) {
1017 		dev_err(&spi->dev,
1018 			"%s: Exceeded max number of transfers with %i\n",
1019 			test->description, test->transfer_count);
1020 		return -E2BIG;
1021 	}
1022 
1023 	/* setting up some values in spi_message
1024 	 * based on some settings in spi_master
1025 	 * some of this can also get done in the run() method
1026 	 */
1027 
1028 	/* iterate over all the iterable values using macros
1029 	 * (to make it a bit more readable...
1030 	 */
1031 #define FOR_EACH_ALIGNMENT(var)						\
1032 	for (var = 0;							\
1033 	    var < (test->iterate_##var ?				\
1034 			(spi->master->dma_alignment ?			\
1035 			 spi->master->dma_alignment :			\
1036 			 test->iterate_##var) :				\
1037 			1);						\
1038 	    var++)
1039 
1040 	for (idx_len = 0; idx_len < SPI_TEST_MAX_ITERATE &&
1041 	     (len = test->iterate_len[idx_len]) != -1; idx_len++) {
1042 		if ((run_only_iter_len > -1) && len != run_only_iter_len)
1043 			continue;
1044 		FOR_EACH_ALIGNMENT(tx_align) {
1045 			FOR_EACH_ALIGNMENT(rx_align) {
1046 				/* and run the iteration */
1047 				ret = spi_test_run_iter(spi, test,
1048 							tx, rx,
1049 							len,
1050 							tx_align,
1051 							rx_align);
1052 				if (ret)
1053 					return ret;
1054 			}
1055 		}
1056 	}
1057 
1058 	return 0;
1059 }
1060 EXPORT_SYMBOL_GPL(spi_test_run_test);
1061 
1062 /**
1063  * spi_test_run_tests - run an array of spi_messages tests
1064  * @spi: the spi device on which to run the tests
1065  * @tests: NULL-terminated array of @spi_test
1066  *
1067  * Returns: status errors as per @spi_test_run_test()
1068  */
1069 
1070 int spi_test_run_tests(struct spi_device *spi,
1071 		       struct spi_test *tests)
1072 {
1073 	char *rx = NULL, *tx = NULL;
1074 	int ret = 0, count = 0;
1075 	struct spi_test *test;
1076 
1077 	/* allocate rx/tx buffers of 128kB size without devm
1078 	 * in the hope that is on a page boundary
1079 	 */
1080 	if (use_vmalloc)
1081 		rx = vmalloc(SPI_TEST_MAX_SIZE_PLUS);
1082 	else
1083 		rx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL);
1084 	if (!rx)
1085 		return -ENOMEM;
1086 
1087 
1088 	if (use_vmalloc)
1089 		tx = vmalloc(SPI_TEST_MAX_SIZE_PLUS);
1090 	else
1091 		tx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL);
1092 	if (!tx) {
1093 		ret = -ENOMEM;
1094 		goto err_tx;
1095 	}
1096 
1097 	/* now run the individual tests in the table */
1098 	for (test = tests, count = 0; test->description[0];
1099 	     test++, count++) {
1100 		/* only run test if requested */
1101 		if ((run_only_test > -1) && (count != run_only_test))
1102 			continue;
1103 		/* run custom implementation */
1104 		if (test->run_test)
1105 			ret = test->run_test(spi, test, tx, rx);
1106 		else
1107 			ret = spi_test_run_test(spi, test, tx, rx);
1108 		if (ret)
1109 			goto out;
1110 		/* add some delays so that we can easily
1111 		 * detect the individual tests when using a logic analyzer
1112 		 * we also add scheduling to avoid potential spi_timeouts...
1113 		 */
1114 		if (delay_ms)
1115 			mdelay(delay_ms);
1116 		schedule();
1117 	}
1118 
1119 out:
1120 	kvfree(tx);
1121 err_tx:
1122 	kvfree(rx);
1123 	return ret;
1124 }
1125 EXPORT_SYMBOL_GPL(spi_test_run_tests);
1126