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