6 files changed, 682 insertions, 1 deletions

diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index 14b851f1a278..6b9ec239d578 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -175,5 +175,5 @@ acpi-y +=		\
         utxferror.o     \
         utxfmutex.o
 
-acpi-$(ACPI_FUTURE_USAGE) += utfileio.o uttrack.o utcache.o
+acpi-$(ACPI_FUTURE_USAGE) += utfileio.o utprint.o uttrack.o utcache.o
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index 78cc366ca878..ebf02cc10a43 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -364,6 +364,11 @@ ACPI_GLOBAL(u32, acpi_gbl_num_objects);
 ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_debug_file, NULL);
 ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_output_file, NULL);
 
+/* Print buffer */
+
+ACPI_GLOBAL(acpi_spinlock, acpi_gbl_print_lock);        /* For print buffer */
+ACPI_GLOBAL(char, acpi_gbl_print_buffer[1024]);
+
 #endif                          /* ACPI_APPLICATION */
 
 /*****************************************************************************
diff --git a/drivers/acpi/acpica/acutils.h b/drivers/acpi/acpica/acutils.h
index e0adbc1f52ed..85871c639cc2 100644
--- a/drivers/acpi/acpica/acutils.h
+++ b/drivers/acpi/acpica/acutils.h
@@ -750,4 +750,23 @@ const struct ah_predefined_name *acpi_ah_match_predefined_name(char *nameseg);
 
 const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
 
+/*
+ * utprint - printf/vprintf output functions
+ */
+const char *acpi_ut_scan_number(const char *string, u64 *number_ptr);
+
+const char *acpi_ut_print_number(char *string, u64 number);
+
+int
+acpi_ut_vsnprintf(char *string,
+                  acpi_size size, const char *format, va_list args);
+
+int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...);
+
+#ifdef ACPI_APPLICATION
+int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args);
+
+int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...);
+#endif
+
 #endif                          /* _ACUTILS_H */
