blob: d6b93553dcb52580153f2335bcdfdf562999c612 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk20e0e232002-09-08 16:09:41 +00002/*
3 * (C) Copyright 2000-2002
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
wdenk20e0e232002-09-08 16:09:41 +00005 */
6
Simon Glass90606da2020-06-07 20:33:00 -06007#include <compiler.h>
Simon Glass24b852a2015-11-08 23:47:45 -07008#include <console.h>
Simon Glass4e4bf942022-07-31 12:28:48 -06009#include <display_options.h>
Simon Glass33eac2d2015-04-29 07:56:43 -060010#include <div64.h>
Pali Rohárbdfb6d72021-08-02 15:18:31 +020011#include <version_string.h>
Grant Likelyc95c4282007-02-20 09:05:00 +010012#include <linux/ctype.h>
Tom Rini4abbed72023-12-14 13:16:56 -050013#include <linux/kernel.h>
Grant Likelyc95c4282007-02-20 09:05:00 +010014#include <asm/io.h>
Tom Rini4abbed72023-12-14 13:16:56 -050015#include <vsprintf.h>
wdenk20e0e232002-09-08 16:09:41 +000016
Simon Glass6c519f22017-06-16 12:51:42 -060017char *display_options_get_banner_priv(bool newlines, const char *build_tag,
18 char *buf, int size)
wdenk20e0e232002-09-08 16:09:41 +000019{
Simon Glass6c519f22017-06-16 12:51:42 -060020 int len;
21
22 len = snprintf(buf, size, "%s%s", newlines ? "\n\n" : "",
23 version_string);
24 if (build_tag && len < size)
25 len += snprintf(buf + len, size - len, ", Build: %s",
26 build_tag);
27 if (len > size - 3)
28 len = size - 3;
Heinrich Schuchardt6c74e942019-04-26 18:39:00 +020029 if (len < 0)
30 len = 0;
31 snprintf(buf + len, size - len, "\n\n");
Simon Glass6c519f22017-06-16 12:51:42 -060032
33 return buf;
34}
35
36#ifndef BUILD_TAG
37#define BUILD_TAG NULL
wdenk20e0e232002-09-08 16:09:41 +000038#endif
Simon Glass6c519f22017-06-16 12:51:42 -060039
40char *display_options_get_banner(bool newlines, char *buf, int size)
41{
42 return display_options_get_banner_priv(newlines, BUILD_TAG, buf, size);
43}
44
45int display_options(void)
46{
47 char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
48
49 display_options_get_banner(true, buf, sizeof(buf));
50 printf("%s", buf);
51
wdenk20e0e232002-09-08 16:09:41 +000052 return 0;
53}
54
Simon Glass33eac2d2015-04-29 07:56:43 -060055void print_freq(uint64_t freq, const char *s)
56{
Heiko Schocher80402f32015-06-29 09:10:46 +020057 unsigned long m = 0;
Simon Glass33eac2d2015-04-29 07:56:43 -060058 uint32_t f;
Heinrich Schuchardtdcf16722020-10-08 22:23:23 +020059 static const char names[] = {'G', 'M', 'k'};
Simon Glass33eac2d2015-04-29 07:56:43 -060060 unsigned long d = 1e9;
61 char c = 0;
62 unsigned int i;
63
64 for (i = 0; i < ARRAY_SIZE(names); i++, d /= 1000) {
65 if (freq >= d) {
66 c = names[i];
67 break;
68 }
69 }
70
71 if (!c) {
Masahiro Yamadadee37fc2018-08-06 20:47:40 +090072 printf("%llu Hz%s", freq, s);
Simon Glass33eac2d2015-04-29 07:56:43 -060073 return;
74 }
75
76 f = do_div(freq, d);
Simon Glass33eac2d2015-04-29 07:56:43 -060077
78 /* If there's a remainder, show the first few digits */
79 if (f) {
80 m = f;
81 while (m > 1000)
82 m /= 10;
83 while (m && !(m % 10))
84 m /= 10;
85 if (m >= 100)
86 m = (m / 10) + (m % 100 >= 50);
87 }
88
Suriyan Ramasamie9015b32015-08-18 09:25:33 -070089 printf("%lu", (unsigned long) freq);
Simon Glass33eac2d2015-04-29 07:56:43 -060090 if (m)
91 printf(".%ld", m);
92 printf(" %cHz%s", c, s);
93}
94
Simon Glassc6da9ae2014-10-15 04:38:35 -060095void print_size(uint64_t size, const char *s)
wdenk20e0e232002-09-08 16:09:41 +000096{
Timur Tabi52dbac62010-04-13 13:16:02 -050097 unsigned long m = 0, n;
Simon Glassc6da9ae2014-10-15 04:38:35 -060098 uint64_t f;
Timur Tabi4b42c902010-04-13 13:16:03 -050099 static const char names[] = {'E', 'P', 'T', 'G', 'M', 'K'};
Nick Thompsonf2d76ae2010-05-11 11:29:52 +0100100 unsigned long d = 10 * ARRAY_SIZE(names);
Timur Tabi4b42c902010-04-13 13:16:03 -0500101 char c = 0;
102 unsigned int i;
wdenk20e0e232002-09-08 16:09:41 +0000103
Nick Thompsonf2d76ae2010-05-11 11:29:52 +0100104 for (i = 0; i < ARRAY_SIZE(names); i++, d -= 10) {
105 if (size >> d) {
Timur Tabi4b42c902010-04-13 13:16:03 -0500106 c = names[i];
107 break;
Becky Bruce417faf22008-07-09 11:09:41 -0500108 }
wdenk20e0e232002-09-08 16:09:41 +0000109 }
110
Timur Tabi4b42c902010-04-13 13:16:03 -0500111 if (!c) {
Matwey V. Kornilovf52352f2021-08-06 00:22:58 +0300112 /*
113 * SPL tiny-printf is not capable for printing uint64_t.
114 * We have just checked that the size is small enought to fit
115 * unsigned int safely.
116 */
117 printf("%u Bytes%s", (unsigned int)size, s);
Timur Tabi4b42c902010-04-13 13:16:03 -0500118 return;
119 }
120
Nick Thompsonf2d76ae2010-05-11 11:29:52 +0100121 n = size >> d;
122 f = size & ((1ULL << d) - 1);
wdenk20e0e232002-09-08 16:09:41 +0000123
Becky Bruce417faf22008-07-09 11:09:41 -0500124 /* If there's a remainder, deal with it */
Nick Thompsonf2d76ae2010-05-11 11:29:52 +0100125 if (f) {
126 m = (10ULL * f + (1ULL << (d - 1))) >> d;
wdenk20e0e232002-09-08 16:09:41 +0000127
Becky Bruce417faf22008-07-09 11:09:41 -0500128 if (m >= 10) {
129 m -= 10;
130 n += 1;
Pali Rohárd1790182022-09-12 21:02:27 +0200131
132 if (n == 1024 && i > 0) {
133 n = 1;
134 m = 0;
135 c = names[i - 1];
136 }
Becky Bruce417faf22008-07-09 11:09:41 -0500137 }
wdenk0d498392003-07-01 21:06:45 +0000138 }
139
Timur Tabi4b42c902010-04-13 13:16:03 -0500140 printf ("%lu", n);
wdenk20e0e232002-09-08 16:09:41 +0000141 if (m) {
142 printf (".%ld", m);
143 }
Timur Tabi4b42c902010-04-13 13:16:03 -0500144 printf (" %ciB%s", c, s);
wdenk20e0e232002-09-08 16:09:41 +0000145}
Grant Likelyc95c4282007-02-20 09:05:00 +0100146
Simon Glass0cceb992021-05-08 07:00:05 -0600147#define MAX_LINE_LENGTH_BYTES 64
148#define DEFAULT_LINE_LENGTH_BYTES 16
149
150int hexdump_line(ulong addr, const void *data, uint width, uint count,
151 uint linelen, char *out, int size)
Grant Likelyc95c4282007-02-20 09:05:00 +0100152{
Reinhard Meyer150f7232010-09-08 12:25:40 +0200153 /* linebuf as a union causes proper alignment */
154 union linebuf {
York Sun4d1fd7f2014-02-26 17:03:19 -0800155 uint64_t uq[MAX_LINE_LENGTH_BYTES/sizeof(uint64_t) + 1];
Reinhard Meyer150f7232010-09-08 12:25:40 +0200156 uint32_t ui[MAX_LINE_LENGTH_BYTES/sizeof(uint32_t) + 1];
157 uint16_t us[MAX_LINE_LENGTH_BYTES/sizeof(uint16_t) + 1];
158 uint8_t uc[MAX_LINE_LENGTH_BYTES/sizeof(uint8_t) + 1];
159 } lb;
Simon Glass0cceb992021-05-08 07:00:05 -0600160 uint thislinelen;
Grant Likelyc95c4282007-02-20 09:05:00 +0100161 int i;
Simon Glass677dbf52020-06-02 19:26:47 -0600162 ulong x;
Grant Likelyc95c4282007-02-20 09:05:00 +0100163
Simon Glass0cceb992021-05-08 07:00:05 -0600164 if (linelen * width > MAX_LINE_LENGTH_BYTES)
165 linelen = MAX_LINE_LENGTH_BYTES / width;
166 if (linelen < 1)
167 linelen = DEFAULT_LINE_LENGTH_BYTES / width;
168
169 /*
170 * Check the size here so that we don't need to use snprintf(). This
171 * helps to reduce code size
172 */
173 if (size < HEXDUMP_MAX_BUF_LENGTH(linelen * width))
174 return -ENOSPC;
175
176 thislinelen = linelen;
177 out += sprintf(out, "%08lx:", addr);
178
179 /* check for overflow condition */
180 if (count < thislinelen)
181 thislinelen = count;
182
183 /* Copy from memory into linebuf and print hex values */
184 for (i = 0; i < thislinelen; i++) {
185 if (width == 4)
186 x = lb.ui[i] = *(volatile uint32_t *)data;
187 else if (MEM_SUPPORT_64BIT_DATA && width == 8)
188 x = lb.uq[i] = *(volatile ulong *)data;
189 else if (width == 2)
190 x = lb.us[i] = *(volatile uint16_t *)data;
191 else
192 x = lb.uc[i] = *(volatile uint8_t *)data;
193 if (CONFIG_IS_ENABLED(USE_TINY_PRINTF))
194 out += sprintf(out, " %x", (uint)x);
195 else
196 out += sprintf(out, " %0*lx", width * 2, x);
197 data += width;
198 }
199
200 /* fill line with whitespace for nice ASCII print */
201 for (i = 0; i < (linelen - thislinelen) * (width * 2 + 1); i++)
202 *out++ = ' ';
203
204 /* Print data in ASCII characters */
205 for (i = 0; i < thislinelen * width; i++) {
206 if (!isprint(lb.uc[i]) || lb.uc[i] >= 0x80)
207 lb.uc[i] = '.';
208 }
209 lb.uc[i] = '\0';
210 out += sprintf(out, " %s", lb.uc);
211
212 return thislinelen;
213}
214
215int print_buffer(ulong addr, const void *data, uint width, uint count,
216 uint linelen)
217{
Grant Likelyc95c4282007-02-20 09:05:00 +0100218 if (linelen*width > MAX_LINE_LENGTH_BYTES)
219 linelen = MAX_LINE_LENGTH_BYTES / width;
220 if (linelen < 1)
221 linelen = DEFAULT_LINE_LENGTH_BYTES / width;
222
223 while (count) {
Simon Glass0cceb992021-05-08 07:00:05 -0600224 uint thislinelen;
225 char buf[HEXDUMP_MAX_BUF_LENGTH(width * linelen)];
Grant Likelyc95c4282007-02-20 09:05:00 +0100226
Simon Glass0cceb992021-05-08 07:00:05 -0600227 thislinelen = hexdump_line(addr, data, width, count, linelen,
228 buf, sizeof(buf));
229 assert(thislinelen >= 0);
230 puts(buf);
231 putc('\n');
Grant Likelyc95c4282007-02-20 09:05:00 +0100232
233 /* update references */
Simon Glass0cceb992021-05-08 07:00:05 -0600234 data += thislinelen * width;
Andreas Bießmannefd7c112013-02-07 04:58:19 +0000235 addr += thislinelen * width;
236 count -= thislinelen;
Grant Likelyc95c4282007-02-20 09:05:00 +0100237
Simon Glass0cceb992021-05-08 07:00:05 -0600238 if (!IS_ENABLED(CONFIG_SPL_BUILD) && ctrlc())
239 return -EINTR;
Grant Likelyc95c4282007-02-20 09:05:00 +0100240 }
241
242 return 0;
243}