1 /* 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 :-) 10 * 11 * from hush: simple_itoa() was lifted from boa-0.93.15 12 */ 13 14 #include <common.h> 15 #include <charset.h> 16 #include <efi_loader.h> 17 #include <div64.h> 18 #include <uuid.h> 19 #include <stdarg.h> 20 #include <linux/ctype.h> 21 #include <linux/err.h> 22 #include <linux/types.h> 23 #include <linux/string.h> 24 25 #define noinline __attribute__((noinline)) 26 27 /* we use this so that we can do without the ctype library */ 28 #define is_digit(c) ((c) >= '0' && (c) <= '9') 29 30 static int skip_atoi(const char **s) 31 { 32 int i = 0; 33 34 while (is_digit(**s)) 35 i = i * 10 + *((*s)++) - '0'; 36 37 return i; 38 } 39 40 /* Decimal conversion is by far the most typical, and is used 41 * for /proc and /sys data. This directly impacts e.g. top performance 42 * with many processes running. We optimize it for speed 43 * using code from 44 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html 45 * (with permission from the author, Douglas W. Jones). */ 46 47 /* Formats correctly any integer in [0,99999]. 48 * Outputs from one to five digits depending on input. 49 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */ 50 static char *put_dec_trunc(char *buf, unsigned q) 51 { 52 unsigned d3, d2, d1, d0; 53 d1 = (q>>4) & 0xf; 54 d2 = (q>>8) & 0xf; 55 d3 = (q>>12); 56 57 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 58 q = (d0 * 0xcd) >> 11; 59 d0 = d0 - 10*q; 60 *buf++ = d0 + '0'; /* least significant digit */ 61 d1 = q + 9*d3 + 5*d2 + d1; 62 if (d1 != 0) { 63 q = (d1 * 0xcd) >> 11; 64 d1 = d1 - 10*q; 65 *buf++ = d1 + '0'; /* next digit */ 66 67 d2 = q + 2*d2; 68 if ((d2 != 0) || (d3 != 0)) { 69 q = (d2 * 0xd) >> 7; 70 d2 = d2 - 10*q; 71 *buf++ = d2 + '0'; /* next digit */ 72 73 d3 = q + 4*d3; 74 if (d3 != 0) { 75 q = (d3 * 0xcd) >> 11; 76 d3 = d3 - 10*q; 77 *buf++ = d3 + '0'; /* next digit */ 78 if (q != 0) 79 *buf++ = q + '0'; /* most sign. digit */ 80 } 81 } 82 } 83 return buf; 84 } 85 /* Same with if's removed. Always emits five digits */ 86 static char *put_dec_full(char *buf, unsigned q) 87 { 88 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */ 89 /* but anyway, gcc produces better code with full-sized ints */ 90 unsigned d3, d2, d1, d0; 91 d1 = (q>>4) & 0xf; 92 d2 = (q>>8) & 0xf; 93 d3 = (q>>12); 94 95 /* 96 * Possible ways to approx. divide by 10 97 * gcc -O2 replaces multiply with shifts and adds 98 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386) 99 * (x * 0x67) >> 10: 1100111 100 * (x * 0x34) >> 9: 110100 - same 101 * (x * 0x1a) >> 8: 11010 - same 102 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386) 103 */ 104 105 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 106 q = (d0 * 0xcd) >> 11; 107 d0 = d0 - 10*q; 108 *buf++ = d0 + '0'; 109 d1 = q + 9*d3 + 5*d2 + d1; 110 q = (d1 * 0xcd) >> 11; 111 d1 = d1 - 10*q; 112 *buf++ = d1 + '0'; 113 114 d2 = q + 2*d2; 115 q = (d2 * 0xd) >> 7; 116 d2 = d2 - 10*q; 117 *buf++ = d2 + '0'; 118 119 d3 = q + 4*d3; 120 q = (d3 * 0xcd) >> 11; /* - shorter code */ 121 /* q = (d3 * 0x67) >> 10; - would also work */ 122 d3 = d3 - 10*q; 123 *buf++ = d3 + '0'; 124 *buf++ = q + '0'; 125 return buf; 126 } 127 /* No inlining helps gcc to use registers better */ 128 static noinline char *put_dec(char *buf, uint64_t num) 129 { 130 while (1) { 131 unsigned rem; 132 if (num < 100000) 133 return put_dec_trunc(buf, num); 134 rem = do_div(num, 100000); 135 buf = put_dec_full(buf, rem); 136 } 137 } 138 139 #define ZEROPAD 1 /* pad with zero */ 140 #define SIGN 2 /* unsigned/signed long */ 141 #define PLUS 4 /* show plus */ 142 #define SPACE 8 /* space if plus */ 143 #define LEFT 16 /* left justified */ 144 #define SMALL 32 /* Must be 32 == 0x20 */ 145 #define SPECIAL 64 /* 0x */ 146 147 /* 148 * Macro to add a new character to our output string, but only if it will 149 * fit. The macro moves to the next character position in the output string. 150 */ 151 #define ADDCH(str, ch) do { \ 152 if ((str) < end) \ 153 *(str) = (ch); \ 154 ++str; \ 155 } while (0) 156 157 static char *number(char *buf, char *end, u64 num, 158 int base, int size, int precision, int type) 159 { 160 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ 161 static const char digits[16] = "0123456789ABCDEF"; 162 163 char tmp[66]; 164 char sign; 165 char locase; 166 int need_pfx = ((type & SPECIAL) && base != 10); 167 int i; 168 169 /* locase = 0 or 0x20. ORing digits or letters with 'locase' 170 * produces same digits or (maybe lowercased) letters */ 171 locase = (type & SMALL); 172 if (type & LEFT) 173 type &= ~ZEROPAD; 174 sign = 0; 175 if (type & SIGN) { 176 if ((s64) num < 0) { 177 sign = '-'; 178 num = -(s64) num; 179 size--; 180 } else if (type & PLUS) { 181 sign = '+'; 182 size--; 183 } else if (type & SPACE) { 184 sign = ' '; 185 size--; 186 } 187 } 188 if (need_pfx) { 189 size--; 190 if (base == 16) 191 size--; 192 } 193 194 /* generate full string in tmp[], in reverse order */ 195 i = 0; 196 if (num == 0) 197 tmp[i++] = '0'; 198 /* Generic code, for any base: 199 else do { 200 tmp[i++] = (digits[do_div(num,base)] | locase); 201 } while (num != 0); 202 */ 203 else if (base != 10) { /* 8 or 16 */ 204 int mask = base - 1; 205 int shift = 3; 206 207 if (base == 16) 208 shift = 4; 209 210 do { 211 tmp[i++] = (digits[((unsigned char)num) & mask] 212 | locase); 213 num >>= shift; 214 } while (num); 215 } else { /* base 10 */ 216 i = put_dec(tmp, num) - tmp; 217 } 218 219 /* printing 100 using %2d gives "100", not "00" */ 220 if (i > precision) 221 precision = i; 222 /* leading space padding */ 223 size -= precision; 224 if (!(type & (ZEROPAD + LEFT))) { 225 while (--size >= 0) 226 ADDCH(buf, ' '); 227 } 228 /* sign */ 229 if (sign) 230 ADDCH(buf, sign); 231 /* "0x" / "0" prefix */ 232 if (need_pfx) { 233 ADDCH(buf, '0'); 234 if (base == 16) 235 ADDCH(buf, 'X' | locase); 236 } 237 /* zero or space padding */ 238 if (!(type & LEFT)) { 239 char c = (type & ZEROPAD) ? '0' : ' '; 240 241 while (--size >= 0) 242 ADDCH(buf, c); 243 } 244 /* hmm even more zero padding? */ 245 while (i <= --precision) 246 ADDCH(buf, '0'); 247 /* actual digits of result */ 248 while (--i >= 0) 249 ADDCH(buf, tmp[i]); 250 /* trailing space padding */ 251 while (--size >= 0) 252 ADDCH(buf, ' '); 253 return buf; 254 } 255 256 static char *string(char *buf, char *end, char *s, int field_width, 257 int precision, int flags) 258 { 259 int len, i; 260 261 if (s == NULL) 262 s = "<NULL>"; 263 264 len = strnlen(s, precision); 265 266 if (!(flags & LEFT)) 267 while (len < field_width--) 268 ADDCH(buf, ' '); 269 for (i = 0; i < len; ++i) 270 ADDCH(buf, *s++); 271 while (len < field_width--) 272 ADDCH(buf, ' '); 273 return buf; 274 } 275 276 static char *string16(char *buf, char *end, u16 *s, int field_width, 277 int precision, int flags) 278 { 279 u16 *str = s ? s : L"<NULL>"; 280 int utf16_len = utf16_strnlen(str, precision); 281 u8 utf8[utf16_len * MAX_UTF8_PER_UTF16]; 282 int utf8_len, i; 283 284 utf8_len = utf16_to_utf8(utf8, str, utf16_len) - utf8; 285 286 if (!(flags & LEFT)) 287 while (utf8_len < field_width--) 288 ADDCH(buf, ' '); 289 for (i = 0; i < utf8_len; ++i) 290 ADDCH(buf, utf8[i]); 291 while (utf8_len < field_width--) 292 ADDCH(buf, ' '); 293 return buf; 294 } 295 296 #if defined(CONFIG_EFI_LOADER) && \ 297 !defined(CONFIG_SPL_BUILD) && !defined(API_BUILD) 298 static char *device_path_string(char *buf, char *end, void *dp, int field_width, 299 int precision, int flags) 300 { 301 u16 *str; 302 303 /* If dp == NULL output the string '<NULL>' */ 304 if (!dp) 305 return string16(buf, end, dp, field_width, precision, flags); 306 307 str = efi_dp_str((struct efi_device_path *)dp); 308 if (!str) 309 return ERR_PTR(-ENOMEM); 310 311 buf = string16(buf, end, str, field_width, precision, flags); 312 efi_free_pool(str); 313 return buf; 314 } 315 #endif 316 317 #ifdef CONFIG_CMD_NET 318 static const char hex_asc[] = "0123456789abcdef"; 319 #define hex_asc_lo(x) hex_asc[((x) & 0x0f)] 320 #define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4] 321 322 static inline char *pack_hex_byte(char *buf, u8 byte) 323 { 324 *buf++ = hex_asc_hi(byte); 325 *buf++ = hex_asc_lo(byte); 326 return buf; 327 } 328 329 static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, 330 int precision, int flags) 331 { 332 /* (6 * 2 hex digits), 5 colons and trailing zero */ 333 char mac_addr[6 * 3]; 334 char *p = mac_addr; 335 int i; 336 337 for (i = 0; i < 6; i++) { 338 p = pack_hex_byte(p, addr[i]); 339 if (!(flags & SPECIAL) && i != 5) 340 *p++ = ':'; 341 } 342 *p = '\0'; 343 344 return string(buf, end, mac_addr, field_width, precision, 345 flags & ~SPECIAL); 346 } 347 348 static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, 349 int precision, int flags) 350 { 351 /* (8 * 4 hex digits), 7 colons and trailing zero */ 352 char ip6_addr[8 * 5]; 353 char *p = ip6_addr; 354 int i; 355 356 for (i = 0; i < 8; i++) { 357 p = pack_hex_byte(p, addr[2 * i]); 358 p = pack_hex_byte(p, addr[2 * i + 1]); 359 if (!(flags & SPECIAL) && i != 7) 360 *p++ = ':'; 361 } 362 *p = '\0'; 363 364 return string(buf, end, ip6_addr, field_width, precision, 365 flags & ~SPECIAL); 366 } 367 368 static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, 369 int precision, int flags) 370 { 371 /* (4 * 3 decimal digits), 3 dots and trailing zero */ 372 char ip4_addr[4 * 4]; 373 char temp[3]; /* hold each IP quad in reverse order */ 374 char *p = ip4_addr; 375 int i, digits; 376 377 for (i = 0; i < 4; i++) { 378 digits = put_dec_trunc(temp, addr[i]) - temp; 379 /* reverse the digits in the quad */ 380 while (digits--) 381 *p++ = temp[digits]; 382 if (i != 3) 383 *p++ = '.'; 384 } 385 *p = '\0'; 386 387 return string(buf, end, ip4_addr, field_width, precision, 388 flags & ~SPECIAL); 389 } 390 #endif 391 392 #ifdef CONFIG_LIB_UUID 393 /* 394 * This works (roughly) the same way as linux's, but we currently always 395 * print lower-case (ie. we just keep %pUB and %pUL for compat with linux), 396 * mostly just because that is what uuid_bin_to_str() supports. 397 * 398 * %pUb: 01020304-0506-0708-090a-0b0c0d0e0f10 399 * %pUl: 04030201-0605-0807-090a-0b0c0d0e0f10 400 */ 401 static char *uuid_string(char *buf, char *end, u8 *addr, int field_width, 402 int precision, int flags, const char *fmt) 403 { 404 char uuid[UUID_STR_LEN + 1]; 405 int str_format = UUID_STR_FORMAT_STD; 406 407 switch (*(++fmt)) { 408 case 'L': 409 case 'l': 410 str_format = UUID_STR_FORMAT_GUID; 411 break; 412 case 'B': 413 case 'b': 414 /* this is the default */ 415 break; 416 default: 417 break; 418 } 419 420 uuid_bin_to_str(addr, uuid, str_format); 421 422 return string(buf, end, uuid, field_width, precision, flags); 423 } 424 #endif 425 426 /* 427 * Show a '%p' thing. A kernel extension is that the '%p' is followed 428 * by an extra set of alphanumeric characters that are extended format 429 * specifiers. 430 * 431 * Right now we handle: 432 * 433 * - 'M' For a 6-byte MAC address, it prints the address in the 434 * usual colon-separated hex notation 435 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated 436 * decimal for v4 and colon separated network-order 16 bit hex for v6) 437 * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is 438 * currently the same 439 * 440 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 441 * function pointers are really function descriptors, which contain a 442 * pointer to the real address. 443 */ 444 static char *pointer(const char *fmt, char *buf, char *end, void *ptr, 445 int field_width, int precision, int flags) 446 { 447 u64 num = (uintptr_t)ptr; 448 449 /* 450 * Being a boot loader, we explicitly allow pointers to 451 * (physical) address null. 452 */ 453 #if 0 454 if (!ptr) 455 return string(buf, end, "(null)", field_width, precision, 456 flags); 457 #endif 458 459 switch (*fmt) { 460 #if defined(CONFIG_EFI_LOADER) && \ 461 !defined(CONFIG_SPL_BUILD) && !defined(API_BUILD) 462 case 'D': 463 return device_path_string(buf, end, ptr, field_width, 464 precision, flags); 465 #endif 466 #ifdef CONFIG_CMD_NET 467 case 'a': 468 flags |= SPECIAL | ZEROPAD; 469 470 switch (fmt[1]) { 471 case 'p': 472 default: 473 field_width = sizeof(phys_addr_t) * 2 + 2; 474 num = *(phys_addr_t *)ptr; 475 break; 476 } 477 break; 478 case 'm': 479 flags |= SPECIAL; 480 /* Fallthrough */ 481 case 'M': 482 return mac_address_string(buf, end, ptr, field_width, 483 precision, flags); 484 case 'i': 485 flags |= SPECIAL; 486 /* Fallthrough */ 487 case 'I': 488 if (fmt[1] == '6') 489 return ip6_addr_string(buf, end, ptr, field_width, 490 precision, flags); 491 if (fmt[1] == '4') 492 return ip4_addr_string(buf, end, ptr, field_width, 493 precision, flags); 494 flags &= ~SPECIAL; 495 break; 496 #endif 497 #ifdef CONFIG_LIB_UUID 498 case 'U': 499 return uuid_string(buf, end, ptr, field_width, precision, 500 flags, fmt); 501 #endif 502 default: 503 break; 504 } 505 flags |= SMALL; 506 if (field_width == -1) { 507 field_width = 2*sizeof(void *); 508 flags |= ZEROPAD; 509 } 510 return number(buf, end, num, 16, field_width, precision, flags); 511 } 512 513 static int vsnprintf_internal(char *buf, size_t size, const char *fmt, 514 va_list args) 515 { 516 u64 num; 517 int base; 518 char *str; 519 520 int flags; /* flags to number() */ 521 522 int field_width; /* width of output field */ 523 int precision; /* min. # of digits for integers; max 524 number of chars for from string */ 525 int qualifier; /* 'h', 'l', or 'L' for integer fields */ 526 /* 'z' support added 23/7/1999 S.H. */ 527 /* 'z' changed to 'Z' --davidm 1/25/99 */ 528 /* 't' added for ptrdiff_t */ 529 char *end = buf + size; 530 531 /* Make sure end is always >= buf - do we want this in U-Boot? */ 532 if (end < buf) { 533 end = ((void *)-1); 534 size = end - buf; 535 } 536 str = buf; 537 538 for (; *fmt ; ++fmt) { 539 if (*fmt != '%') { 540 ADDCH(str, *fmt); 541 continue; 542 } 543 544 /* process flags */ 545 flags = 0; 546 repeat: 547 ++fmt; /* this also skips first '%' */ 548 switch (*fmt) { 549 case '-': 550 flags |= LEFT; 551 goto repeat; 552 case '+': 553 flags |= PLUS; 554 goto repeat; 555 case ' ': 556 flags |= SPACE; 557 goto repeat; 558 case '#': 559 flags |= SPECIAL; 560 goto repeat; 561 case '0': 562 flags |= ZEROPAD; 563 goto repeat; 564 } 565 566 /* get field width */ 567 field_width = -1; 568 if (is_digit(*fmt)) 569 field_width = skip_atoi(&fmt); 570 else if (*fmt == '*') { 571 ++fmt; 572 /* it's the next argument */ 573 field_width = va_arg(args, int); 574 if (field_width < 0) { 575 field_width = -field_width; 576 flags |= LEFT; 577 } 578 } 579 580 /* get the precision */ 581 precision = -1; 582 if (*fmt == '.') { 583 ++fmt; 584 if (is_digit(*fmt)) 585 precision = skip_atoi(&fmt); 586 else if (*fmt == '*') { 587 ++fmt; 588 /* it's the next argument */ 589 precision = va_arg(args, int); 590 } 591 if (precision < 0) 592 precision = 0; 593 } 594 595 /* get the conversion qualifier */ 596 qualifier = -1; 597 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || 598 *fmt == 'Z' || *fmt == 'z' || *fmt == 't') { 599 qualifier = *fmt; 600 ++fmt; 601 if (qualifier == 'l' && *fmt == 'l') { 602 qualifier = 'L'; 603 ++fmt; 604 } 605 } 606 607 /* default base */ 608 base = 10; 609 610 switch (*fmt) { 611 case 'c': 612 if (!(flags & LEFT)) { 613 while (--field_width > 0) 614 ADDCH(str, ' '); 615 } 616 ADDCH(str, (unsigned char) va_arg(args, int)); 617 while (--field_width > 0) 618 ADDCH(str, ' '); 619 continue; 620 621 case 's': 622 if (qualifier == 'l' && !IS_ENABLED(CONFIG_SPL_BUILD)) { 623 str = string16(str, end, va_arg(args, u16 *), 624 field_width, precision, flags); 625 } else { 626 str = string(str, end, va_arg(args, char *), 627 field_width, precision, flags); 628 } 629 continue; 630 631 case 'p': 632 str = pointer(fmt + 1, str, end, 633 va_arg(args, void *), 634 field_width, precision, flags); 635 if (IS_ERR(str)) 636 return PTR_ERR(str); 637 /* Skip all alphanumeric pointer suffixes */ 638 while (isalnum(fmt[1])) 639 fmt++; 640 continue; 641 642 case 'n': 643 if (qualifier == 'l') { 644 long *ip = va_arg(args, long *); 645 *ip = (str - buf); 646 } else { 647 int *ip = va_arg(args, int *); 648 *ip = (str - buf); 649 } 650 continue; 651 652 case '%': 653 ADDCH(str, '%'); 654 continue; 655 656 /* integer number formats - set up the flags and "break" */ 657 case 'o': 658 base = 8; 659 break; 660 661 case 'x': 662 flags |= SMALL; 663 case 'X': 664 base = 16; 665 break; 666 667 case 'd': 668 case 'i': 669 flags |= SIGN; 670 case 'u': 671 break; 672 673 default: 674 ADDCH(str, '%'); 675 if (*fmt) 676 ADDCH(str, *fmt); 677 else 678 --fmt; 679 continue; 680 } 681 if (qualifier == 'L') /* "quad" for 64 bit variables */ 682 num = va_arg(args, unsigned long long); 683 else if (qualifier == 'l') { 684 num = va_arg(args, unsigned long); 685 if (flags & SIGN) 686 num = (signed long) num; 687 } else if (qualifier == 'Z' || qualifier == 'z') { 688 num = va_arg(args, size_t); 689 } else if (qualifier == 't') { 690 num = va_arg(args, ptrdiff_t); 691 } else if (qualifier == 'h') { 692 num = (unsigned short) va_arg(args, int); 693 if (flags & SIGN) 694 num = (signed short) num; 695 } else { 696 num = va_arg(args, unsigned int); 697 if (flags & SIGN) 698 num = (signed int) num; 699 } 700 str = number(str, end, num, base, field_width, precision, 701 flags); 702 } 703 704 if (size > 0) { 705 ADDCH(str, '\0'); 706 if (str > end) 707 end[-1] = '\0'; 708 --str; 709 } 710 /* the trailing null byte doesn't count towards the total */ 711 return str - buf; 712 } 713 714 int vsnprintf(char *buf, size_t size, const char *fmt, 715 va_list args) 716 { 717 return vsnprintf_internal(buf, size, fmt, args); 718 } 719 720 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 721 { 722 int i; 723 724 i = vsnprintf(buf, size, fmt, args); 725 726 if (likely(i < size)) 727 return i; 728 if (size != 0) 729 return size - 1; 730 return 0; 731 } 732 733 int snprintf(char *buf, size_t size, const char *fmt, ...) 734 { 735 va_list args; 736 int i; 737 738 va_start(args, fmt); 739 i = vsnprintf(buf, size, fmt, args); 740 va_end(args); 741 742 return i; 743 } 744 745 int scnprintf(char *buf, size_t size, const char *fmt, ...) 746 { 747 va_list args; 748 int i; 749 750 va_start(args, fmt); 751 i = vscnprintf(buf, size, fmt, args); 752 va_end(args); 753 754 return i; 755 } 756 757 /** 758 * Format a string and place it in a buffer (va_list version) 759 * 760 * @param buf The buffer to place the result into 761 * @param fmt The format string to use 762 * @param args Arguments for the format string 763 * 764 * The function returns the number of characters written 765 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 766 * buffer overflows. 767 * 768 * If you're not already dealing with a va_list consider using sprintf(). 769 */ 770 int vsprintf(char *buf, const char *fmt, va_list args) 771 { 772 return vsnprintf_internal(buf, INT_MAX, fmt, args); 773 } 774 775 int sprintf(char *buf, const char *fmt, ...) 776 { 777 va_list args; 778 int i; 779 780 va_start(args, fmt); 781 i = vsprintf(buf, fmt, args); 782 va_end(args); 783 return i; 784 } 785 786 int printf(const char *fmt, ...) 787 { 788 va_list args; 789 uint i; 790 char printbuffer[CONFIG_SYS_PBSIZE]; 791 792 va_start(args, fmt); 793 794 /* 795 * For this to work, printbuffer must be larger than 796 * anything we ever want to print. 797 */ 798 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 799 va_end(args); 800 801 /* Handle error */ 802 if (i <= 0) 803 return i; 804 /* Print the string */ 805 puts(printbuffer); 806 return i; 807 } 808 809 int vprintf(const char *fmt, va_list args) 810 { 811 uint i; 812 char printbuffer[CONFIG_SYS_PBSIZE]; 813 814 /* 815 * For this to work, printbuffer must be larger than 816 * anything we ever want to print. 817 */ 818 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); 819 820 /* Handle error */ 821 if (i <= 0) 822 return i; 823 /* Print the string */ 824 puts(printbuffer); 825 return i; 826 } 827 828 829 void __assert_fail(const char *assertion, const char *file, unsigned line, 830 const char *function) 831 { 832 /* This will not return */ 833 panic("%s:%u: %s: Assertion `%s' failed.", file, line, function, 834 assertion); 835 } 836 837 char *simple_itoa(ulong i) 838 { 839 /* 21 digits plus null terminator, good for 64-bit or smaller ints */ 840 static char local[22]; 841 char *p = &local[21]; 842 843 *p-- = '\0'; 844 do { 845 *p-- = '0' + i % 10; 846 i /= 10; 847 } while (i > 0); 848 return p + 1; 849 } 850 851 /* We don't seem to have %'d in U-Boot */ 852 void print_grouped_ull(unsigned long long int_val, int digits) 853 { 854 char str[21], *s; 855 int grab = 3; 856 857 digits = (digits + 2) / 3; 858 sprintf(str, "%*llu", digits * 3, int_val); 859 for (s = str; *s; s += grab) { 860 if (s != str) 861 putc(s[-1] != ' ' ? ',' : ' '); 862 printf("%.*s", grab, s); 863 grab = 3; 864 } 865 } 866 867 bool str2off(const char *p, loff_t *num) 868 { 869 char *endptr; 870 871 *num = simple_strtoull(p, &endptr, 16); 872 return *p != '\0' && *endptr == '\0'; 873 } 874 875 bool str2long(const char *p, ulong *num) 876 { 877 char *endptr; 878 879 *num = simple_strtoul(p, &endptr, 16); 880 return *p != '\0' && *endptr == '\0'; 881 } 882