diff --git a/drivers/acpi/acpica/utprint.c b/drivers/acpi/acpica/utprint.c
new file mode 100644
index 000000000000..9d5293fd992f
--- /dev/null
+++ b/drivers/acpi/acpica/utprint.c
@@ -0,0 +1,649 @@
+/******************************************************************************
+ *
+ * Module Name: utprint - Formatted printing routines
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include "accommon.h"
+
+#define _COMPONENT          ACPI_UTILITIES
+ACPI_MODULE_NAME("utprint")
+
+#define ACPI_FORMAT_SIGN            0x01
+#define ACPI_FORMAT_SIGN_PLUS       0x02
+#define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
+#define ACPI_FORMAT_ZERO            0x08
+#define ACPI_FORMAT_LEFT            0x10
+#define ACPI_FORMAT_UPPER           0x20
+#define ACPI_FORMAT_PREFIX          0x40
+/* Local prototypes */
+static acpi_size
+acpi_ut_bound_string_length(const char *string, acpi_size count);
+
+static char *acpi_ut_bound_string_output(char *string, const char *end, char c);
+
+static char *acpi_ut_format_number(char *string,
+                                   char *end,
+                                   u64 number,
+                                   u8 base, s32 width, s32 precision, u8 type);
+
+static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_bound_string_length
+ *
+ * PARAMETERS:  string              - String with boundary
+ *              count               - Boundary of the string
+ *
+ * RETURN:      Length of the string.
+ *
+ * DESCRIPTION: Calculate the length of a string with boundary.
+ *
+ ******************************************************************************/
+
+static acpi_size
+acpi_ut_bound_string_length(const char *string, acpi_size count)
+{
+        u32 length = 0;
+
+        while (*string && count) {
+                length++;
+                string++;
+                count--;
+        }
+
+        return (length);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_bound_string_output
+ *
+ * PARAMETERS:  string              - String with boundary
+ *              end                 - Boundary of the string
+ *              c                   - Character to be output to the string
+ *
+ * RETURN:      Updated position for next valid character
+ *
+ * DESCRIPTION: Output a character into a string with boundary check.
+ *
+ ******************************************************************************/
+
+static char *acpi_ut_bound_string_output(char *string, const char *end, char c)
+{
+
+        if (string < end) {
+                *string = c;
+        }
+        ++string;
+
+        return (string);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_put_number
+ *
+ * PARAMETERS:  string              - Buffer to hold reverse-ordered string
+ *              number              - Integer to be converted
+ *              base                - Base of the integer
+ *              upper               - Whether or not using upper cased digits
+ *
+ * RETURN:      Updated position for next valid character
+ *
+ * DESCRIPTION: Convert an integer into a string, note that, the string holds a
+ *              reversed ordered number without the trailing zero.
+ *
+ ******************************************************************************/
+
+static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper)
+{
+        const char lower_digits[] = "0123456789abcdef";
+        const char upper_digits[] = "0123456789ABCDEF";
+        const char *digits;
+        u64 digit_index;
+        char *pos;
+
+        pos = string;
+        digits = upper ? upper_digits : lower_digits;
+
+        if (number == 0) {
+                *(pos++) = '0';
+        } else {
+                while (number) {
+                        (void)acpi_ut_divide(number, base, &number,
+                                             &digit_index);
+                        *(pos++) = digits[digit_index];
+                }
+        }
+        /* *(Pos++) = '0'; */
+
+        return (pos);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_scan_number
+ *
+ * PARAMETERS:  string              - String buffer
+ *              number_ptr          - Where the number is returned
+ *
+ * RETURN:      Updated position for next valid character
+ *
+ * DESCRIPTION: Scan a string for a decimal integer.
+ *
+ ******************************************************************************/
+
+const char *acpi_ut_scan_number(const char *string, u64 *number_ptr)
+{
+        u64 number = 0;
+
+        while (ACPI_IS_DIGIT(*string)) {
+                number *= 10;
+                number += *(string++) - '0';
+        }
+        *number_ptr = number;
+
+        return (string);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_print_number
+ *
+ * PARAMETERS:  string              - String buffer
+ *              number              - The number to be converted
+ *
+ * RETURN:      Updated position for next valid character
+ *
+ * DESCRIPTION: Print a decimal integer into a string.
+ *
+ ******************************************************************************/
+
+const char *acpi_ut_print_number(char *string, u64 number)
+{
+        char ascii_string[20];
+        const char *pos1;
+        char *pos2;
+
+        pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE);
+        pos2 = string;
+
+        while (pos1 != ascii_string) {
+                *(pos2++) = *(--pos1);
+        }
+        *pos2 = 0;
+
+        return (string);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_format_number
+ *
+ * PARAMETERS:  string              - String buffer with boundary
+ *              end                 - Boundary of the string
+ *              number              - The number to be converted
+ *              base                - Base of the integer
+ *              width               - Field width
+ *              precision           - Precision of the integer
+ *              type                - Special printing flags
+ *
+ * RETURN:      Updated position for next valid character
+ *
+ * DESCRIPTION: Print an integer into a string with any base and any precision.
+ *
+ ******************************************************************************/
+
+static char *acpi_ut_format_number(char *string,
+                                   char *end,
+                                   u64 number,
+                                   u8 base, s32 width, s32 precision, u8 type)
+{
+        char sign;
+        char zero;
+        u8 need_prefix;
+        u8 upper;
+        s32 i;
+        char reversed_string[66];
+
+        /* Perform sanity checks */
+
+        if (base < 2 || base > 16) {
+                return NULL;
+        }
+        if (type & ACPI_FORMAT_LEFT) {
+                type &= ~ACPI_FORMAT_ZERO;
+        }
+
+        need_prefix = ((type & ACPI_FORMAT_PREFIX)
+                       && base != 10) ? TRUE : FALSE;
+        upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
+        zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' ';
+
+        /* Calculate size according to sign and prefix */
+
+        sign = '\0';
+        if (type & ACPI_FORMAT_SIGN) {
+                if ((s64) number < 0) {
+                        sign = '-';
+                        number = -(s64) number;
+                        width--;
+                } else if (type & ACPI_FORMAT_SIGN_PLUS) {
+                        sign = '+';
+                        width--;
+                } else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) {
+                        sign = ' ';
+                        width--;
+                }
+        }
+        if (need_prefix) {
+                width--;
+                if (base == 16) {
+                        width--;
+                }
+        }
+
+        /* Generate full string in reverse order */
+
+        i = ACPI_PTR_DIFF(acpi_ut_put_number
+                          (reversed_string, number, base, upper),
+                          reversed_string);
+
+        /* Printing 100 using %2d gives "100", not "00" */
+
+        if (i > precision) {
+                precision = i;
+        }
+        width -= precision;
+
+        /* Output the string */
+
+        if (!(type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT))) {
+                while (--width >= 0) {
+                        string = acpi_ut_bound_string_output(string, end, ' ');
+                }
+        }
+        if (sign) {
+                string = acpi_ut_bound_string_output(string, end, sign);
+        }
+        if (need_prefix) {
+                string = acpi_ut_bound_string_output(string, end, '0');
+                if (base == 16) {
+                        string = acpi_ut_bound_string_output(string, end,
+                                                             upper ? 'X' : 'x');
+                }
+        }
+        if (!(type & ACPI_FORMAT_LEFT)) {
+                while (--width >= 0) {
+                        string = acpi_ut_bound_string_output(string, end, zero);
+                }
+        }
+        while (i <= --precision) {
+                string = acpi_ut_bound_string_output(string, end, '0');
+        }
+        while (--i >= 0) {
+                string = acpi_ut_bound_string_output(string, end,
+                                                     reversed_string[i]);
+        }
+        while (--width >= 0) {
+                string = acpi_ut_bound_string_output(string, end, ' ');
+        }
+
+        return (string);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_vsnprintf
+ *
+ * PARAMETERS:  string              - String with boundary
+ *              size                - Boundary of the string
+ *              format              - Standard printf format
+ *              args                - Argument list
+ *
+ * RETURN:      Size of successfully output bytes
+ *
+ * DESCRIPTION: Formatted output to a string using argument list pointer.
+ *
+ ******************************************************************************/
+
+int
+acpi_ut_vsnprintf(char *string,
+                  acpi_size size, const char *format, va_list args)
+{
+        u8 base = 10;
+        u8 type = 0;
+        s32 width = -1;
+        s32 precision = -1;
+        char qualifier = 0;
+        u64 number;
+        char *pos;
+        char *end;
+        char c;
+        const char *s;
+        const void *p;
+        s32 length;
+        int i;
+
+        pos = string;
+        end = string + size;
+
+        for (; *format; ++format) {
+                if (*format != '%') {
+                        pos = acpi_ut_bound_string_output(pos, end, *format);
+                        continue;
+                }
+
+                /* Process sign */
+
+                do {
+                        ++format;
+                        if (*format == '#') {
+                                type |= ACPI_FORMAT_PREFIX;
+                        } else if (*format == '0') {
+                                type |= ACPI_FORMAT_ZERO;
+                        } else if (*format == '+') {
+                                type |= ACPI_FORMAT_SIGN_PLUS;
+                        } else if (*format == ' ') {
+                                type |= ACPI_FORMAT_SIGN_PLUS_SPACE;
+                        } else if (*format == '-') {
+                                type |= ACPI_FORMAT_LEFT;
+                        } else {
+                                break;
+                        }
+                } while (1);
+
+                /* Process width */
+
+                if (ACPI_IS_DIGIT(*format)) {
+                        format = acpi_ut_scan_number(format, &number);
+                        width = (s32) number;
+                } else if (*format == '*') {
+                        ++format;
+                        width = va_arg(args, int);
+                        if (width < 0) {
+                                width = -width;
+                                type |= ACPI_FORMAT_LEFT;
+                        }
+                }
+
+                /* Process precision */
+
+                if (*format == '.') {
+                        ++format;
+                        if (ACPI_IS_DIGIT(*format)) {
+                                format = acpi_ut_scan_number(format, &number);
+                                precision = (s32) number;
+                        } else if (*format == '*') {
+                                ++format;
+                                precision = va_arg(args, int);
+                        }
+                        if (precision < 0) {
+                                precision = 0;
+                        }
+                }
+
+                /* Process qualifier */
+
+                if (*format == 'h' || *format == 'l' || *format == 'L') {
+                        qualifier = *format;
+                        ++format;
+                        if (qualifier == 'l' && *format == 'l') {
+                                qualifier = 'L';
+                                ++format;
+                        }
+                }
+
+                switch (*format) {
+                case '%':
+
+                        pos = acpi_ut_bound_string_output(pos, end, '%');
+                        continue;
+
+                case 'c':
+
+                        if (!(type & ACPI_FORMAT_LEFT)) {
+                                while (--width > 0) {
+                                        pos =
+                                            acpi_ut_bound_string_output(pos,
+                                                                        end,
+                                                                        ' ');
+                                }
+                        }
+                        c = (char)va_arg(args, int);
+                        pos = acpi_ut_bound_string_output(pos, end, c);
+                        while (--width > 0) {
+                                pos =
+                                    acpi_ut_bound_string_output(pos, end, ' ');
+                        }
+                        continue;
+
+                case 's':
+
+                        s = va_arg(args, char *);
+                        if (!s) {
+                                s = "<NULL>";
+                        }
+                        length = acpi_ut_bound_string_length(s, precision);
+                        if (!(type & ACPI_FORMAT_LEFT)) {
+                                while (length < width--) {
+                                        pos =
+                                            acpi_ut_bound_string_output(pos,
+                                                                        end,
+                                                                        ' ');
+                                }
+                        }
+                        for (i = 0; i < length; ++i) {
+                                pos = acpi_ut_bound_string_output(pos, end, *s);
+                                ++s;
+                        }
+                        while (length < width--) {
+                                pos =
+                                    acpi_ut_bound_string_output(pos, end, ' ');
+                        }
+                        continue;
+
+                case 'o':
+
+                        base = 8;
+                        break;
+
+                case 'X':
+
+                        type |= ACPI_FORMAT_UPPER;
+
+                case 'x':
+
+                        base = 16;
+                        break;
+
+                case 'd':
+                case 'i':
+
+                        type |= ACPI_FORMAT_SIGN;
+
+                case 'u':
+
+                        break;
+
+                case 'p':
+
+                        if (width == -1) {
+                                width = 2 * sizeof(void *);
+                                type |= ACPI_FORMAT_ZERO;
+                        }
+                        p = va_arg(args, void *);
+                        pos = acpi_ut_format_number(pos, end,
+                                                    ACPI_TO_INTEGER(p),
+                                                    16, width, precision, type);
+                        continue;
+
+                default:
+
+                        pos = acpi_ut_bound_string_output(pos, end, '%');
+                        if (*format) {
+                                pos =
+                                    acpi_ut_bound_string_output(pos, end,
+                                                                *format);
+                        } else {
+                                --format;
+                        }
+                        continue;
+                }
+
+                if (qualifier == 'L') {
+                        number = va_arg(args, u64);
+                        if (type & ACPI_FORMAT_SIGN) {
+                                number = (s64) number;
+                        }
+                } else if (qualifier == 'l') {
+                        number = va_arg(args, unsigned long);
+                        if (type & ACPI_FORMAT_SIGN) {
+                                number = (s32) number;
+                        }
+                } else if (qualifier == 'h') {
+                        number = (u16)va_arg(args, int);
+                        if (type & ACPI_FORMAT_SIGN) {
+                                number = (s16) number;
+                        }
+                } else {
+                        number = va_arg(args, unsigned int);
+                        if (type & ACPI_FORMAT_SIGN) {
+                                number = (signed int)number;
+                        }
+                }
+                pos = acpi_ut_format_number(pos, end, number, base,
+                                            width, precision, type);
+        }
+
+        if (size > 0) {
+                if (pos < end) {
+                        *pos = '\0';
+                } else {
+                        end[-1] = '\0';
+                }
+        }
+
+        return (ACPI_PTR_DIFF(pos, string));
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_snprintf
+ *
+ * PARAMETERS:  string              - String with boundary
+ *              size                - Boundary of the string
+ *              Format, ...         - Standard printf format
+ *
+ * RETURN:      Size of successfully output bytes
+ *
+ * DESCRIPTION: Formatted output to a string.
+ *
+ ******************************************************************************/
+
+int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...)
+{
+        va_list args;
+        int length;
+
+        va_start(args, format);
+        length = acpi_ut_vsnprintf(string, size, format, args);
+        va_end(args);
+
+        return (length);
+}
+
+#ifdef ACPI_APPLICATION
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_file_vprintf
+ *
+ * PARAMETERS:  file                - File descriptor
+ *              format              - Standard printf format
+ *              args                - Argument list
+ *
+ * RETURN:      Size of successfully output bytes
+ *
+ * DESCRIPTION: Formatted output to a file using argument list pointer.
+ *
+ ******************************************************************************/
+
+int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args)
+{
+        acpi_cpu_flags flags;
+        int length;
+
+        flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
+        length = acpi_ut_vsnprintf(acpi_gbl_print_buffer,
+                                   sizeof(acpi_gbl_print_buffer), format, args);
+        (void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1);
+        acpi_os_release_lock(acpi_gbl_print_lock, flags);
+
+        return (length);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_file_printf
+ *
+ * PARAMETERS:  file                - File descriptor
+ *              Format, ...         - Standard printf format
+ *
+ * RETURN:      Size of successfully output bytes
+ *
+ * DESCRIPTION: Formatted output to a file.
+ *
+ ******************************************************************************/
+
+int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...)
+{
+        va_list args;
+        int length;
+
+        va_start(args, format);
+        length = acpi_ut_file_vprintf(file, format, args);
+        va_end(args);
+
+        return (length);
+}
+#endif
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 5480209b4254..165abcae5548 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -126,6 +126,7 @@
 typedef unsigned char u8;
 typedef unsigned char u8;
 typedef unsigned short u16;
+typedef short s16;
 typedef COMPILER_DEPENDENT_UINT64 u64;
 typedef COMPILER_DEPENDENT_INT64 s64;
 
diff --git a/tools/power/acpi/os_specific/service_layers/osunixxf.c b/tools/power/acpi/os_specific/service_layers/osunixxf.c
index 0e6a8a6be441..60b58cd18410 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixxf.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixxf.c
@@ -182,10 +182,17 @@ static void os_exit_line_edit_mode(void)
 
 acpi_status acpi_os_initialize(void)
 {
+        acpi_status status;
 
         acpi_gbl_output_file = stdout;
 
         os_enter_line_edit_mode();
+
+        status = acpi_os_create_lock(&acpi_gbl_print_lock);
+        if (ACPI_FAILURE(status)) {
+                return (status);
+        }
+
         return (AE_OK);
 }