1
2
3
4
5
6
7#include <linux/kernel.h>
8#include <errno.h>
9#include <fcntl.h>
10#include <stdarg.h>
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <sys/syscall.h>
15#include <sys/types.h>
16#include <sys/stat.h>
17#include <unistd.h>
18
19#include "../../kselftest.h"
20
21#define DEBUG_LEVEL_1_BIT (0x0001)
22#define DEBUG_LEVEL_2_BIT (0x0002)
23#define DEBUG_LEVEL_3_BIT (0x0004)
24#define DEBUG_LEVEL_4_BIT (0x0008)
25#define DEBUG_TIMING_BIT (0x1000)
26
27#ifndef ARRAY_SIZE
28# define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
29#endif
30
31
32#define DEBUG 0x0001
33
34#define DEBUG_PRINT_L1(...) debug_print(DEBUG_LEVEL_1_BIT, __VA_ARGS__)
35#define DEBUG_PRINT_L2(...) debug_print(DEBUG_LEVEL_2_BIT, __VA_ARGS__)
36#define DEBUG_PRINT_L3(...) debug_print(DEBUG_LEVEL_3_BIT, __VA_ARGS__)
37#define DEBUG_PRINT_L4(...) debug_print(DEBUG_LEVEL_4_BIT, __VA_ARGS__)
38#define DEBUG_PRINT_T(...) debug_print(DEBUG_TIMING_BIT, __VA_ARGS__)
39
40static void debug_print(int level, const char *s, ...)
41{
42 va_list args;
43
44 va_start(args, s);
45
46 if (DEBUG & level)
47 vfprintf(stdout, s, args);
48 va_end(args);
49}
50
51#ifndef min
52#define min(x, y) ((x) < (y) ? x : y)
53#endif
54
55#define RETURN_FROM_TEST(_ret) \
56 do { \
57 DEBUG_PRINT_L1( \
58 "\tTest %s returned %d\n", __func__, _ret); \
59 return _ret; \
60 } while (0)
61
62#define ADI_BLKSZ 64
63#define ADI_MAX_VERSION 15
64
65#define TEST_STEP_FAILURE(_ret) \
66 do { \
67 fprintf(stderr, "\tTest step failure: %d at %s:%d\n", \
68 _ret, __func__, __LINE__); \
69 goto out; \
70 } while (0)
71
72#define RDTICK(_x) \
73 asm volatile(" rd %%tick, %0\n" : "=r" (_x))
74
75static int random_version(void)
76{
77 long tick;
78
79 RDTICK(tick);
80
81 return tick % (ADI_MAX_VERSION + 1);
82}
83
84#define MAX_RANGES_SUPPORTED 5
85static const char system_ram_str[] = "System RAM\n";
86static int range_count;
87static unsigned long long int start_addr[MAX_RANGES_SUPPORTED];
88static unsigned long long int end_addr[MAX_RANGES_SUPPORTED];
89
90struct stats {
91 char name[16];
92 unsigned long total;
93 unsigned long count;
94 unsigned long bytes;
95};
96
97static struct stats read_stats = {
98 .name = "read", .total = 0, .count = 0, .bytes = 0};
99static struct stats pread_stats = {
100 .name = "pread", .total = 0, .count = 0, .bytes = 0};
101static struct stats write_stats = {
102 .name = "write", .total = 0, .count = 0, .bytes = 0};
103static struct stats pwrite_stats = {
104 .name = "pwrite", .total = 0, .count = 0, .bytes = 0};
105static struct stats seek_stats = {
106 .name = "seek", .total = 0, .count = 0, .bytes = 0};
107
108static void update_stats(struct stats * const ustats,
109 unsigned long measurement, unsigned long bytes)
110{
111 ustats->total += measurement;
112 ustats->bytes += bytes;
113 ustats->count++;
114}
115
116static void print_ustats(const struct stats * const ustats)
117{
118 DEBUG_PRINT_L1("%s\t%7d\t%7.0f\t%7.0f\n",
119 ustats->name, ustats->count,
120 (float)ustats->total / (float)ustats->count,
121 (float)ustats->bytes / (float)ustats->count);
122}
123
124static void print_stats(void)
125{
126 DEBUG_PRINT_L1("\nSyscall\tCall\tAvgTime\tAvgSize\n"
127 "\tCount\t(ticks)\t(bytes)\n"
128 "-------------------------------\n");
129
130 print_ustats(&read_stats);
131 print_ustats(&pread_stats);
132 print_ustats(&write_stats);
133 print_ustats(&pwrite_stats);
134 print_ustats(&seek_stats);
135}
136
137static int build_memory_map(void)
138{
139 char line[256];
140 FILE *fp;
141 int i;
142
143 range_count = 0;
144
145 fp = fopen("/proc/iomem", "r");
146 if (!fp) {
147 fprintf(stderr, "/proc/iomem: error %d: %s\n",
148 errno, strerror(errno));
149 return -errno;
150 }
151
152 while (fgets(line, sizeof(line), fp) != 0) {
153 if (strstr(line, system_ram_str)) {
154 char *dash, *end_ptr;
155
156
157
158
159
160 dash = strstr(line, "-");
161 dash[0] = 0x20;
162
163 start_addr[range_count] = strtoull(line, &end_ptr, 16);
164 end_addr[range_count] = strtoull(end_ptr, NULL, 16);
165 range_count++;
166 }
167 }
168
169 fclose(fp);
170
171 DEBUG_PRINT_L1("RAM Ranges\n");
172 for (i = 0; i < range_count; i++)
173 DEBUG_PRINT_L1("\trange %d: 0x%llx\t- 0x%llx\n",
174 i, start_addr[i], end_addr[i]);
175
176 if (range_count == 0) {
177 fprintf(stderr, "No valid address ranges found. Error.\n");
178 return -1;
179 }
180
181 return 0;
182}
183
184static int read_adi(int fd, unsigned char *buf, int buf_sz)
185{
186 int ret, bytes_read = 0;
187 long start, end, elapsed_time = 0;
188
189 do {
190 RDTICK(start);
191 ret = read(fd, buf + bytes_read, buf_sz - bytes_read);
192 RDTICK(end);
193 if (ret < 0)
194 return -errno;
195
196 elapsed_time += end - start;
197 update_stats(&read_stats, elapsed_time, buf_sz);
198 bytes_read += ret;
199
200 } while (bytes_read < buf_sz);
201
202 DEBUG_PRINT_T("\tread elapsed timed = %ld\n", elapsed_time);
203 DEBUG_PRINT_L3("\tRead %d bytes\n", bytes_read);
204
205 return bytes_read;
206}
207
208static int pread_adi(int fd, unsigned char *buf,
209 int buf_sz, unsigned long offset)
210{
211 int ret, i, bytes_read = 0;
212 unsigned long cur_offset;
213 long start, end, elapsed_time = 0;
214
215 cur_offset = offset;
216 do {
217 RDTICK(start);
218 ret = pread(fd, buf + bytes_read, buf_sz - bytes_read,
219 cur_offset);
220 RDTICK(end);
221 if (ret < 0)
222 return -errno;
223
224 elapsed_time += end - start;
225 update_stats(&pread_stats, elapsed_time, buf_sz);
226 bytes_read += ret;
227 cur_offset += ret;
228
229 } while (bytes_read < buf_sz);
230
231 DEBUG_PRINT_T("\tpread elapsed timed = %ld\n", elapsed_time);
232 DEBUG_PRINT_L3("\tRead %d bytes starting at offset 0x%lx\n",
233 bytes_read, offset);
234 for (i = 0; i < bytes_read; i++)
235 DEBUG_PRINT_L4("\t\t0x%lx\t%d\n", offset + i, buf[i]);
236
237 return bytes_read;
238}
239
240static int write_adi(int fd, const unsigned char * const buf, int buf_sz)
241{
242 int ret, bytes_written = 0;
243 long start, end, elapsed_time = 0;
244
245 do {
246 RDTICK(start);
247 ret = write(fd, buf + bytes_written, buf_sz - bytes_written);
248 RDTICK(end);
249 if (ret < 0)
250 return -errno;
251
252 elapsed_time += (end - start);
253 update_stats(&write_stats, elapsed_time, buf_sz);
254 bytes_written += ret;
255 } while (bytes_written < buf_sz);
256
257 DEBUG_PRINT_T("\twrite elapsed timed = %ld\n", elapsed_time);
258 DEBUG_PRINT_L3("\tWrote %d of %d bytes\n", bytes_written, buf_sz);
259
260 return bytes_written;
261}
262
263static int pwrite_adi(int fd, const unsigned char * const buf,
264 int buf_sz, unsigned long offset)
265{
266 int ret, bytes_written = 0;
267 unsigned long cur_offset;
268 long start, end, elapsed_time = 0;
269
270 cur_offset = offset;
271
272 do {
273 RDTICK(start);
274 ret = pwrite(fd, buf + bytes_written,
275 buf_sz - bytes_written, cur_offset);
276 RDTICK(end);
277 if (ret < 0) {
278 fprintf(stderr, "pwrite(): error %d: %s\n",
279 errno, strerror(errno));
280 return -errno;
281 }
282
283 elapsed_time += (end - start);
284 update_stats(&pwrite_stats, elapsed_time, buf_sz);
285 bytes_written += ret;
286 cur_offset += ret;
287
288 } while (bytes_written < buf_sz);
289
290 DEBUG_PRINT_T("\tpwrite elapsed timed = %ld\n", elapsed_time);
291 DEBUG_PRINT_L3("\tWrote %d of %d bytes starting at address 0x%lx\n",
292 bytes_written, buf_sz, offset);
293
294 return bytes_written;
295}
296
297static off_t seek_adi(int fd, off_t offset, int whence)
298{
299 long start, end;
300 off_t ret;
301
302 RDTICK(start);
303 ret = lseek(fd, offset, whence);
304 RDTICK(end);
305 DEBUG_PRINT_L2("\tlseek ret = 0x%llx\n", ret);
306 if (ret < 0)
307 goto out;
308
309 DEBUG_PRINT_T("\tlseek elapsed timed = %ld\n", end - start);
310 update_stats(&seek_stats, end - start, 0);
311
312out:
313 (void)lseek(fd, 0, SEEK_END);
314 return ret;
315}
316
317static int test0_prpw_aligned_1byte(int fd)
318{
319
320 unsigned long paddr =
321 (end_addr[range_count - 1] - 0x1000) & ~(ADI_BLKSZ - 1);
322 unsigned char version[1], expected_version;
323 loff_t offset;
324 int ret;
325
326 version[0] = random_version();
327 expected_version = version[0];
328
329 offset = paddr / ADI_BLKSZ;
330
331 ret = pwrite_adi(fd, version, sizeof(version), offset);
332 if (ret != sizeof(version))
333 TEST_STEP_FAILURE(ret);
334
335 ret = pread_adi(fd, version, sizeof(version), offset);
336 if (ret != sizeof(version))
337 TEST_STEP_FAILURE(ret);
338
339 if (expected_version != version[0]) {
340 DEBUG_PRINT_L2("\tExpected version %d but read version %d\n",
341 expected_version, version[0]);
342 TEST_STEP_FAILURE(-expected_version);
343 }
344
345 ret = 0;
346out:
347 RETURN_FROM_TEST(ret);
348}
349
350#define TEST1_VERSION_SZ 4096
351static int test1_prpw_aligned_4096bytes(int fd)
352{
353
354 unsigned long paddr =
355 (end_addr[range_count - 1] - 0x6000) & ~(ADI_BLKSZ - 1);
356 unsigned char version[TEST1_VERSION_SZ],
357 expected_version[TEST1_VERSION_SZ];
358 loff_t offset;
359 int ret, i;
360
361 for (i = 0; i < TEST1_VERSION_SZ; i++) {
362 version[i] = random_version();
363 expected_version[i] = version[i];
364 }
365
366 offset = paddr / ADI_BLKSZ;
367
368 ret = pwrite_adi(fd, version, sizeof(version), offset);
369 if (ret != sizeof(version))
370 TEST_STEP_FAILURE(ret);
371
372 ret = pread_adi(fd, version, sizeof(version), offset);
373 if (ret != sizeof(version))
374 TEST_STEP_FAILURE(ret);
375
376 for (i = 0; i < TEST1_VERSION_SZ; i++) {
377 if (expected_version[i] != version[i]) {
378 DEBUG_PRINT_L2(
379 "\tExpected version %d but read version %d\n",
380 expected_version, version[0]);
381 TEST_STEP_FAILURE(-expected_version[i]);
382 }
383 }
384
385 ret = 0;
386out:
387 RETURN_FROM_TEST(ret);
388}
389
390#define TEST2_VERSION_SZ 10327
391static int test2_prpw_aligned_10327bytes(int fd)
392{
393
394 unsigned long paddr =
395 (start_addr[0] + 0x6000) & ~(ADI_BLKSZ - 1);
396 unsigned char version[TEST2_VERSION_SZ],
397 expected_version[TEST2_VERSION_SZ];
398 loff_t offset;
399 int ret, i;
400
401 for (i = 0; i < TEST2_VERSION_SZ; i++) {
402 version[i] = random_version();
403 expected_version[i] = version[i];
404 }
405
406 offset = paddr / ADI_BLKSZ;
407
408 ret = pwrite_adi(fd, version, sizeof(version), offset);
409 if (ret != sizeof(version))
410 TEST_STEP_FAILURE(ret);
411
412 ret = pread_adi(fd, version, sizeof(version), offset);
413 if (ret != sizeof(version))
414 TEST_STEP_FAILURE(ret);
415
416 for (i = 0; i < TEST2_VERSION_SZ; i++) {
417 if (expected_version[i] != version[i]) {
418 DEBUG_PRINT_L2(
419 "\tExpected version %d but read version %d\n",
420 expected_version, version[0]);
421 TEST_STEP_FAILURE(-expected_version[i]);
422 }
423 }
424
425 ret = 0;
426out:
427 RETURN_FROM_TEST(ret);
428}
429
430#define TEST3_VERSION_SZ 12541
431static int test3_prpw_unaligned_12541bytes(int fd)
432{
433
434 unsigned long paddr =
435 ((start_addr[0] + 0xC000) & ~(ADI_BLKSZ - 1)) + 17;
436 unsigned char version[TEST3_VERSION_SZ],
437 expected_version[TEST3_VERSION_SZ];
438 loff_t offset;
439 int ret, i;
440
441 for (i = 0; i < TEST3_VERSION_SZ; i++) {
442 version[i] = random_version();
443 expected_version[i] = version[i];
444 }
445
446 offset = paddr / ADI_BLKSZ;
447
448 ret = pwrite_adi(fd, version, sizeof(version), offset);
449 if (ret != sizeof(version))
450 TEST_STEP_FAILURE(ret);
451
452 ret = pread_adi(fd, version, sizeof(version), offset);
453 if (ret != sizeof(version))
454 TEST_STEP_FAILURE(ret);
455
456 for (i = 0; i < TEST3_VERSION_SZ; i++) {
457 if (expected_version[i] != version[i]) {
458 DEBUG_PRINT_L2(
459 "\tExpected version %d but read version %d\n",
460 expected_version, version[0]);
461 TEST_STEP_FAILURE(-expected_version[i]);
462 }
463 }
464
465 ret = 0;
466out:
467 RETURN_FROM_TEST(ret);
468}
469
470static int test4_lseek(int fd)
471{
472#define OFFSET_ADD (0x100)
473#define OFFSET_SUBTRACT (0xFFFFFFF000000000)
474
475 off_t offset_out, offset_in;
476 int ret;
477
478
479 offset_in = 0x123456789abcdef0;
480 offset_out = seek_adi(fd, offset_in, SEEK_SET);
481 if (offset_out != offset_in) {
482 ret = -1;
483 TEST_STEP_FAILURE(ret);
484 }
485
486
487 offset_out = seek_adi(fd, offset_in, SEEK_SET);
488 if (offset_out < 0 && errno == EINVAL)
489 DEBUG_PRINT_L2(
490 "\tSEEK_SET failed as designed. Not an error\n");
491 else {
492 ret = -2;
493 TEST_STEP_FAILURE(ret);
494 }
495
496 offset_out = seek_adi(fd, 0, SEEK_CUR);
497 if (offset_out != offset_in) {
498 ret = -3;
499 TEST_STEP_FAILURE(ret);
500 }
501
502 offset_out = seek_adi(fd, OFFSET_ADD, SEEK_CUR);
503 if (offset_out != (offset_in + OFFSET_ADD)) {
504 ret = -4;
505 TEST_STEP_FAILURE(ret);
506 }
507
508 offset_out = seek_adi(fd, OFFSET_SUBTRACT, SEEK_CUR);
509 if (offset_out != (offset_in + OFFSET_ADD + OFFSET_SUBTRACT)) {
510 ret = -5;
511 TEST_STEP_FAILURE(ret);
512 }
513
514 ret = 0;
515out:
516 RETURN_FROM_TEST(ret);
517}
518
519static int test5_rw_aligned_1byte(int fd)
520{
521
522 unsigned long paddr =
523 (end_addr[range_count - 1] - 0xF000) & ~(ADI_BLKSZ - 1);
524 unsigned char version, expected_version;
525 loff_t offset;
526 off_t oret;
527 int ret;
528
529 offset = paddr / ADI_BLKSZ;
530 version = expected_version = random_version();
531
532 oret = seek_adi(fd, offset, SEEK_SET);
533 if (oret != offset) {
534 ret = -1;
535 TEST_STEP_FAILURE(ret);
536 }
537
538 ret = write_adi(fd, &version, sizeof(version));
539 if (ret != sizeof(version))
540 TEST_STEP_FAILURE(ret);
541
542 oret = seek_adi(fd, offset, SEEK_SET);
543 if (oret != offset) {
544 ret = -1;
545 TEST_STEP_FAILURE(ret);
546 }
547
548 ret = read_adi(fd, &version, sizeof(version));
549 if (ret != sizeof(version))
550 TEST_STEP_FAILURE(ret);
551
552 if (expected_version != version) {
553 DEBUG_PRINT_L2("\tExpected version %d but read version %d\n",
554 expected_version, version);
555 TEST_STEP_FAILURE(-expected_version);
556 }
557
558 ret = 0;
559out:
560 RETURN_FROM_TEST(ret);
561}
562
563#define TEST6_VERSION_SZ 9434
564static int test6_rw_aligned_9434bytes(int fd)
565{
566
567 unsigned long paddr =
568 (end_addr[range_count - 1] - 0x5F000) & ~(ADI_BLKSZ - 1);
569 unsigned char version[TEST6_VERSION_SZ],
570 expected_version[TEST6_VERSION_SZ];
571 loff_t offset;
572 off_t oret;
573 int ret, i;
574
575 offset = paddr / ADI_BLKSZ;
576 for (i = 0; i < TEST6_VERSION_SZ; i++)
577 version[i] = expected_version[i] = random_version();
578
579 oret = seek_adi(fd, offset, SEEK_SET);
580 if (oret != offset) {
581 ret = -1;
582 TEST_STEP_FAILURE(ret);
583 }
584
585 ret = write_adi(fd, version, sizeof(version));
586 if (ret != sizeof(version))
587 TEST_STEP_FAILURE(ret);
588
589 memset(version, 0, TEST6_VERSION_SZ);
590
591 oret = seek_adi(fd, offset, SEEK_SET);
592 if (oret != offset) {
593 ret = -1;
594 TEST_STEP_FAILURE(ret);
595 }
596
597 ret = read_adi(fd, version, sizeof(version));
598 if (ret != sizeof(version))
599 TEST_STEP_FAILURE(ret);
600
601 for (i = 0; i < TEST6_VERSION_SZ; i++) {
602 if (expected_version[i] != version[i]) {
603 DEBUG_PRINT_L2(
604 "\tExpected version %d but read version %d\n",
605 expected_version[i], version[i]);
606 TEST_STEP_FAILURE(-expected_version[i]);
607 }
608 }
609
610 ret = 0;
611out:
612 RETURN_FROM_TEST(ret);
613}
614
615#define TEST7_VERSION_SZ 14963
616static int test7_rw_aligned_14963bytes(int fd)
617{
618
619 unsigned long paddr =
620 ((start_addr[range_count - 1] + 0xF000) & ~(ADI_BLKSZ - 1)) + 39;
621 unsigned char version[TEST7_VERSION_SZ],
622 expected_version[TEST7_VERSION_SZ];
623 loff_t offset;
624 off_t oret;
625 int ret, i;
626
627 offset = paddr / ADI_BLKSZ;
628 for (i = 0; i < TEST7_VERSION_SZ; i++) {
629 version[i] = random_version();
630 expected_version[i] = version[i];
631 }
632
633 oret = seek_adi(fd, offset, SEEK_SET);
634 if (oret != offset) {
635 ret = -1;
636 TEST_STEP_FAILURE(ret);
637 }
638
639 ret = write_adi(fd, version, sizeof(version));
640 if (ret != sizeof(version))
641 TEST_STEP_FAILURE(ret);
642
643 memset(version, 0, TEST7_VERSION_SZ);
644
645 oret = seek_adi(fd, offset, SEEK_SET);
646 if (oret != offset) {
647 ret = -1;
648 TEST_STEP_FAILURE(ret);
649 }
650
651 ret = read_adi(fd, version, sizeof(version));
652 if (ret != sizeof(version))
653 TEST_STEP_FAILURE(ret);
654
655 for (i = 0; i < TEST7_VERSION_SZ; i++) {
656 if (expected_version[i] != version[i]) {
657 DEBUG_PRINT_L2(
658 "\tExpected version %d but read version %d\n",
659 expected_version[i], version[i]);
660 TEST_STEP_FAILURE(-expected_version[i]);
661 }
662
663 paddr += ADI_BLKSZ;
664 }
665
666 ret = 0;
667out:
668 RETURN_FROM_TEST(ret);
669}
670
671static int (*tests[])(int fd) = {
672 test0_prpw_aligned_1byte,
673 test1_prpw_aligned_4096bytes,
674 test2_prpw_aligned_10327bytes,
675 test3_prpw_unaligned_12541bytes,
676 test4_lseek,
677 test5_rw_aligned_1byte,
678 test6_rw_aligned_9434bytes,
679 test7_rw_aligned_14963bytes,
680};
681#define TEST_COUNT ARRAY_SIZE(tests)
682
683int main(int argc, char *argv[])
684{
685 int fd, ret, test;
686
687 ret = build_memory_map();
688 if (ret < 0)
689 return ret;
690
691 fd = open("/dev/adi", O_RDWR);
692 if (fd < 0) {
693 fprintf(stderr, "open: error %d: %s\n",
694 errno, strerror(errno));
695 return -errno;
696 }
697
698 for (test = 0; test < TEST_COUNT; test++) {
699 DEBUG_PRINT_L1("Running test #%d\n", test);
700
701 ret = (*tests[test])(fd);
702 if (ret != 0)
703 ksft_test_result_fail("Test #%d failed: error %d\n",
704 test, ret);
705 else
706 ksft_test_result_pass("Test #%d passed\n", test);
707 }
708
709 print_stats();
710 close(fd);
711
712 if (ksft_get_fail_cnt() > 0)
713 ksft_exit_fail();
714 else
715 ksft_exit_pass();
716
717
718
719
720 return 0;
721}
722
