// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 1996-2005 Paul Mackerras.
 */
#include <linux/string.h>
#include <asm/udbg.h>
#include <asm/time.h>
#include "nonstdio.h"

static bool paginating, paginate_skipping;
static unsigned long paginate_lpp; /* Lines Per Page */
static unsigned long paginate_pos;

void xmon_start_pagination(void)
{
 paginating = true;
 paginate_skipping = false;
 paginate_pos = 0;
}

void xmon_end_pagination(void)
{
 paginating = false;
}

void xmon_set_pagination_lpp(unsigned long lpp)
{
 paginate_lpp = lpp;
}

static int xmon_readchar(void)
{
 if (udbg_getc)
  return udbg_getc();
 return -1;
}

static int xmon_write(const char *ptr, int nb)
{
 int rv = 0;
 const char *p = ptr, *q;
 const char msg[] = "[Hit a key (a:all, q:truncate, any:next page)]";

 if (nb <= 0)
  return rv;

 if (paginating && paginate_skipping)
  return nb;

 if (paginate_lpp) {
  while (paginating && (q = strchr(p, '\n'))) {
   rv += udbg_write(p, q - p + 1);
   p = q + 1;
   paginate_pos++;

   if (paginate_pos >= paginate_lpp) {
    udbg_write(msg, strlen(msg));

    switch (xmon_readchar()) {
    case 'a':
     paginating = false;
     break;
    case 'q':
     paginate_skipping = true;
     break;
    default:
     /* nothing */
     break;
    }

    paginate_pos = 0;
    udbg_write("\r\n", 2);

    if (paginate_skipping)
     return nb;
   }
  }
 }

 return rv + udbg_write(p, nb - (p - ptr));
}

int xmon_putchar(int c)
{
 char ch = c;

 if (c == '\n')
  xmon_putchar('\r');
 return xmon_write(&ch, 1) == 1? c: -1;
}

static char line[256];
static char *lineptr;
static int lineleft;

static int xmon_getchar(void)
{
 int c;

 if (lineleft == 0) {
  lineptr = line;
  for (;;) {
   c = xmon_readchar();
   if (c == -1 || c == 4)
    break;
   if (c == '\r' || c == '\n') {
    *lineptr++ = '\n';
    xmon_putchar('\n');
    break;
   }
   switch (c) {
   case 0177:
   case '\b':
    if (lineptr > line) {
     xmon_putchar('\b');
     xmon_putchar(' ');
     xmon_putchar('\b');
     --lineptr;
    }
    break;
   case 'U' & 0x1F:
    while (lineptr > line) {
     xmon_putchar('\b');
     xmon_putchar(' ');
     xmon_putchar('\b');
     --lineptr;
    }
    break;
   default:
    if (lineptr >= &line[sizeof(line) - 1])
     xmon_putchar('\a');
    else {
     xmon_putchar(c);
     *lineptr++ = c;
    }
   }
  }
  lineleft = lineptr - line;
  lineptr = line;
 }
 if (lineleft == 0)
  return -1;
 --lineleft;
 return *lineptr++;
}

char *xmon_gets(char *str, int nb)
{
 char *p;
 int c;

 for (p = str; p < str + nb - 1; ) {
  c = xmon_getchar();
  if (c == -1) {
   if (p == str)
    return NULL;
   break;
  }
  *p++ = c;
  if (c == '\n')
   break;
 }
 *p = 0;
 return str;
}

void xmon_printf(const char *format, ...)
{
 va_list args;
 static char xmon_outbuf[1024];
 int rc, n;

 va_start(args, format);
 n = vsnprintf(xmon_outbuf, sizeof(xmon_outbuf), format, args);
 va_end(args);

 rc = xmon_write(xmon_outbuf, n);

 if (n && rc == 0) {
  /* No udbg hooks, fallback to printk() - dangerous */
  pr_cont("%s", xmon_outbuf);
 }
}

void xmon_puts(const char *str)
{
 xmon_write(str, strlen(str));
}