1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/*
* Test Joachim's MKMIF core.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <sys/time.h>
/* Rename both CMSIS HAL_OK and libhal HAL_OK to disambiguate */
#define HAL_OK CMSIS_HAL_OK
#include "mgmt-cli.h"
#undef HAL_OK
#define HAL_OK LIBHAL_OK
#include "hal.h"
#undef HAL_OK
#define SCLK_DIV 0x20
typedef union {
uint8_t byte[4];
uint32_t word;
} byteword_t;
static hal_error_t sclk_test(struct cli_def *cli, hal_core_t *core, const uint32_t divisor)
{
uint32_t readback;
hal_error_t err;
cli_print(cli, "Trying to adjust the clockspeed (divisor %x).", (unsigned int) divisor);
if ((err = hal_mkmif_set_clockspeed(core, divisor)) != LIBHAL_OK) {
cli_print(cli, "hal_mkmif_set_clockspeed: %s", hal_error_string(err));
return err;
}
if ((err = hal_mkmif_get_clockspeed(core, &readback)) != LIBHAL_OK) {
cli_print(cli, "hal_mkmif_get_clockspeed: %s", hal_error_string(err));
return err;
}
if (readback != divisor) {
cli_print(cli, "expected %x, got %x", (unsigned int)divisor, (unsigned int)readback);
return HAL_ERROR_IO_UNEXPECTED;
}
return LIBHAL_OK;
}
static hal_error_t init_test(struct cli_def *cli, hal_core_t *core)
{
hal_error_t err;
cli_print(cli, "Trying to init to the memory in continuous mode.");
if ((err = hal_mkmif_init(core)) != LIBHAL_OK) {
cli_print(cli, "hal_mkmif_init: %s", hal_error_string(err));
return err;
}
return LIBHAL_OK;
}
static hal_error_t write_test(struct cli_def *cli, hal_core_t *core)
{
uint32_t write_data;
uint32_t write_address;
int i;
hal_error_t err;
for (write_data = 0x01020304, write_address = 0, i = 0;
i < 0x10;
write_data += 0x01010101, write_address += 4, ++i) {
cli_print(cli, "Trying to write 0x%08x to memory address 0x%08x.",
(unsigned int)write_data, (unsigned int)write_address);
if ((err = hal_mkmif_write_word(core, write_address, write_data)) != LIBHAL_OK) {
cli_print(cli, "hal_mkmif_write: %s", hal_error_string(err));
return err;
}
}
return LIBHAL_OK;
}
static hal_error_t read_test(struct cli_def *cli, hal_core_t *core)
{
uint32_t read_data;
uint32_t read_address;
int i;
hal_error_t err;
for (read_address = 0, i = 0;
i < 0x10;
read_address += 4, ++i) {
cli_print(cli, "Trying to read from memory address 0x%08x.", (unsigned int)read_address);
if ((err = hal_mkmif_read_word(core, read_address, &read_data)) != LIBHAL_OK) {
cli_print(cli, "hal_mkmif_read: %s", hal_error_string(err));
return err;
}
cli_print(cli, "Data read: 0x%08x", (unsigned int)read_data);
}
return LIBHAL_OK;
}
static hal_error_t write_read_test(struct cli_def *cli, hal_core_t *core)
{
uint32_t data;
uint32_t readback;
hal_error_t err;
cli_print(cli, "Trying to write 0xdeadbeef to the memory and then read back.");
data = 0xdeadbeef;
if ((err = hal_mkmif_write_word(core, 0x00000000, data)) != LIBHAL_OK) {
cli_print(cli, "write error: %s", hal_error_string(err));
return err;
}
if ((err = hal_mkmif_read_word(core, 0x00000000, &readback)) != LIBHAL_OK) {
cli_print(cli, "read error: %s", hal_error_string(err));
return err;
}
if (readback != data) {
cli_print(cli, "read %08x, expected %08x", (unsigned int)readback, (unsigned int)data);
return HAL_ERROR_IO_UNEXPECTED;
}
return LIBHAL_OK;
}
int cmd_test_mkmif(struct cli_def *cli, const char *command, char *argv[], int argc)
{
hal_core_t *core = hal_core_find(MKMIF_NAME, NULL);
hal_error_t res;
command = command;
argv = argv;
argc = argc;
if (core == NULL) {
cli_print(cli, "MKMIF core not present, not testing.");
return HAL_ERROR_CORE_NOT_FOUND;
}
res =
sclk_test(cli, core, SCLK_DIV) ||
init_test(cli, core) ||
write_read_test(cli, core) ||
write_test(cli, core) ||
read_test(cli, core);
if (res != LIBHAL_OK) {
cli_print(cli, "\nTest FAILED");
}
return CLI_OK;
}
|
