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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
/*
* Copyright (c) 2011, Google Inc. All rights reserved.
*
* See file CREDITS for list of people who contributed to this
* project.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*/
/*
* This module records the progress of boot and arbitrary commands, and
* permits accurate timestamping of each. The records can optionally be
* passed to kernel in the ATAGs
*/
#include <common.h>
#include <libfdt.h>
#include <fdt_decode.h>
DECLARE_GLOBAL_DATA_PTR;
struct bootstage_record {
uint32_t time_us;
uint32_t start_us;
const char *name;
};
static struct bootstage_record record[BOOTSTAGE_COUNT] = {{1, 0, "avoid_bss"} };
uint32_t bootstage_mark(enum bootstage_id id, const char *name)
{
struct bootstage_record *rec = &record[id];
/* Only record the first event for each */
if (!rec->name) {
rec->time_us = (uint32_t)timer_get_us();
rec->start_us = 0;
rec->name = name;
}
return rec->time_us;
}
uint32_t bootstage_start(enum bootstage_id id, const char *name)
{
struct bootstage_record *rec = &record[id];
rec->start_us = timer_get_us();
rec->name = name;
return rec->start_us;
}
uint32_t bootstage_accum(enum bootstage_id id)
{
struct bootstage_record *rec = &record[id];
uint32_t duration;
duration = (uint32_t)timer_get_us() - rec->start_us;
rec->time_us += duration;
return duration;
}
static void print_time(unsigned long us_time)
{
char str[12], *s;
int grab = 3;
/* We don't seem to have %'d in U-Boot */
sprintf(str, "%9ld", us_time);
for (s = str; *s; s += grab) {
if (s != str)
putc(s[-1] != ' ' ? ',' : ' ');
printf("%.*s", grab, s);
grab = 3;
}
}
static uint32_t print_time_record(enum bootstage_id id,
struct bootstage_record *rec, uint32_t prev)
{
if (prev == -1U) {
printf("%11s", "");
print_time(rec->time_us);
} else {
print_time(rec->time_us);
print_time(rec->time_us - prev);
}
if (rec->name)
printf(" %s\n", rec->name);
else
printf(" id=%d\n", id);
return rec->time_us;
}
static int h_compare_record(const void *r1, const void *r2)
{
const struct bootstage_record *rec1 = r1, *rec2 = r2;
return rec1->time_us - rec2->time_us;
}
#define BOOTSTAGE_NODE "bootstage"
/**
* This function add a new node to the device tree.
*
* @param pathp the path where the new node is added.
* @param nodep the name of the new node
* @return 0 on success, != 0 on failure.
*/
static int add_new_node(struct fdt_header *fdt,
const char *pathp, const char *nodep)
{
int nodeoffset;
int err;
nodeoffset = fdt_path_offset(fdt, pathp);
if (nodeoffset < 0)
return nodeoffset;
err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
if (err < 0)
return err;
return 0;
}
/**
* this function add all bootstage timings to the device tree.
*
* @param fdt the point to the device tree.
* @return 0 on success, != 0 on failure.
*/
static int add_bootstages_devicetree(struct fdt_header *fdt)
{
int id;
int i;
int ret = 0;
if (fdt == NULL)
return 0;
/*
* Create the node for bootstage.
* The address of flat device tree is set up by the command bootm.
*/
ret = add_new_node(fdt, "/", BOOTSTAGE_NODE);
/*
* insert the timings to the device tree in the reverse order,
* so that they can be printed in the Linux kernel in the right order.
*/
for (id = BOOTSTAGE_COUNT - 1, i = 0; id >= 0 && ret == 0; id--) {
struct bootstage_record *rec = &record[id];
static char path[32];
static char node[8];
int nodeoffset;
sprintf(path, "/%s/", BOOTSTAGE_NODE);
if (id != BOOTSTAGE_AWAKE && rec->time_us == 0)
continue;
sprintf(node, "%d", i);
if ((ret = add_new_node(fdt, path, node)))
break;
/* add properties to the node. */
strncat(path, node, sizeof(path) - strlen(path));
nodeoffset = fdt_path_offset(fdt, path);
if (nodeoffset < 0)
ret = nodeoffset;
if (!ret)
ret = fdt_setprop_string(fdt, nodeoffset, "name", rec->name);
if (!ret)
ret = fdt_setprop_cell(fdt, nodeoffset, "time", rec->time_us);
i++;
}
if (ret)
printf("add_bootstages: failed to add to device tree\n");
return ret;
}
void bootstage_report(void)
{
struct bootstage_record *rec = record;
int id;
uint32_t prev;
u32 flags = gd->flags;
#ifdef CONFIG_OF_CONTROL
/* Force this information to display even on silent console */
if (fdt_decode_get_config_int(gd->blob, "bootstage-force-report", 0))
gd->flags &= ~GD_FLG_SILENT;
#endif
puts("Timer summary in microseconds:\n");
printf("%11s%11s %s\n", "Mark", "Elapsed", "Stage");
/* Fake the first record - we could get it from early boot */
rec->name = "reset";
rec->time_us = 0;
prev = print_time_record(BOOTSTAGE_AWAKE, rec, 0);
/* Sort records by increasing time */
qsort(record, ARRAY_SIZE(record), sizeof(*rec), h_compare_record);
for (id = 0; id < BOOTSTAGE_COUNT; id++, rec++) {
if (rec->time_us != 0 && !rec->start_us)
prev = print_time_record(id, rec, prev);
}
puts("\nAccumulated time:\n");
for (id = 0, rec = record; id < BOOTSTAGE_COUNT; id++, rec++) {
if (rec->start_us)
prev = print_time_record(id, rec, -1);
}
add_bootstages_devicetree(working_fdt);
if (flags & GD_FLG_SILENT)
gd->flags |= GD_FLG_SILENT;
}
|
