[PATCH] ppc64: pSeries_progress -> rtas_progress

The pSeries_progress function is called from some places in the rtas code,
which may also be used by non-pSeries platforms.
Though pSeries is currently the only platform type that implements
display-character, the code is actually generic enough to be part of
the rtas subsystem.

I hit a bug here because the generic rtas code tried calling ppc_md.progress,
which points to an __init function on most platforms.

We could also clear the ppc_md.progress pointer when freeing the init memory
to make it more explicit that ppc_md.progress must not be called after
bootup.

Signed-off-by: Arnd Bergmann <arndb@de.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>

1 files changed, 104 insertions, 2 deletions

diff --git a/arch/ppc64/kernel/rtas.c b/arch/ppc64/kernel/rtas.c
index 5575603def27..43e1518653d5 100644
--- a/arch/ppc64/kernel/rtas.c
+++ b/arch/ppc64/kernel/rtas.c
@@ -91,6 +91,108 @@ call_rtas_display_status_delay(unsigned char c)
         }
 }
 
+void
+rtas_progress(char *s, unsigned short hex)
+{
+        struct device_node *root;
+        int width, *p;
+        char *os;
+        static int display_character, set_indicator;
+        static int max_width;
+        static DEFINE_SPINLOCK(progress_lock);
+        static int pending_newline = 0;  /* did last write end with unprinted newline? */
+
+        if (!rtas.base)
+                return;
+
+        if (max_width == 0) {
+                if ((root = find_path_device("/rtas")) &&
+                     (p = (unsigned int *)get_property(root,
+                                                       "ibm,display-line-length",
+                                                       NULL)))
+                        max_width = *p;
+                else
+                        max_width = 0x10;
+                display_character = rtas_token("display-character");
+                set_indicator = rtas_token("set-indicator");
+        }
+
+        if (display_character == RTAS_UNKNOWN_SERVICE) {
+                /* use hex display if available */
+                if (set_indicator != RTAS_UNKNOWN_SERVICE)
+                        rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
+                return;
+        }
+
+        spin_lock(&progress_lock);
+
+        /*
+         * Last write ended with newline, but we didn't print it since
+         * it would just clear the bottom line of output. Print it now
+         * instead.
+         *
+         * If no newline is pending, print a CR to start output at the
+         * beginning of the line.
+         */
+        if (pending_newline) {
+                rtas_call(display_character, 1, 1, NULL, '\r');
+                rtas_call(display_character, 1, 1, NULL, '\n');
+                pending_newline = 0;
+        } else {
+                rtas_call(display_character, 1, 1, NULL, '\r');
+        }
+ 
+        width = max_width;
+        os = s;
+        while (*os) {
+                if (*os == '\n' || *os == '\r') {
+                        /* Blank to end of line. */
+                        while (width-- > 0)
+                                rtas_call(display_character, 1, 1, NULL, ' ');
+ 
+                        /* If newline is the last character, save it
+                         * until next call to avoid bumping up the
+                         * display output.
+                         */
+                        if (*os == '\n' && !os[1]) {
+                                pending_newline = 1;
+                                spin_unlock(&progress_lock);
+                                return;
+                        }
+ 
+                        /* RTAS wants CR-LF, not just LF */
+ 
+                        if (*os == '\n') {
+                                rtas_call(display_character, 1, 1, NULL, '\r');
+                                rtas_call(display_character, 1, 1, NULL, '\n');
+                        } else {
+                                /* CR might be used to re-draw a line, so we'll
+                                 * leave it alone and not add LF.
+                                 */
+                                rtas_call(display_character, 1, 1, NULL, *os);
+                        }
+ 
+                        width = max_width;
+                } else {
+                        width--;
+                        rtas_call(display_character, 1, 1, NULL, *os);
+                }
+ 
+                os++;
+ 
+                /* if we overwrite the screen length */
+                if (width <= 0)
+                        while ((*os != 0) && (*os != '\n') && (*os != '\r'))
+                                os++;
+        }
+ 
+        /* Blank to end of line. */
+        while (width-- > 0)
+                rtas_call(display_character, 1, 1, NULL, ' ');
+
+        spin_unlock(&progress_lock);
+}
+
 int
 rtas_token(const char *service)
 {
@@ -425,8 +527,8 @@ rtas_flash_firmware(void)
 
         printk(KERN_ALERT "FLASH: flash image is %ld bytes\n", image_size);
         printk(KERN_ALERT "FLASH: performing flash and reboot\n");
-        ppc_md.progress("Flashing        \n", 0x0);
-        ppc_md.progress("Please Wait...  ", 0x0);
+        rtas_progress("Flashing        \n", 0x0);
+        rtas_progress("Please Wait...  ", 0x0);
         printk(KERN_ALERT "FLASH: this will take several minutes.  Do not power off!\n");
         status = rtas_call(update_token, 1, 1, NULL, rtas_block_list);
         switch (status) {       /* should only get "bad" status */