xref: /openbmc/linux/drivers/acpi/acpica/utprint.c (revision 6774def6)
1 /******************************************************************************
2  *
3  * Module Name: utprint - Formatted printing routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2014, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 
47 #define _COMPONENT          ACPI_UTILITIES
48 ACPI_MODULE_NAME("utprint")
49 
50 #define ACPI_FORMAT_SIGN            0x01
51 #define ACPI_FORMAT_SIGN_PLUS       0x02
52 #define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
53 #define ACPI_FORMAT_ZERO            0x08
54 #define ACPI_FORMAT_LEFT            0x10
55 #define ACPI_FORMAT_UPPER           0x20
56 #define ACPI_FORMAT_PREFIX          0x40
57 /* Local prototypes */
58 static acpi_size
59 acpi_ut_bound_string_length(const char *string, acpi_size count);
60 
61 static char *acpi_ut_bound_string_output(char *string, const char *end, char c);
62 
63 static char *acpi_ut_format_number(char *string,
64 				   char *end,
65 				   u64 number,
66 				   u8 base, s32 width, s32 precision, u8 type);
67 
68 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper);
69 
70 /* Module globals */
71 
72 static const char acpi_gbl_lower_hex_digits[] = "0123456789abcdef";
73 static const char acpi_gbl_upper_hex_digits[] = "0123456789ABCDEF";
74 
75 /*******************************************************************************
76  *
77  * FUNCTION:    acpi_ut_bound_string_length
78  *
79  * PARAMETERS:  string              - String with boundary
80  *              count               - Boundary of the string
81  *
82  * RETURN:      Length of the string. Less than or equal to Count.
83  *
84  * DESCRIPTION: Calculate the length of a string with boundary.
85  *
86  ******************************************************************************/
87 
88 static acpi_size
89 acpi_ut_bound_string_length(const char *string, acpi_size count)
90 {
91 	u32 length = 0;
92 
93 	while (*string && count) {
94 		length++;
95 		string++;
96 		count--;
97 	}
98 
99 	return (length);
100 }
101 
102 /*******************************************************************************
103  *
104  * FUNCTION:    acpi_ut_bound_string_output
105  *
106  * PARAMETERS:  string              - String with boundary
107  *              end                 - Boundary of the string
108  *              c                   - Character to be output to the string
109  *
110  * RETURN:      Updated position for next valid character
111  *
112  * DESCRIPTION: Output a character into a string with boundary check.
113  *
114  ******************************************************************************/
115 
116 static char *acpi_ut_bound_string_output(char *string, const char *end, char c)
117 {
118 
119 	if (string < end) {
120 		*string = c;
121 	}
122 
123 	++string;
124 	return (string);
125 }
126 
127 /*******************************************************************************
128  *
129  * FUNCTION:    acpi_ut_put_number
130  *
131  * PARAMETERS:  string              - Buffer to hold reverse-ordered string
132  *              number              - Integer to be converted
133  *              base                - Base of the integer
134  *              upper               - Whether or not using upper cased digits
135  *
136  * RETURN:      Updated position for next valid character
137  *
138  * DESCRIPTION: Convert an integer into a string, note that, the string holds a
139  *              reversed ordered number without the trailing zero.
140  *
141  ******************************************************************************/
142 
143 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper)
144 {
145 	const char *digits;
146 	u64 digit_index;
147 	char *pos;
148 
149 	pos = string;
150 	digits = upper ? acpi_gbl_upper_hex_digits : acpi_gbl_lower_hex_digits;
151 
152 	if (number == 0) {
153 		*(pos++) = '0';
154 	} else {
155 		while (number) {
156 			(void)acpi_ut_divide(number, base, &number,
157 					     &digit_index);
158 			*(pos++) = digits[digit_index];
159 		}
160 	}
161 
162 	/* *(Pos++) = '0'; */
163 	return (pos);
164 }
165 
166 /*******************************************************************************
167  *
168  * FUNCTION:    acpi_ut_scan_number
169  *
170  * PARAMETERS:  string              - String buffer
171  *              number_ptr          - Where the number is returned
172  *
173  * RETURN:      Updated position for next valid character
174  *
175  * DESCRIPTION: Scan a string for a decimal integer.
176  *
177  ******************************************************************************/
178 
179 const char *acpi_ut_scan_number(const char *string, u64 *number_ptr)
180 {
181 	u64 number = 0;
182 
183 	while (ACPI_IS_DIGIT(*string)) {
184 		number *= 10;
185 		number += *(string++) - '0';
186 	}
187 
188 	*number_ptr = number;
189 	return (string);
190 }
191 
192 /*******************************************************************************
193  *
194  * FUNCTION:    acpi_ut_print_number
195  *
196  * PARAMETERS:  string              - String buffer
197  *              number              - The number to be converted
198  *
199  * RETURN:      Updated position for next valid character
200  *
201  * DESCRIPTION: Print a decimal integer into a string.
202  *
203  ******************************************************************************/
204 
205 const char *acpi_ut_print_number(char *string, u64 number)
206 {
207 	char ascii_string[20];
208 	const char *pos1;
209 	char *pos2;
210 
211 	pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE);
212 	pos2 = string;
213 
214 	while (pos1 != ascii_string) {
215 		*(pos2++) = *(--pos1);
216 	}
217 
218 	*pos2 = 0;
219 	return (string);
220 }
221 
222 /*******************************************************************************
223  *
224  * FUNCTION:    acpi_ut_format_number
225  *
226  * PARAMETERS:  string              - String buffer with boundary
227  *              end                 - Boundary of the string
228  *              number              - The number to be converted
229  *              base                - Base of the integer
230  *              width               - Field width
231  *              precision           - Precision of the integer
232  *              type                - Special printing flags
233  *
234  * RETURN:      Updated position for next valid character
235  *
236  * DESCRIPTION: Print an integer into a string with any base and any precision.
237  *
238  ******************************************************************************/
239 
240 static char *acpi_ut_format_number(char *string,
241 				   char *end,
242 				   u64 number,
243 				   u8 base, s32 width, s32 precision, u8 type)
244 {
245 	char *pos;
246 	char sign;
247 	char zero;
248 	u8 need_prefix;
249 	u8 upper;
250 	s32 i;
251 	char reversed_string[66];
252 
253 	/* Parameter validation */
254 
255 	if (base < 2 || base > 16) {
256 		return (NULL);
257 	}
258 
259 	if (type & ACPI_FORMAT_LEFT) {
260 		type &= ~ACPI_FORMAT_ZERO;
261 	}
262 
263 	need_prefix = ((type & ACPI_FORMAT_PREFIX)
264 		       && base != 10) ? TRUE : FALSE;
265 	upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
266 	zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' ';
267 
268 	/* Calculate size according to sign and prefix */
269 
270 	sign = '\0';
271 	if (type & ACPI_FORMAT_SIGN) {
272 		if ((s64) number < 0) {
273 			sign = '-';
274 			number = -(s64) number;
275 			width--;
276 		} else if (type & ACPI_FORMAT_SIGN_PLUS) {
277 			sign = '+';
278 			width--;
279 		} else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) {
280 			sign = ' ';
281 			width--;
282 		}
283 	}
284 	if (need_prefix) {
285 		width--;
286 		if (base == 16) {
287 			width--;
288 		}
289 	}
290 
291 	/* Generate full string in reverse order */
292 
293 	pos = acpi_ut_put_number(reversed_string, number, base, upper);
294 	i = ACPI_PTR_DIFF(pos, reversed_string);
295 
296 	/* Printing 100 using %2d gives "100", not "00" */
297 
298 	if (i > precision) {
299 		precision = i;
300 	}
301 
302 	width -= precision;
303 
304 	/* Output the string */
305 
306 	if (!(type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT))) {
307 		while (--width >= 0) {
308 			string = acpi_ut_bound_string_output(string, end, ' ');
309 		}
310 	}
311 	if (sign) {
312 		string = acpi_ut_bound_string_output(string, end, sign);
313 	}
314 	if (need_prefix) {
315 		string = acpi_ut_bound_string_output(string, end, '0');
316 		if (base == 16) {
317 			string = acpi_ut_bound_string_output(string, end,
318 							     upper ? 'X' : 'x');
319 		}
320 	}
321 	if (!(type & ACPI_FORMAT_LEFT)) {
322 		while (--width >= 0) {
323 			string = acpi_ut_bound_string_output(string, end, zero);
324 		}
325 	}
326 
327 	while (i <= --precision) {
328 		string = acpi_ut_bound_string_output(string, end, '0');
329 	}
330 	while (--i >= 0) {
331 		string = acpi_ut_bound_string_output(string, end,
332 						     reversed_string[i]);
333 	}
334 	while (--width >= 0) {
335 		string = acpi_ut_bound_string_output(string, end, ' ');
336 	}
337 
338 	return (string);
339 }
340 
341 /*******************************************************************************
342  *
343  * FUNCTION:    acpi_ut_vsnprintf
344  *
345  * PARAMETERS:  string              - String with boundary
346  *              size                - Boundary of the string
347  *              format              - Standard printf format
348  *              args                - Argument list
349  *
350  * RETURN:      Number of bytes actually written.
351  *
352  * DESCRIPTION: Formatted output to a string using argument list pointer.
353  *
354  ******************************************************************************/
355 
356 int
357 acpi_ut_vsnprintf(char *string,
358 		  acpi_size size, const char *format, va_list args)
359 {
360 	u8 base = 10;
361 	u8 type = 0;
362 	s32 width = -1;
363 	s32 precision = -1;
364 	char qualifier = 0;
365 	u64 number;
366 	char *pos;
367 	char *end;
368 	char c;
369 	const char *s;
370 	const void *p;
371 	s32 length;
372 	int i;
373 
374 	pos = string;
375 	end = string + size;
376 
377 	for (; *format; ++format) {
378 		if (*format != '%') {
379 			pos = acpi_ut_bound_string_output(pos, end, *format);
380 			continue;
381 		}
382 
383 		/* Process sign */
384 
385 		do {
386 			++format;
387 			if (*format == '#') {
388 				type |= ACPI_FORMAT_PREFIX;
389 			} else if (*format == '0') {
390 				type |= ACPI_FORMAT_ZERO;
391 			} else if (*format == '+') {
392 				type |= ACPI_FORMAT_SIGN_PLUS;
393 			} else if (*format == ' ') {
394 				type |= ACPI_FORMAT_SIGN_PLUS_SPACE;
395 			} else if (*format == '-') {
396 				type |= ACPI_FORMAT_LEFT;
397 			} else {
398 				break;
399 			}
400 		} while (1);
401 
402 		/* Process width */
403 
404 		width = -1;
405 		if (ACPI_IS_DIGIT(*format)) {
406 			format = acpi_ut_scan_number(format, &number);
407 			width = (s32) number;
408 		} else if (*format == '*') {
409 			++format;
410 			width = va_arg(args, int);
411 			if (width < 0) {
412 				width = -width;
413 				type |= ACPI_FORMAT_LEFT;
414 			}
415 		}
416 
417 		/* Process precision */
418 
419 		precision = -1;
420 		if (*format == '.') {
421 			++format;
422 			if (ACPI_IS_DIGIT(*format)) {
423 				format = acpi_ut_scan_number(format, &number);
424 				precision = (s32) number;
425 			} else if (*format == '*') {
426 				++format;
427 				precision = va_arg(args, int);
428 			}
429 			if (precision < 0) {
430 				precision = 0;
431 			}
432 		}
433 
434 		/* Process qualifier */
435 
436 		qualifier = -1;
437 		if (*format == 'h' || *format == 'l' || *format == 'L') {
438 			qualifier = *format;
439 			++format;
440 
441 			if (qualifier == 'l' && *format == 'l') {
442 				qualifier = 'L';
443 				++format;
444 			}
445 		}
446 
447 		switch (*format) {
448 		case '%':
449 
450 			pos = acpi_ut_bound_string_output(pos, end, '%');
451 			continue;
452 
453 		case 'c':
454 
455 			if (!(type & ACPI_FORMAT_LEFT)) {
456 				while (--width > 0) {
457 					pos =
458 					    acpi_ut_bound_string_output(pos,
459 									end,
460 									' ');
461 				}
462 			}
463 
464 			c = (char)va_arg(args, int);
465 			pos = acpi_ut_bound_string_output(pos, end, c);
466 
467 			while (--width > 0) {
468 				pos =
469 				    acpi_ut_bound_string_output(pos, end, ' ');
470 			}
471 			continue;
472 
473 		case 's':
474 
475 			s = va_arg(args, char *);
476 			if (!s) {
477 				s = "<NULL>";
478 			}
479 			length = acpi_ut_bound_string_length(s, precision);
480 			if (!(type & ACPI_FORMAT_LEFT)) {
481 				while (length < width--) {
482 					pos =
483 					    acpi_ut_bound_string_output(pos,
484 									end,
485 									' ');
486 				}
487 			}
488 			for (i = 0; i < length; ++i) {
489 				pos = acpi_ut_bound_string_output(pos, end, *s);
490 				++s;
491 			}
492 			while (length < width--) {
493 				pos =
494 				    acpi_ut_bound_string_output(pos, end, ' ');
495 			}
496 			continue;
497 
498 		case 'o':
499 
500 			base = 8;
501 			break;
502 
503 		case 'X':
504 
505 			type |= ACPI_FORMAT_UPPER;
506 
507 		case 'x':
508 
509 			base = 16;
510 			break;
511 
512 		case 'd':
513 		case 'i':
514 
515 			type |= ACPI_FORMAT_SIGN;
516 
517 		case 'u':
518 
519 			break;
520 
521 		case 'p':
522 
523 			if (width == -1) {
524 				width = 2 * sizeof(void *);
525 				type |= ACPI_FORMAT_ZERO;
526 			}
527 
528 			p = va_arg(args, void *);
529 			pos = acpi_ut_format_number(pos, end,
530 						    ACPI_TO_INTEGER(p), 16,
531 						    width, precision, type);
532 			continue;
533 
534 		default:
535 
536 			pos = acpi_ut_bound_string_output(pos, end, '%');
537 			if (*format) {
538 				pos =
539 				    acpi_ut_bound_string_output(pos, end,
540 								*format);
541 			} else {
542 				--format;
543 			}
544 			continue;
545 		}
546 
547 		if (qualifier == 'L') {
548 			number = va_arg(args, u64);
549 			if (type & ACPI_FORMAT_SIGN) {
550 				number = (s64) number;
551 			}
552 		} else if (qualifier == 'l') {
553 			number = va_arg(args, unsigned long);
554 			if (type & ACPI_FORMAT_SIGN) {
555 				number = (s32) number;
556 			}
557 		} else if (qualifier == 'h') {
558 			number = (u16)va_arg(args, int);
559 			if (type & ACPI_FORMAT_SIGN) {
560 				number = (s16) number;
561 			}
562 		} else {
563 			number = va_arg(args, unsigned int);
564 			if (type & ACPI_FORMAT_SIGN) {
565 				number = (signed int)number;
566 			}
567 		}
568 
569 		pos = acpi_ut_format_number(pos, end, number, base,
570 					    width, precision, type);
571 	}
572 
573 	if (size > 0) {
574 		if (pos < end) {
575 			*pos = '\0';
576 		} else {
577 			end[-1] = '\0';
578 		}
579 	}
580 
581 	return (ACPI_PTR_DIFF(pos, string));
582 }
583 
584 /*******************************************************************************
585  *
586  * FUNCTION:    acpi_ut_snprintf
587  *
588  * PARAMETERS:  string              - String with boundary
589  *              size                - Boundary of the string
590  *              Format, ...         - Standard printf format
591  *
592  * RETURN:      Number of bytes actually written.
593  *
594  * DESCRIPTION: Formatted output to a string.
595  *
596  ******************************************************************************/
597 
598 int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...)
599 {
600 	va_list args;
601 	int length;
602 
603 	va_start(args, format);
604 	length = acpi_ut_vsnprintf(string, size, format, args);
605 	va_end(args);
606 
607 	return (length);
608 }
609 
610 #ifdef ACPI_APPLICATION
611 /*******************************************************************************
612  *
613  * FUNCTION:    acpi_ut_file_vprintf
614  *
615  * PARAMETERS:  file                - File descriptor
616  *              format              - Standard printf format
617  *              args                - Argument list
618  *
619  * RETURN:      Number of bytes actually written.
620  *
621  * DESCRIPTION: Formatted output to a file using argument list pointer.
622  *
623  ******************************************************************************/
624 
625 int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args)
626 {
627 	acpi_cpu_flags flags;
628 	int length;
629 
630 	flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
631 	length = acpi_ut_vsnprintf(acpi_gbl_print_buffer,
632 				   sizeof(acpi_gbl_print_buffer), format, args);
633 
634 	(void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1);
635 	acpi_os_release_lock(acpi_gbl_print_lock, flags);
636 
637 	return (length);
638 }
639 
640 /*******************************************************************************
641  *
642  * FUNCTION:    acpi_ut_file_printf
643  *
644  * PARAMETERS:  file                - File descriptor
645  *              Format, ...         - Standard printf format
646  *
647  * RETURN:      Number of bytes actually written.
648  *
649  * DESCRIPTION: Formatted output to a file.
650  *
651  ******************************************************************************/
652 
653 int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...)
654 {
655 	va_list args;
656 	int length;
657 
658 	va_start(args, format);
659 	length = acpi_ut_file_vprintf(file, format, args);
660 	va_end(args);
661 
662 	return (length);
663 }
664 #endif
665