mirror of
https://source.denx.de/u-boot/u-boot.git
synced 2025-12-18 16:01:32 +01:00
1e24e84db4
The formatting with %pa / %pap behaves like %x, which results in an incorrect value being output. To improve this, a new fine-tuning Kconfig SPL_USE_TINY_PRINTF_POINTER_SUPPORT for pointer formatting has been added. If it is enabled, the output of %pa / %pap should be correct, and if it is disabled, the pointer formatting is completely unsupported. In addition to indicate unsupported formatting, '?' will be output. This allows enabling pointer formatting only when needed. For SPL_NET it is selected by default. Then it also supports the formatting with %pm, %pM and %pI4. In summery this level of %p support for tiny printf is possible now: 1) The standard tiny printf won't have support for pointer formatting. So it doesn't print misleading values for %pa, instead '?' will be output: %p => ? %pa => ?a %pap => ?ap 2) If SPL_USE_TINY_PRINTF_POINTER_SUPPORT is enabled or DEBUG is defined tiny printf supports formatting %p and %pa / %pap. 3) If SPL_NET is enabled the support of pointers is extended for %pm, %pM and %pI4. Signed-off-by: Christoph Niedermaier <cniedermaier@dh-electronics.com>
422 lines
8.0 KiB
C
422 lines
8.0 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Tiny printf version for SPL
|
|
*
|
|
* Copied from:
|
|
* http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
|
|
*
|
|
* Copyright (C) 2004,2008 Kustaa Nyholm
|
|
*/
|
|
|
|
#include <log.h>
|
|
#include <serial.h>
|
|
#include <stdarg.h>
|
|
#include <linux/ctype.h>
|
|
|
|
struct printf_info {
|
|
char *bf; /* Digit buffer */
|
|
char zs; /* non-zero if a digit has been written */
|
|
char *outstr; /* Next output position for sprintf() */
|
|
|
|
/* Output a character */
|
|
void (*putc)(struct printf_info *info, char ch);
|
|
};
|
|
|
|
static void out(struct printf_info *info, char c)
|
|
{
|
|
*info->bf++ = c;
|
|
}
|
|
|
|
static void out_dgt(struct printf_info *info, char dgt)
|
|
{
|
|
out(info, dgt + (dgt < 10 ? '0' : 'a' - 10));
|
|
info->zs = 1;
|
|
}
|
|
|
|
static void div_out(struct printf_info *info, unsigned long *num,
|
|
unsigned long div)
|
|
{
|
|
unsigned char dgt = 0;
|
|
|
|
while (*num >= div) {
|
|
*num -= div;
|
|
dgt++;
|
|
}
|
|
|
|
if (info->zs || dgt > 0)
|
|
out_dgt(info, dgt);
|
|
}
|
|
|
|
#ifdef CONFIG_SPL_NET
|
|
static void string(struct printf_info *info, char *s)
|
|
{
|
|
char ch;
|
|
|
|
while ((ch = *s++))
|
|
out(info, ch);
|
|
}
|
|
|
|
static const char hex_asc[] = "0123456789abcdef";
|
|
#define hex_asc_lo(x) hex_asc[((x) & 0x0f)]
|
|
#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4]
|
|
|
|
static inline char *pack_hex_byte(char *buf, u8 byte)
|
|
{
|
|
*buf++ = hex_asc_hi(byte);
|
|
*buf++ = hex_asc_lo(byte);
|
|
return buf;
|
|
}
|
|
|
|
static void mac_address_string(struct printf_info *info, u8 *addr,
|
|
bool separator)
|
|
{
|
|
/* (6 * 2 hex digits), 5 colons and trailing zero */
|
|
char mac_addr[6 * 3];
|
|
char *p = mac_addr;
|
|
int i;
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
p = pack_hex_byte(p, addr[i]);
|
|
if (separator && i != 5)
|
|
*p++ = ':';
|
|
}
|
|
*p = '\0';
|
|
|
|
string(info, mac_addr);
|
|
}
|
|
|
|
static char *put_dec_trunc(char *buf, unsigned int q)
|
|
{
|
|
unsigned int d3, d2, d1, d0;
|
|
d1 = (q >> 4) & 0xf;
|
|
d2 = (q >> 8) & 0xf;
|
|
d3 = (q >> 12);
|
|
|
|
d0 = 6 * (d3 + d2 + d1) + (q & 0xf);
|
|
q = (d0 * 0xcd) >> 11;
|
|
d0 = d0 - 10 * q;
|
|
*buf++ = d0 + '0'; /* least significant digit */
|
|
d1 = q + 9 * d3 + 5 * d2 + d1;
|
|
if (d1 != 0) {
|
|
q = (d1 * 0xcd) >> 11;
|
|
d1 = d1 - 10 * q;
|
|
*buf++ = d1 + '0'; /* next digit */
|
|
|
|
d2 = q + 2 * d2;
|
|
if ((d2 != 0) || (d3 != 0)) {
|
|
q = (d2 * 0xd) >> 7;
|
|
d2 = d2 - 10 * q;
|
|
*buf++ = d2 + '0'; /* next digit */
|
|
|
|
d3 = q + 4 * d3;
|
|
if (d3 != 0) {
|
|
q = (d3 * 0xcd) >> 11;
|
|
d3 = d3 - 10 * q;
|
|
*buf++ = d3 + '0'; /* next digit */
|
|
if (q != 0)
|
|
*buf++ = q + '0'; /* most sign. digit */
|
|
}
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static void ip4_addr_string(struct printf_info *info, u8 *addr)
|
|
{
|
|
/* (4 * 3 decimal digits), 3 dots and trailing zero */
|
|
char ip4_addr[4 * 4];
|
|
char temp[3]; /* hold each IP quad in reverse order */
|
|
char *p = ip4_addr;
|
|
int i, digits;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
digits = put_dec_trunc(temp, addr[i]) - temp;
|
|
/* reverse the digits in the quad */
|
|
while (digits--)
|
|
*p++ = temp[digits];
|
|
if (i != 3)
|
|
*p++ = '.';
|
|
}
|
|
*p = '\0';
|
|
|
|
string(info, ip4_addr);
|
|
}
|
|
#endif /* CONFIG_SPL_NET */
|
|
|
|
/*
|
|
* Show a '%p' thing. A kernel extension is that the '%p' is followed
|
|
* by an extra set of characters that are extended format
|
|
* specifiers.
|
|
*
|
|
* Right now we handle:
|
|
*
|
|
* - 'M' For a 6-byte MAC address, it prints the address in the
|
|
* usual colon-separated hex notation.
|
|
* - 'm' Same as above except there is no colon-separator.
|
|
* - 'I4'for IPv4 addresses printed in the usual way (dot-separated
|
|
* decimal).
|
|
*/
|
|
|
|
#if defined(CONFIG_SPL_USE_TINY_PRINTF_POINTER_SUPPORT) || defined(DEBUG)
|
|
static void pointer(struct printf_info *info, const char *fmt, void *ptr)
|
|
{
|
|
unsigned long num = (uintptr_t)ptr;
|
|
unsigned long div;
|
|
|
|
switch (*fmt) {
|
|
case 'a':
|
|
switch (fmt[1]) {
|
|
case 'p':
|
|
default:
|
|
num = *(phys_addr_t *)ptr;
|
|
break;
|
|
}
|
|
break;
|
|
#ifdef CONFIG_SPL_NET
|
|
case 'm':
|
|
return mac_address_string(info, ptr, false);
|
|
case 'M':
|
|
return mac_address_string(info, ptr, true);
|
|
case 'I':
|
|
if (fmt[1] == '4')
|
|
return ip4_addr_string(info, ptr);
|
|
#else
|
|
case 'm':
|
|
case 'M':
|
|
case 'I':
|
|
out(info, '?');
|
|
return;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
div = 1UL << (sizeof(long) * 8 - 4);
|
|
for (; div; div /= 0x10)
|
|
div_out(info, &num, div);
|
|
}
|
|
#endif
|
|
|
|
static int _vprintf(struct printf_info *info, const char *fmt, va_list va)
|
|
{
|
|
char ch;
|
|
char *p;
|
|
unsigned long num;
|
|
char buf[12];
|
|
unsigned long div;
|
|
|
|
while ((ch = *(fmt++))) {
|
|
if (ch != '%') {
|
|
info->putc(info, ch);
|
|
} else {
|
|
bool lz = false;
|
|
int width = 0;
|
|
bool islong = false;
|
|
bool force_char = false;
|
|
|
|
ch = *(fmt++);
|
|
if (ch == '-')
|
|
ch = *(fmt++);
|
|
|
|
if (ch == '0') {
|
|
ch = *(fmt++);
|
|
lz = 1;
|
|
}
|
|
|
|
if (ch >= '0' && ch <= '9') {
|
|
width = 0;
|
|
while (ch >= '0' && ch <= '9') {
|
|
width = (width * 10) + ch - '0';
|
|
ch = *fmt++;
|
|
}
|
|
}
|
|
if (ch == 'l') {
|
|
ch = *(fmt++);
|
|
islong = true;
|
|
}
|
|
|
|
info->bf = buf;
|
|
p = info->bf;
|
|
info->zs = 0;
|
|
|
|
switch (ch) {
|
|
case '\0':
|
|
goto abort;
|
|
case 'u':
|
|
case 'd':
|
|
case 'i':
|
|
div = 1000000000;
|
|
if (islong) {
|
|
num = va_arg(va, unsigned long);
|
|
if (sizeof(long) > 4)
|
|
div *= div * 10;
|
|
} else {
|
|
num = va_arg(va, unsigned int);
|
|
}
|
|
|
|
if (ch != 'u') {
|
|
if (islong && (long)num < 0) {
|
|
num = -(long)num;
|
|
out(info, '-');
|
|
} else if (!islong && (int)num < 0) {
|
|
num = -(int)num;
|
|
out(info, '-');
|
|
}
|
|
}
|
|
if (!num) {
|
|
out_dgt(info, 0);
|
|
} else {
|
|
for (; div; div /= 10)
|
|
div_out(info, &num, div);
|
|
}
|
|
break;
|
|
#if defined(CONFIG_SPL_USE_TINY_PRINTF_POINTER_SUPPORT) || defined(DEBUG)
|
|
case 'p':
|
|
pointer(info, fmt, va_arg(va, void *));
|
|
/*
|
|
* Skip this because it pulls in _ctype which is
|
|
* 256 bytes, and we don't generally implement
|
|
* pointer anyway
|
|
*/
|
|
while (isalnum(fmt[0]))
|
|
fmt++;
|
|
break;
|
|
#endif
|
|
case 'x':
|
|
case 'X':
|
|
if (islong) {
|
|
num = va_arg(va, unsigned long);
|
|
div = 1UL << (sizeof(long) * 8 - 4);
|
|
} else {
|
|
num = va_arg(va, unsigned int);
|
|
div = 0x10000000;
|
|
}
|
|
if (!num) {
|
|
out_dgt(info, 0);
|
|
} else {
|
|
for (; div; div /= 0x10)
|
|
div_out(info, &num, div);
|
|
}
|
|
break;
|
|
case 'c':
|
|
out(info, (char)(va_arg(va, int)));
|
|
/* For the case when it's \0 char */
|
|
force_char = true;
|
|
break;
|
|
case 's':
|
|
p = va_arg(va, char*);
|
|
break;
|
|
case '%':
|
|
out(info, '%');
|
|
break;
|
|
default:
|
|
out(info, '?');
|
|
break;
|
|
}
|
|
|
|
*info->bf = 0;
|
|
info->bf = p;
|
|
while (width > 0 && info->bf && *info->bf++)
|
|
width--;
|
|
while (width-- > 0)
|
|
info->putc(info, lz ? '0' : ' ');
|
|
if (p) {
|
|
while ((ch = *p++) || force_char) {
|
|
info->putc(info, ch);
|
|
force_char = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
abort:
|
|
return 0;
|
|
}
|
|
|
|
#if CONFIG_IS_ENABLED(PRINTF)
|
|
static void putc_normal(struct printf_info *info, char ch)
|
|
{
|
|
putc(ch);
|
|
}
|
|
|
|
int vprintf(const char *fmt, va_list va)
|
|
{
|
|
struct printf_info info;
|
|
|
|
info.putc = putc_normal;
|
|
return _vprintf(&info, fmt, va);
|
|
}
|
|
|
|
int printf(const char *fmt, ...)
|
|
{
|
|
struct printf_info info;
|
|
|
|
va_list va;
|
|
int ret;
|
|
|
|
info.putc = putc_normal;
|
|
va_start(va, fmt);
|
|
ret = _vprintf(&info, fmt, va);
|
|
va_end(va);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static void putc_outstr(struct printf_info *info, char ch)
|
|
{
|
|
*info->outstr++ = ch;
|
|
}
|
|
|
|
int sprintf(char *buf, const char *fmt, ...)
|
|
{
|
|
struct printf_info info;
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
info.outstr = buf;
|
|
info.putc = putc_outstr;
|
|
_vprintf(&info, fmt, va);
|
|
va_end(va);
|
|
*info.outstr = '\0';
|
|
|
|
return info.outstr - buf;
|
|
}
|
|
|
|
#if CONFIG_IS_ENABLED(LOG)
|
|
/* Note that size is ignored */
|
|
int vsnprintf(char *buf, size_t size, const char *fmt, va_list va)
|
|
{
|
|
struct printf_info info;
|
|
|
|
info.outstr = buf;
|
|
info.putc = putc_outstr;
|
|
_vprintf(&info, fmt, va);
|
|
*info.outstr = '\0';
|
|
|
|
return info.outstr - buf;
|
|
}
|
|
#endif
|
|
|
|
/* Note that size is ignored */
|
|
int snprintf(char *buf, size_t size, const char *fmt, ...)
|
|
{
|
|
struct printf_info info;
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
info.outstr = buf;
|
|
info.putc = putc_outstr;
|
|
_vprintf(&info, fmt, va);
|
|
va_end(va);
|
|
*info.outstr = '\0';
|
|
|
|
return info.outstr - buf;
|
|
}
|
|
|
|
void print_grouped_ull(unsigned long long int_val, int digits)
|
|
{
|
|
/* Don't try to print the upper 32-bits */
|
|
printf("%ld ", (ulong)int_val);
|
|
}
|