blob: a9b8a3ae67fa0817deefa3f1d5d559b97056eeb7 [file] [log] [blame]
wdenk153d5112002-08-30 11:07:04 +00001/*
2 * linux/lib/vsprintf.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8/*
9 * Wirzenius wrote this portably, Torvalds fucked it up :-)
Simon Glass3cce8a52011-10-21 18:51:33 +000010 *
11 * from hush: simple_itoa() was lifted from boa-0.93.15
wdenk153d5112002-08-30 11:07:04 +000012 */
13
14#include <stdarg.h>
15#include <linux/types.h>
16#include <linux/string.h>
17#include <linux/ctype.h>
Heiko Schochera7fd0d92011-05-02 21:33:49 +000018#include <errno.h>
wdenk153d5112002-08-30 11:07:04 +000019
20#include <common.h>
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000021#if !defined(CONFIG_PANIC_HANG)
wdenk153d5112002-08-30 11:07:04 +000022#include <command.h>
wdenk153d5112002-08-30 11:07:04 +000023#endif
24
Dirk Behme47910502009-07-22 17:51:56 +020025#include <div64.h>
Dirk Behme47910502009-07-22 17:51:56 +020026#define noinline __attribute__((noinline))
27
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000028unsigned long simple_strtoul(const char *cp, char **endp,
29 unsigned int base)
wdenk153d5112002-08-30 11:07:04 +000030{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000031 unsigned long result = 0;
32 unsigned long value;
wdenk153d5112002-08-30 11:07:04 +000033
34 if (*cp == '0') {
35 cp++;
36 if ((*cp == 'x') && isxdigit(cp[1])) {
37 base = 16;
38 cp++;
39 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000040
41 if (!base)
wdenk153d5112002-08-30 11:07:04 +000042 base = 8;
wdenk153d5112002-08-30 11:07:04 +000043 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000044
45 if (!base)
wdenk153d5112002-08-30 11:07:04 +000046 base = 10;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000047
wdenk153d5112002-08-30 11:07:04 +000048 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
49 ? toupper(*cp) : *cp)-'A'+10) < base) {
50 result = result*base + value;
51 cp++;
52 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000053
wdenk153d5112002-08-30 11:07:04 +000054 if (endp)
55 *endp = (char *)cp;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000056
wdenk153d5112002-08-30 11:07:04 +000057 return result;
58}
59
Heiko Schochera7fd0d92011-05-02 21:33:49 +000060int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
61{
62 char *tail;
63 unsigned long val;
64 size_t len;
65
66 *res = 0;
67 len = strlen(cp);
68 if (len == 0)
69 return -EINVAL;
70
71 val = simple_strtoul(cp, &tail, base);
72 if (tail == cp)
73 return -EINVAL;
74
75 if ((*tail == '\0') ||
76 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
77 *res = val;
78 return 0;
79 }
80
81 return -EINVAL;
82}
83
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000084long simple_strtol(const char *cp, char **endp, unsigned int base)
wdenk153d5112002-08-30 11:07:04 +000085{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000086 if (*cp == '-')
87 return -simple_strtoul(cp + 1, endp, base);
88
89 return simple_strtoul(cp, endp, base);
wdenk153d5112002-08-30 11:07:04 +000090}
91
Lukasz Majewski3ec44112012-12-11 11:09:42 +010092unsigned long ustrtoul(const char *cp, char **endp, unsigned int base)
Kyungmin Park7e6ee7a2008-11-19 16:32:36 +010093{
94 unsigned long result = simple_strtoul(cp, endp, base);
95 switch (**endp) {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000096 case 'G':
Kyungmin Park7e6ee7a2008-11-19 16:32:36 +010097 result *= 1024;
98 /* fall through */
99 case 'M':
100 result *= 1024;
101 /* fall through */
102 case 'K':
103 case 'k':
104 result *= 1024;
105 if ((*endp)[1] == 'i') {
106 if ((*endp)[2] == 'B')
107 (*endp) += 3;
108 else
109 (*endp) += 2;
110 }
111 }
112 return result;
113}
114
Piotr Wilczek7df54d32013-01-27 22:59:24 +0000115unsigned long long ustrtoull(const char *cp, char **endp, unsigned int base)
116{
117 unsigned long long result = simple_strtoull(cp, endp, base);
118 switch (**endp) {
119 case 'G':
120 result *= 1024;
121 /* fall through */
122 case 'M':
123 result *= 1024;
124 /* fall through */
125 case 'K':
126 case 'k':
127 result *= 1024;
128 if ((*endp)[1] == 'i') {
129 if ((*endp)[2] == 'B')
130 (*endp) += 3;
131 else
132 (*endp) += 2;
133 }
134 }
135 return result;
136}
137
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000138unsigned long long simple_strtoull(const char *cp, char **endp,
139 unsigned int base)
wdenkc40b2952004-03-13 23:29:43 +0000140{
141 unsigned long long result = 0, value;
142
143 if (*cp == '0') {
144 cp++;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000145 if ((*cp == 'x') && isxdigit(cp[1])) {
wdenkc40b2952004-03-13 23:29:43 +0000146 base = 16;
147 cp++;
148 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000149
150 if (!base)
wdenkc40b2952004-03-13 23:29:43 +0000151 base = 8;
wdenkc40b2952004-03-13 23:29:43 +0000152 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000153
154 if (!base)
wdenkc40b2952004-03-13 23:29:43 +0000155 base = 10;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000156
157 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp - '0'
158 : (islower(*cp) ? toupper(*cp) : *cp) - 'A' + 10) < base) {
wdenkc40b2952004-03-13 23:29:43 +0000159 result = result * base + value;
160 cp++;
161 }
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000162
wdenkc40b2952004-03-13 23:29:43 +0000163 if (endp)
164 *endp = (char *) cp;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000165
wdenkc40b2952004-03-13 23:29:43 +0000166 return result;
167}
wdenkc40b2952004-03-13 23:29:43 +0000168
wdenk153d5112002-08-30 11:07:04 +0000169/* we use this so that we can do without the ctype library */
170#define is_digit(c) ((c) >= '0' && (c) <= '9')
171
172static int skip_atoi(const char **s)
173{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000174 int i = 0;
wdenk153d5112002-08-30 11:07:04 +0000175
176 while (is_digit(**s))
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000177 i = i * 10 + *((*s)++) - '0';
178
wdenk153d5112002-08-30 11:07:04 +0000179 return i;
180}
181
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500182/* Decimal conversion is by far the most typical, and is used
183 * for /proc and /sys data. This directly impacts e.g. top performance
184 * with many processes running. We optimize it for speed
185 * using code from
186 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
187 * (with permission from the author, Douglas W. Jones). */
188
189/* Formats correctly any integer in [0,99999].
190 * Outputs from one to five digits depending on input.
191 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000192static char *put_dec_trunc(char *buf, unsigned q)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500193{
194 unsigned d3, d2, d1, d0;
195 d1 = (q>>4) & 0xf;
196 d2 = (q>>8) & 0xf;
197 d3 = (q>>12);
198
199 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
200 q = (d0 * 0xcd) >> 11;
201 d0 = d0 - 10*q;
202 *buf++ = d0 + '0'; /* least significant digit */
203 d1 = q + 9*d3 + 5*d2 + d1;
204 if (d1 != 0) {
205 q = (d1 * 0xcd) >> 11;
206 d1 = d1 - 10*q;
207 *buf++ = d1 + '0'; /* next digit */
208
209 d2 = q + 2*d2;
210 if ((d2 != 0) || (d3 != 0)) {
211 q = (d2 * 0xd) >> 7;
212 d2 = d2 - 10*q;
213 *buf++ = d2 + '0'; /* next digit */
214
215 d3 = q + 4*d3;
216 if (d3 != 0) {
217 q = (d3 * 0xcd) >> 11;
218 d3 = d3 - 10*q;
219 *buf++ = d3 + '0'; /* next digit */
220 if (q != 0)
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000221 *buf++ = q + '0'; /* most sign. digit */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500222 }
223 }
224 }
225 return buf;
226}
227/* Same with if's removed. Always emits five digits */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000228static char *put_dec_full(char *buf, unsigned q)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500229{
230 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
231 /* but anyway, gcc produces better code with full-sized ints */
232 unsigned d3, d2, d1, d0;
233 d1 = (q>>4) & 0xf;
234 d2 = (q>>8) & 0xf;
235 d3 = (q>>12);
236
Wolfgang Denkc0a14ae2009-04-05 00:27:57 +0200237 /*
238 * Possible ways to approx. divide by 10
239 * gcc -O2 replaces multiply with shifts and adds
240 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
241 * (x * 0x67) >> 10: 1100111
242 * (x * 0x34) >> 9: 110100 - same
243 * (x * 0x1a) >> 8: 11010 - same
244 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386)
245 */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500246
247 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
248 q = (d0 * 0xcd) >> 11;
249 d0 = d0 - 10*q;
250 *buf++ = d0 + '0';
251 d1 = q + 9*d3 + 5*d2 + d1;
252 q = (d1 * 0xcd) >> 11;
253 d1 = d1 - 10*q;
254 *buf++ = d1 + '0';
255
256 d2 = q + 2*d2;
257 q = (d2 * 0xd) >> 7;
258 d2 = d2 - 10*q;
259 *buf++ = d2 + '0';
260
261 d3 = q + 4*d3;
262 q = (d3 * 0xcd) >> 11; /* - shorter code */
263 /* q = (d3 * 0x67) >> 10; - would also work */
264 d3 = d3 - 10*q;
265 *buf++ = d3 + '0';
266 *buf++ = q + '0';
267 return buf;
268}
269/* No inlining helps gcc to use registers better */
Simon Glass6bf67252014-10-15 04:38:34 -0600270static noinline char *put_dec(char *buf, uint64_t num)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500271{
272 while (1) {
273 unsigned rem;
274 if (num < 100000)
275 return put_dec_trunc(buf, num);
276 rem = do_div(num, 100000);
277 buf = put_dec_full(buf, rem);
278 }
279}
280
wdenk153d5112002-08-30 11:07:04 +0000281#define ZEROPAD 1 /* pad with zero */
282#define SIGN 2 /* unsigned/signed long */
283#define PLUS 4 /* show plus */
284#define SPACE 8 /* space if plus */
285#define LEFT 16 /* left justified */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500286#define SMALL 32 /* Must be 32 == 0x20 */
287#define SPECIAL 64 /* 0x */
wdenk153d5112002-08-30 11:07:04 +0000288
Sonny Rao046a37b2011-11-02 09:52:08 +0000289#ifdef CONFIG_SYS_VSNPRINTF
290/*
291 * Macro to add a new character to our output string, but only if it will
292 * fit. The macro moves to the next character position in the output string.
293 */
294#define ADDCH(str, ch) do { \
295 if ((str) < end) \
296 *(str) = (ch); \
297 ++str; \
298 } while (0)
299#else
300#define ADDCH(str, ch) (*(str)++ = (ch))
301#endif
302
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000303static char *number(char *buf, char *end, u64 num,
Sonny Rao046a37b2011-11-02 09:52:08 +0000304 int base, int size, int precision, int type)
wdenk153d5112002-08-30 11:07:04 +0000305{
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500306 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000307 static const char digits[16] = "0123456789ABCDEF";
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500308
309 char tmp[66];
310 char sign;
311 char locase;
312 int need_pfx = ((type & SPECIAL) && base != 10);
wdenk153d5112002-08-30 11:07:04 +0000313 int i;
314
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500315 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
316 * produces same digits or (maybe lowercased) letters */
317 locase = (type & SMALL);
wdenk153d5112002-08-30 11:07:04 +0000318 if (type & LEFT)
319 type &= ~ZEROPAD;
wdenk153d5112002-08-30 11:07:04 +0000320 sign = 0;
321 if (type & SIGN) {
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000322 if ((s64) num < 0) {
wdenk153d5112002-08-30 11:07:04 +0000323 sign = '-';
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000324 num = -(s64) num;
wdenk153d5112002-08-30 11:07:04 +0000325 size--;
326 } else if (type & PLUS) {
327 sign = '+';
328 size--;
329 } else if (type & SPACE) {
330 sign = ' ';
331 size--;
332 }
333 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500334 if (need_pfx) {
335 size--;
wdenk153d5112002-08-30 11:07:04 +0000336 if (base == 16)
wdenk153d5112002-08-30 11:07:04 +0000337 size--;
338 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500339
340 /* generate full string in tmp[], in reverse order */
wdenk153d5112002-08-30 11:07:04 +0000341 i = 0;
342 if (num == 0)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500343 tmp[i++] = '0';
344 /* Generic code, for any base:
345 else do {
346 tmp[i++] = (digits[do_div(num,base)] | locase);
347 } while (num != 0);
348 */
349 else if (base != 10) { /* 8 or 16 */
350 int mask = base - 1;
351 int shift = 3;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000352
353 if (base == 16)
354 shift = 4;
355
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500356 do {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000357 tmp[i++] = (digits[((unsigned char)num) & mask]
358 | locase);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500359 num >>= shift;
360 } while (num);
361 } else { /* base 10 */
362 i = put_dec(tmp, num) - tmp;
363 }
364
365 /* printing 100 using %2d gives "100", not "00" */
wdenk153d5112002-08-30 11:07:04 +0000366 if (i > precision)
367 precision = i;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500368 /* leading space padding */
wdenk153d5112002-08-30 11:07:04 +0000369 size -= precision;
Sonny Rao046a37b2011-11-02 09:52:08 +0000370 if (!(type & (ZEROPAD + LEFT))) {
371 while (--size >= 0)
372 ADDCH(buf, ' ');
373 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500374 /* sign */
wdenk153d5112002-08-30 11:07:04 +0000375 if (sign)
Sonny Rao046a37b2011-11-02 09:52:08 +0000376 ADDCH(buf, sign);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500377 /* "0x" / "0" prefix */
378 if (need_pfx) {
Sonny Rao046a37b2011-11-02 09:52:08 +0000379 ADDCH(buf, '0');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500380 if (base == 16)
Sonny Rao046a37b2011-11-02 09:52:08 +0000381 ADDCH(buf, 'X' | locase);
wdenk153d5112002-08-30 11:07:04 +0000382 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500383 /* zero or space padding */
384 if (!(type & LEFT)) {
385 char c = (type & ZEROPAD) ? '0' : ' ';
Sonny Rao046a37b2011-11-02 09:52:08 +0000386
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500387 while (--size >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000388 ADDCH(buf, c);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500389 }
390 /* hmm even more zero padding? */
391 while (i <= --precision)
Sonny Rao046a37b2011-11-02 09:52:08 +0000392 ADDCH(buf, '0');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500393 /* actual digits of result */
394 while (--i >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000395 ADDCH(buf, tmp[i]);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500396 /* trailing space padding */
397 while (--size >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000398 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500399 return buf;
wdenk153d5112002-08-30 11:07:04 +0000400}
401
Sonny Rao046a37b2011-11-02 09:52:08 +0000402static char *string(char *buf, char *end, char *s, int field_width,
403 int precision, int flags)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500404{
405 int len, i;
wdenk153d5112002-08-30 11:07:04 +0000406
Kim Phillips0eb25762012-10-29 13:34:36 +0000407 if (s == NULL)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500408 s = "<NULL>";
409
410 len = strnlen(s, precision);
411
412 if (!(flags & LEFT))
413 while (len < field_width--)
Sonny Rao046a37b2011-11-02 09:52:08 +0000414 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500415 for (i = 0; i < len; ++i)
Sonny Rao046a37b2011-11-02 09:52:08 +0000416 ADDCH(buf, *s++);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500417 while (len < field_width--)
Sonny Rao046a37b2011-11-02 09:52:08 +0000418 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500419 return buf;
420}
421
422#ifdef CONFIG_CMD_NET
Jeroen Hofsteed7b2d9d2014-07-10 22:33:00 +0200423static const char hex_asc[] = "0123456789abcdef";
424#define hex_asc_lo(x) hex_asc[((x) & 0x0f)]
425#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4]
426
427static inline char *pack_hex_byte(char *buf, u8 byte)
428{
429 *buf++ = hex_asc_hi(byte);
430 *buf++ = hex_asc_lo(byte);
431 return buf;
432}
433
Sonny Rao046a37b2011-11-02 09:52:08 +0000434static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500435 int precision, int flags)
436{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000437 /* (6 * 2 hex digits), 5 colons and trailing zero */
438 char mac_addr[6 * 3];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500439 char *p = mac_addr;
440 int i;
441
442 for (i = 0; i < 6; i++) {
443 p = pack_hex_byte(p, addr[i]);
444 if (!(flags & SPECIAL) && i != 5)
445 *p++ = ':';
446 }
447 *p = '\0';
448
Sonny Rao046a37b2011-11-02 09:52:08 +0000449 return string(buf, end, mac_addr, field_width, precision,
450 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500451}
452
Sonny Rao046a37b2011-11-02 09:52:08 +0000453static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500454 int precision, int flags)
455{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000456 /* (8 * 4 hex digits), 7 colons and trailing zero */
457 char ip6_addr[8 * 5];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500458 char *p = ip6_addr;
459 int i;
460
461 for (i = 0; i < 8; i++) {
462 p = pack_hex_byte(p, addr[2 * i]);
463 p = pack_hex_byte(p, addr[2 * i + 1]);
464 if (!(flags & SPECIAL) && i != 7)
465 *p++ = ':';
466 }
467 *p = '\0';
468
Sonny Rao046a37b2011-11-02 09:52:08 +0000469 return string(buf, end, ip6_addr, field_width, precision,
470 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500471}
472
Sonny Rao046a37b2011-11-02 09:52:08 +0000473static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500474 int precision, int flags)
475{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000476 /* (4 * 3 decimal digits), 3 dots and trailing zero */
477 char ip4_addr[4 * 4];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500478 char temp[3]; /* hold each IP quad in reverse order */
479 char *p = ip4_addr;
480 int i, digits;
481
482 for (i = 0; i < 4; i++) {
483 digits = put_dec_trunc(temp, addr[i]) - temp;
484 /* reverse the digits in the quad */
485 while (digits--)
486 *p++ = temp[digits];
487 if (i != 3)
488 *p++ = '.';
489 }
490 *p = '\0';
491
Sonny Rao046a37b2011-11-02 09:52:08 +0000492 return string(buf, end, ip4_addr, field_width, precision,
493 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500494}
495#endif
496
497/*
498 * Show a '%p' thing. A kernel extension is that the '%p' is followed
499 * by an extra set of alphanumeric characters that are extended format
500 * specifiers.
501 *
502 * Right now we handle:
503 *
504 * - 'M' For a 6-byte MAC address, it prints the address in the
505 * usual colon-separated hex notation
506 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated
507 * decimal for v4 and colon separated network-order 16 bit hex for v6)
508 * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
509 * currently the same
510 *
511 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
512 * function pointers are really function descriptors, which contain a
513 * pointer to the real address.
514 */
Sonny Rao046a37b2011-11-02 09:52:08 +0000515static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
516 int field_width, int precision, int flags)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500517{
Thierry Reding1eebd142014-11-12 18:26:47 -0700518 u64 num = (uintptr_t)ptr;
519
Wolfgang Denkd266f662012-10-30 09:19:52 +0000520 /*
521 * Being a boot loader, we explicitly allow pointers to
522 * (physical) address null.
523 */
524#if 0
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500525 if (!ptr)
Sonny Rao046a37b2011-11-02 09:52:08 +0000526 return string(buf, end, "(null)", field_width, precision,
527 flags);
Wolfgang Denkd266f662012-10-30 09:19:52 +0000528#endif
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500529
530#ifdef CONFIG_CMD_NET
531 switch (*fmt) {
Thierry Reding1eebd142014-11-12 18:26:47 -0700532 case 'a':
533 flags |= SPECIAL | ZEROPAD;
534
535 switch (fmt[1]) {
536 case 'p':
537 default:
538 field_width = sizeof(phys_addr_t) * 2 + 2;
539 num = *(phys_addr_t *)ptr;
540 break;
541 }
542 break;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500543 case 'm':
544 flags |= SPECIAL;
545 /* Fallthrough */
546 case 'M':
Sonny Rao046a37b2011-11-02 09:52:08 +0000547 return mac_address_string(buf, end, ptr, field_width,
548 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500549 case 'i':
550 flags |= SPECIAL;
551 /* Fallthrough */
552 case 'I':
553 if (fmt[1] == '6')
Sonny Rao046a37b2011-11-02 09:52:08 +0000554 return ip6_addr_string(buf, end, ptr, field_width,
555 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500556 if (fmt[1] == '4')
Sonny Rao046a37b2011-11-02 09:52:08 +0000557 return ip4_addr_string(buf, end, ptr, field_width,
558 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500559 flags &= ~SPECIAL;
560 break;
561 }
562#endif
563 flags |= SMALL;
564 if (field_width == -1) {
565 field_width = 2*sizeof(void *);
566 flags |= ZEROPAD;
567 }
Thierry Reding1eebd142014-11-12 18:26:47 -0700568 return number(buf, end, num, 16, field_width, precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500569}
570
Sonny Rao046a37b2011-11-02 09:52:08 +0000571static int vsnprintf_internal(char *buf, size_t size, const char *fmt,
572 va_list args)
wdenk153d5112002-08-30 11:07:04 +0000573{
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000574 u64 num;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500575 int base;
576 char *str;
wdenk153d5112002-08-30 11:07:04 +0000577
578 int flags; /* flags to number() */
579
580 int field_width; /* width of output field */
581 int precision; /* min. # of digits for integers; max
582 number of chars for from string */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500583 int qualifier; /* 'h', 'l', or 'L' for integer fields */
584 /* 'z' support added 23/7/1999 S.H. */
585 /* 'z' changed to 'Z' --davidm 1/25/99 */
586 /* 't' added for ptrdiff_t */
Sonny Rao046a37b2011-11-02 09:52:08 +0000587 char *end = buf + size;
wdenk153d5112002-08-30 11:07:04 +0000588
Sonny Rao046a37b2011-11-02 09:52:08 +0000589#ifdef CONFIG_SYS_VSNPRINTF
590 /* Make sure end is always >= buf - do we want this in U-Boot? */
591 if (end < buf) {
592 end = ((void *)-1);
593 size = end - buf;
594 }
595#endif
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500596 str = buf;
597
598 for (; *fmt ; ++fmt) {
wdenk153d5112002-08-30 11:07:04 +0000599 if (*fmt != '%') {
Sonny Rao046a37b2011-11-02 09:52:08 +0000600 ADDCH(str, *fmt);
wdenk153d5112002-08-30 11:07:04 +0000601 continue;
602 }
603
604 /* process flags */
605 flags = 0;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000606repeat:
wdenk153d5112002-08-30 11:07:04 +0000607 ++fmt; /* this also skips first '%' */
608 switch (*fmt) {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000609 case '-':
610 flags |= LEFT;
611 goto repeat;
612 case '+':
613 flags |= PLUS;
614 goto repeat;
615 case ' ':
616 flags |= SPACE;
617 goto repeat;
618 case '#':
619 flags |= SPECIAL;
620 goto repeat;
621 case '0':
622 flags |= ZEROPAD;
623 goto repeat;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500624 }
wdenk153d5112002-08-30 11:07:04 +0000625
626 /* get field width */
627 field_width = -1;
628 if (is_digit(*fmt))
629 field_width = skip_atoi(&fmt);
630 else if (*fmt == '*') {
631 ++fmt;
632 /* it's the next argument */
633 field_width = va_arg(args, int);
634 if (field_width < 0) {
635 field_width = -field_width;
636 flags |= LEFT;
637 }
638 }
639
640 /* get the precision */
641 precision = -1;
642 if (*fmt == '.') {
643 ++fmt;
644 if (is_digit(*fmt))
645 precision = skip_atoi(&fmt);
646 else if (*fmt == '*') {
647 ++fmt;
648 /* it's the next argument */
649 precision = va_arg(args, int);
650 }
651 if (precision < 0)
652 precision = 0;
653 }
654
655 /* get the conversion qualifier */
656 qualifier = -1;
Jean-Christophe PLAGNIOL-VILLARDf354b732008-07-14 14:11:45 +0200657 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500658 *fmt == 'Z' || *fmt == 'z' || *fmt == 't') {
wdenk153d5112002-08-30 11:07:04 +0000659 qualifier = *fmt;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500660 ++fmt;
661 if (qualifier == 'l' && *fmt == 'l') {
662 qualifier = 'L';
James Yangbf052932008-01-10 16:02:07 -0600663 ++fmt;
664 }
wdenk153d5112002-08-30 11:07:04 +0000665 }
666
667 /* default base */
668 base = 10;
669
670 switch (*fmt) {
671 case 'c':
Sonny Rao046a37b2011-11-02 09:52:08 +0000672 if (!(flags & LEFT)) {
wdenk153d5112002-08-30 11:07:04 +0000673 while (--field_width > 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000674 ADDCH(str, ' ');
675 }
676 ADDCH(str, (unsigned char) va_arg(args, int));
wdenk153d5112002-08-30 11:07:04 +0000677 while (--field_width > 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000678 ADDCH(str, ' ');
wdenk153d5112002-08-30 11:07:04 +0000679 continue;
680
681 case 's':
Sonny Rao046a37b2011-11-02 09:52:08 +0000682 str = string(str, end, va_arg(args, char *),
683 field_width, precision, flags);
wdenk153d5112002-08-30 11:07:04 +0000684 continue;
685
686 case 'p':
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000687 str = pointer(fmt + 1, str, end,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500688 va_arg(args, void *),
689 field_width, precision, flags);
690 /* Skip all alphanumeric pointer suffixes */
691 while (isalnum(fmt[1]))
692 fmt++;
wdenk153d5112002-08-30 11:07:04 +0000693 continue;
694
wdenk153d5112002-08-30 11:07:04 +0000695 case 'n':
696 if (qualifier == 'l') {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000697 long *ip = va_arg(args, long *);
wdenk153d5112002-08-30 11:07:04 +0000698 *ip = (str - buf);
699 } else {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000700 int *ip = va_arg(args, int *);
wdenk153d5112002-08-30 11:07:04 +0000701 *ip = (str - buf);
702 }
703 continue;
704
705 case '%':
Sonny Rao046a37b2011-11-02 09:52:08 +0000706 ADDCH(str, '%');
wdenk153d5112002-08-30 11:07:04 +0000707 continue;
708
709 /* integer number formats - set up the flags and "break" */
710 case 'o':
711 base = 8;
712 break;
713
wdenk153d5112002-08-30 11:07:04 +0000714 case 'x':
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500715 flags |= SMALL;
716 case 'X':
wdenk153d5112002-08-30 11:07:04 +0000717 base = 16;
718 break;
719
720 case 'd':
721 case 'i':
722 flags |= SIGN;
723 case 'u':
724 break;
725
726 default:
Sonny Rao046a37b2011-11-02 09:52:08 +0000727 ADDCH(str, '%');
wdenk153d5112002-08-30 11:07:04 +0000728 if (*fmt)
Sonny Rao046a37b2011-11-02 09:52:08 +0000729 ADDCH(str, *fmt);
wdenk153d5112002-08-30 11:07:04 +0000730 else
731 --fmt;
732 continue;
733 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500734 if (qualifier == 'L') /* "quad" for 64 bit variables */
wdenkc40b2952004-03-13 23:29:43 +0000735 num = va_arg(args, unsigned long long);
Heiko Schocher4b142fe2009-12-03 11:21:21 +0100736 else if (qualifier == 'l') {
wdenk153d5112002-08-30 11:07:04 +0000737 num = va_arg(args, unsigned long);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500738 if (flags & SIGN)
739 num = (signed long) num;
Jean-Christophe PLAGNIOL-VILLARDf354b732008-07-14 14:11:45 +0200740 } else if (qualifier == 'Z' || qualifier == 'z') {
741 num = va_arg(args, size_t);
742 } else if (qualifier == 't') {
743 num = va_arg(args, ptrdiff_t);
744 } else if (qualifier == 'h') {
wdenk153d5112002-08-30 11:07:04 +0000745 num = (unsigned short) va_arg(args, int);
746 if (flags & SIGN)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500747 num = (signed short) num;
748 } else {
wdenk153d5112002-08-30 11:07:04 +0000749 num = va_arg(args, unsigned int);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500750 if (flags & SIGN)
751 num = (signed int) num;
752 }
Sonny Rao046a37b2011-11-02 09:52:08 +0000753 str = number(str, end, num, base, field_width, precision,
754 flags);
wdenk153d5112002-08-30 11:07:04 +0000755 }
Sonny Rao046a37b2011-11-02 09:52:08 +0000756
757#ifdef CONFIG_SYS_VSNPRINTF
758 if (size > 0) {
759 ADDCH(str, '\0');
760 if (str > end)
761 end[-1] = '\0';
Darwin Rambo686f60f2013-12-19 15:14:19 -0800762 --str;
Sonny Rao046a37b2011-11-02 09:52:08 +0000763 }
764#else
wdenk153d5112002-08-30 11:07:04 +0000765 *str = '\0';
Sonny Rao046a37b2011-11-02 09:52:08 +0000766#endif
767 /* the trailing null byte doesn't count towards the total */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000768 return str - buf;
wdenk153d5112002-08-30 11:07:04 +0000769}
770
Sonny Rao046a37b2011-11-02 09:52:08 +0000771#ifdef CONFIG_SYS_VSNPRINTF
772int vsnprintf(char *buf, size_t size, const char *fmt,
773 va_list args)
774{
775 return vsnprintf_internal(buf, size, fmt, args);
776}
777
Sonny Rao046a37b2011-11-02 09:52:08 +0000778int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
779{
780 int i;
781
782 i = vsnprintf(buf, size, fmt, args);
783
784 if (likely(i < size))
785 return i;
786 if (size != 0)
787 return size - 1;
788 return 0;
789}
790
Sonny Rao046a37b2011-11-02 09:52:08 +0000791int snprintf(char *buf, size_t size, const char *fmt, ...)
792{
793 va_list args;
794 int i;
795
796 va_start(args, fmt);
797 i = vsnprintf(buf, size, fmt, args);
798 va_end(args);
799
800 return i;
801}
802
Sonny Rao046a37b2011-11-02 09:52:08 +0000803int scnprintf(char *buf, size_t size, const char *fmt, ...)
804{
805 va_list args;
806 int i;
807
808 va_start(args, fmt);
809 i = vscnprintf(buf, size, fmt, args);
810 va_end(args);
811
812 return i;
813}
814#endif /* CONFIG_SYS_VSNPRINT */
815
816/**
817 * Format a string and place it in a buffer (va_list version)
818 *
819 * @param buf The buffer to place the result into
820 * @param fmt The format string to use
821 * @param args Arguments for the format string
822 *
823 * The function returns the number of characters written
824 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
825 * buffer overflows.
826 *
827 * If you're not already dealing with a va_list consider using sprintf().
828 */
829int vsprintf(char *buf, const char *fmt, va_list args)
830{
831 return vsnprintf_internal(buf, INT_MAX, fmt, args);
832}
833
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000834int sprintf(char *buf, const char *fmt, ...)
wdenk153d5112002-08-30 11:07:04 +0000835{
836 va_list args;
837 int i;
838
839 va_start(args, fmt);
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000840 i = vsprintf(buf, fmt, args);
wdenk153d5112002-08-30 11:07:04 +0000841 va_end(args);
842 return i;
843}
844
Simon Glass66312372015-02-27 22:06:32 -0700845static void panic_finish(void) __attribute__ ((noreturn));
846
847static void panic_finish(void)
wdenk153d5112002-08-30 11:07:04 +0000848{
wdenk153d5112002-08-30 11:07:04 +0000849 putc('\n');
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000850#if defined(CONFIG_PANIC_HANG)
wdenk153d5112002-08-30 11:07:04 +0000851 hang();
852#else
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000853 udelay(100000); /* allow messages to go out */
854 do_reset(NULL, 0, 0, NULL);
wdenk153d5112002-08-30 11:07:04 +0000855#endif
Heiko Schocher40e01882011-07-26 20:55:57 +0000856 while (1)
857 ;
wdenk153d5112002-08-30 11:07:04 +0000858}
Simon Glass21726a72011-06-29 09:49:34 +0000859
Simon Glass66312372015-02-27 22:06:32 -0700860void panic_str(const char *str)
861{
862 puts(str);
863 panic_finish();
864}
865
866void panic(const char *fmt, ...)
867{
868 va_list args;
869 va_start(args, fmt);
870 vprintf(fmt, args);
871 va_end(args);
872 panic_finish();
873}
874
Simon Glass21726a72011-06-29 09:49:34 +0000875void __assert_fail(const char *assertion, const char *file, unsigned line,
876 const char *function)
877{
878 /* This will not return */
879 panic("%s:%u: %s: Assertion `%s' failed.", file, line, function,
880 assertion);
881}
Simon Glass3cce8a52011-10-21 18:51:33 +0000882
883char *simple_itoa(ulong i)
884{
885 /* 21 digits plus null terminator, good for 64-bit or smaller ints */
886 static char local[22];
887 char *p = &local[21];
888
889 *p-- = '\0';
890 do {
891 *p-- = '0' + i % 10;
892 i /= 10;
893 } while (i > 0);
894 return p + 1;
895}
Simon Glassb8bcaa32013-06-11 11:14:38 -0700896
897/* We don't seem to have %'d in U-Boot */
898void print_grouped_ull(unsigned long long int_val, int digits)
899{
900 char str[21], *s;
901 int grab = 3;
902
903 digits = (digits + 2) / 3;
904 sprintf(str, "%*llu", digits * 3, int_val);
905 for (s = str; *s; s += grab) {
906 if (s != str)
907 putc(s[-1] != ' ' ? ',' : ' ');
908 printf("%.*s", grab, s);
909 grab = 3;
910 }
911}
Heiko Schocher09c32802015-04-27 07:42:05 +0200912
913bool str2off(const char *p, loff_t *num)
914{
915 char *endptr;
916
917 *num = simple_strtoull(p, &endptr, 16);
918 return *p != '\0' && *endptr == '\0';
919}
920
921bool str2long(const char *p, ulong *num)
922{
923 char *endptr;
924
925 *num = simple_strtoul(p, &endptr, 16);
926 return *p != '\0' && *endptr == '\0';
927}