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