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