git.sur5r.net Git - u-boot/blob - lib/tiny-printf.c

   1 /*
   2  * Tiny printf version for SPL
   3  *
   4  * Copied from:
   5  * http://www.sparetimelabs.com/printfrevisited/printfrevisited.php
   6  *
   7  * Copyright (C) 2004,2008  Kustaa Nyholm
   8  *
   9  * SPDX-License-Identifier:     LGPL-2.1+
  10  */
  11
  12 #include <common.h>
  13 #include <stdarg.h>
  14 #include <serial.h>
  15 #include <linux/ctype.h>
  16
  17 struct printf_info {
  18         char *bf;       /* Digit buffer */
  19         char zs;        /* non-zero if a digit has been written */
  20         char *outstr;   /* Next output position for sprintf() */
  21
  22         /* Output a character */
  23         void (*putc)(struct printf_info *info, char ch);
  24 };
  25
  26 static void putc_normal(struct printf_info *info, char ch)
  27 {
  28         putc(ch);
  29 }
  30
  31 static void out(struct printf_info *info, char c)
  32 {
  33         *info->bf++ = c;
  34 }
  35
  36 static void out_dgt(struct printf_info *info, char dgt)
  37 {
  38         out(info, dgt + (dgt < 10 ? '0' : 'a' - 10));
  39         info->zs = 1;
  40 }
  41
  42 static void div_out(struct printf_info *info, unsigned long *num,
  43                     unsigned long div)
  44 {
  45         unsigned char dgt = 0;
  46
  47         while (*num >= div) {
  48                 *num -= div;
  49                 dgt++;
  50         }
  51
  52         if (info->zs || dgt > 0)
  53                 out_dgt(info, dgt);
  54 }
  55
  56 #ifdef CONFIG_SPL_NET_SUPPORT
  57 static void string(struct printf_info *info, char *s)
  58 {
  59         char ch;
  60
  61         while ((ch = *s++))
  62                 out(info, ch);
  63 }
  64
  65 static const char hex_asc[] = "0123456789abcdef";
  66 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
  67 #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
  68
  69 static inline char *pack_hex_byte(char *buf, u8 byte)
  70 {
  71         *buf++ = hex_asc_hi(byte);
  72         *buf++ = hex_asc_lo(byte);
  73         return buf;
  74 }
  75
  76 static void mac_address_string(struct printf_info *info, u8 *addr,
  77                                 bool separator)
  78 {
  79         /* (6 * 2 hex digits), 5 colons and trailing zero */
  80         char mac_addr[6 * 3];
  81         char *p = mac_addr;
  82         int i;
  83
  84         for (i = 0; i < 6; i++) {
  85                 p = pack_hex_byte(p, addr[i]);
  86                 if (separator && i != 5)
  87                         *p++ = ':';
  88         }
  89         *p = '\0';
  90
  91         string(info, mac_addr);
  92 }
  93
  94 static char *put_dec_trunc(char *buf, unsigned int q)
  95 {
  96         unsigned int d3, d2, d1, d0;
  97         d1 = (q >> 4) & 0xf;
  98         d2 = (q >> 8) & 0xf;
  99         d3 = (q >> 12);
 100
 101         d0 = 6 * (d3 + d2 + d1) + (q & 0xf);
 102         q = (d0 * 0xcd) >> 11;
 103         d0 = d0 - 10 * q;
 104         *buf++ = d0 + '0'; /* least significant digit */
 105         d1 = q + 9 * d3 + 5 * d2 + d1;
 106         if (d1 != 0) {
 107                 q = (d1 * 0xcd) >> 11;
 108                 d1 = d1 - 10 * q;
 109                 *buf++ = d1 + '0'; /* next digit */
 110
 111                 d2 = q + 2 * d2;
 112                 if ((d2 != 0) || (d3 != 0)) {
 113                         q = (d2 * 0xd) >> 7;
 114                         d2 = d2 - 10 * q;
 115                         *buf++ = d2 + '0'; /* next digit */
 116
 117                         d3 = q + 4 * d3;
 118                         if (d3 != 0) {
 119                                 q = (d3 * 0xcd) >> 11;
 120                                 d3 = d3 - 10 * q;
 121                                 *buf++ = d3 + '0';  /* next digit */
 122                                 if (q != 0)
 123                                         *buf++ = q + '0'; /* most sign. digit */
 124                         }
 125                 }
 126         }
 127         return buf;
 128 }
 129
 130 static void ip4_addr_string(struct printf_info *info, u8 *addr)
 131 {
 132         /* (4 * 3 decimal digits), 3 dots and trailing zero */
 133         char ip4_addr[4 * 4];
 134         char temp[3];   /* hold each IP quad in reverse order */
 135         char *p = ip4_addr;
 136         int i, digits;
 137
 138         for (i = 0; i < 4; i++) {
 139                 digits = put_dec_trunc(temp, addr[i]) - temp;
 140                 /* reverse the digits in the quad */
 141                 while (digits--)
 142                         *p++ = temp[digits];
 143                 if (i != 3)
 144                         *p++ = '.';
 145         }
 146         *p = '\0';
 147
 148         string(info, ip4_addr);
 149 }
 150 #endif
 151
 152 /*
 153  * Show a '%p' thing.  A kernel extension is that the '%p' is followed
 154  * by an extra set of characters that are extended format
 155  * specifiers.
 156  *
 157  * Right now we handle:
 158  *
 159  * - 'M' For a 6-byte MAC address, it prints the address in the
 160  *       usual colon-separated hex notation.
 161  * - 'm' Same as above except there is no colon-separator.
 162  * - 'I4'for IPv4 addresses printed in the usual way (dot-separated
 163  *       decimal).
 164  */
 165
 166 static void pointer(struct printf_info *info, const char *fmt, void *ptr)
 167 {
 168 #ifdef DEBUG
 169         unsigned long num = (uintptr_t)ptr;
 170         unsigned long div;
 171 #endif
 172
 173         switch (*fmt) {
 174 #ifdef DEBUG
 175         case 'a':
 176
 177                 switch (fmt[1]) {
 178                 case 'p':
 179                 default:
 180                         num = *(phys_addr_t *)ptr;
 181                         break;
 182                 }
 183                 break;
 184 #endif
 185 #ifdef CONFIG_SPL_NET_SUPPORT
 186         case 'm':
 187                 return mac_address_string(info, ptr, false);
 188         case 'M':
 189                 return mac_address_string(info, ptr, true);
 190         case 'I':
 191                 if (fmt[1] == '4')
 192                         return ip4_addr_string(info, ptr);
 193 #endif
 194         default:
 195                 break;
 196         }
 197 #ifdef DEBUG
 198         div = 1UL << (sizeof(long) * 8 - 4);
 199         for (; div; div /= 0x10)
 200                 div_out(info, &num, div);
 201 #endif
 202 }
 203
 204 static int _vprintf(struct printf_info *info, const char *fmt, va_list va)
 205 {
 206         char ch;
 207         char *p;
 208         unsigned long num;
 209         char buf[12];
 210         unsigned long div;
 211
 212         while ((ch = *(fmt++))) {
 213                 if (ch != '%') {
 214                         info->putc(info, ch);
 215                 } else {
 216                         bool lz = false;
 217                         int width = 0;
 218                         bool islong = false;
 219
 220                         ch = *(fmt++);
 221                         if (ch == '-')
 222                                 ch = *(fmt++);
 223
 224                         if (ch == '0') {
 225                                 ch = *(fmt++);
 226                                 lz = 1;
 227                         }
 228
 229                         if (ch >= '0' && ch <= '9') {
 230                                 width = 0;
 231                                 while (ch >= '0' && ch <= '9') {
 232                                         width = (width * 10) + ch - '0';
 233                                         ch = *fmt++;
 234                                 }
 235                         }
 236                         if (ch == 'l') {
 237                                 ch = *(fmt++);
 238                                 islong = true;
 239                         }
 240
 241                         info->bf = buf;
 242                         p = info->bf;
 243                         info->zs = 0;
 244
 245                         switch (ch) {
 246                         case '\0':
 247                                 goto abort;
 248                         case 'u':
 249                         case 'd':
 250                                 div = 1000000000;
 251                                 if (islong) {
 252                                         num = va_arg(va, unsigned long);
 253                                         if (sizeof(long) > 4)
 254                                                 div *= div * 10;
 255                                 } else {
 256                                         num = va_arg(va, unsigned int);
 257                                 }
 258
 259                                 if (ch == 'd') {
 260                                         if (islong && (long)num < 0) {
 261                                                 num = -(long)num;
 262                                                 out(info, '-');
 263                                         } else if (!islong && (int)num < 0) {
 264                                                 num = -(int)num;
 265                                                 out(info, '-');
 266                                         }
 267                                 }
 268                                 if (!num) {
 269                                         out_dgt(info, 0);
 270                                 } else {
 271                                         for (; div; div /= 10)
 272                                                 div_out(info, &num, div);
 273                                 }
 274                                 break;
 275                         case 'x':
 276                                 if (islong) {
 277                                         num = va_arg(va, unsigned long);
 278                                         div = 1UL << (sizeof(long) * 8 - 4);
 279                                 } else {
 280                                         num = va_arg(va, unsigned int);
 281                                         div = 0x10000000;
 282                                 }
 283                                 if (!num) {
 284                                         out_dgt(info, 0);
 285                                 } else {
 286                                         for (; div; div /= 0x10)
 287                                                 div_out(info, &num, div);
 288                                 }
 289                                 break;
 290                         case 'c':
 291                                 out(info, (char)(va_arg(va, int)));
 292                                 break;
 293                         case 's':
 294                                 p = va_arg(va, char*);
 295                                 break;
 296                         case 'p':
 297                                 pointer(info, fmt, va_arg(va, void *));
 298                                 while (isalnum(fmt[0]))
 299                                         fmt++;
 300                                 break;
 301                         case '%':
 302                                 out(info, '%');
 303                         default:
 304                                 break;
 305                         }
 306
 307                         *info->bf = 0;
 308                         info->bf = p;
 309                         while (*info->bf++ && width > 0)
 310                                 width--;
 311                         while (width-- > 0)
 312                                 info->putc(info, lz ? '0' : ' ');
 313                         if (p) {
 314                                 while ((ch = *p++))
 315                                         info->putc(info, ch);
 316                         }
 317                 }
 318         }
 319
 320 abort:
 321         return 0;
 322 }
 323
 324 int vprintf(const char *fmt, va_list va)
 325 {
 326         struct printf_info info;
 327
 328         info.putc = putc_normal;
 329         return _vprintf(&info, fmt, va);
 330 }
 331
 332 int printf(const char *fmt, ...)
 333 {
 334         struct printf_info info;
 335
 336         va_list va;
 337         int ret;
 338
 339         info.putc = putc_normal;
 340         va_start(va, fmt);
 341         ret = _vprintf(&info, fmt, va);
 342         va_end(va);
 343
 344         return ret;
 345 }
 346
 347 static void putc_outstr(struct printf_info *info, char ch)
 348 {
 349         *info->outstr++ = ch;
 350 }
 351
 352 int sprintf(char *buf, const char *fmt, ...)
 353 {
 354         struct printf_info info;
 355         va_list va;
 356         int ret;
 357
 358         va_start(va, fmt);
 359         info.outstr = buf;
 360         info.putc = putc_outstr;
 361         ret = _vprintf(&info, fmt, va);
 362         va_end(va);
 363         *info.outstr = '\0';
 364
 365         return ret;
 366 }
 367
 368 /* Note that size is ignored */
 369 int snprintf(char *buf, size_t size, const char *fmt, ...)
 370 {
 371         struct printf_info info;
 372         va_list va;
 373         int ret;
 374
 375         va_start(va, fmt);
 376         info.outstr = buf;
 377         info.putc = putc_outstr;
 378         ret = _vprintf(&info, fmt, va);
 379         va_end(va);
 380         *info.outstr = '\0';
 381
 382         return ret;
 383 }
 384
 385 void __assert_fail(const char *assertion, const char *file, unsigned line,
 386                    const char *function)
 387 {
 388         /* This will not return */
 389         printf("%s:%u: %s: Assertion `%s' failed.", file, line, function,
 390                assertion);
 391         hang();
 392 }