common/console.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000
   4  * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), [email protected]
   5  */
   6
   7 #define LOG_CATEGORY    LOGC_CONSOLE
   8
   9 #include <console.h>
  10 #include <debug_uart.h>
  11 #include <display_options.h>
  12 #include <dm.h>
  13 #include <env.h>
  14 #include <stdarg.h>
  15 #include <iomux.h>
  16 #include <malloc.h>
  17 #include <mapmem.h>
  18 #include <os.h>
  19 #include <serial.h>
  20 #include <stdio_dev.h>
  21 #include <exports.h>
  22 #include <env_internal.h>
  23 #include <video_console.h>
  24 #include <watchdog.h>
  25 #include <asm/global_data.h>
  26 #include <linux/delay.h>
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 #define CSI "\x1b["
  31
  32 static int on_console(const char *name, const char *value, enum env_op op,
  33         int flags)
  34 {
  35         int console = -1;
  36
  37         /* Check for console redirection */
  38         if (strcmp(name, "stdin") == 0)
  39                 console = stdin;
  40         else if (strcmp(name, "stdout") == 0)
  41                 console = stdout;
  42         else if (strcmp(name, "stderr") == 0)
  43                 console = stderr;
  44
  45         /* if not actually setting a console variable, we don't care */
  46         if (console == -1 || (gd->flags & GD_FLG_DEVINIT) == 0)
  47                 return 0;
  48
  49         switch (op) {
  50         case env_op_create:
  51         case env_op_overwrite:
  52
  53                 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
  54                         if (iomux_doenv(console, value))
  55                                 return 1;
  56                 } else {
  57                         /* Try assigning specified device */
  58                         if (console_assign(console, value) < 0)
  59                                 return 1;
  60                 }
  61
  62                 return 0;
  63
  64         case env_op_delete:
  65                 if ((flags & H_FORCE) == 0)
  66                         printf("Can't delete \"%s\"\n", name);
  67                 return 1;
  68
  69         default:
  70                 return 0;
  71         }
  72 }
  73 U_BOOT_ENV_CALLBACK(console, on_console);
  74
  75 #ifdef CONFIG_SILENT_CONSOLE
  76 static int on_silent(const char *name, const char *value, enum env_op op,
  77         int flags)
  78 {
  79         if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_SET))
  80                 if (flags & H_INTERACTIVE)
  81                         return 0;
  82
  83         if (!CONFIG_IS_ENABLED(SILENT_CONSOLE_UPDATE_ON_RELOC))
  84                 if ((flags & H_INTERACTIVE) == 0)
  85                         return 0;
  86
  87         if (value != NULL)
  88                 gd->flags |= GD_FLG_SILENT;
  89         else
  90                 gd->flags &= ~GD_FLG_SILENT;
  91
  92         return 0;
  93 }
  94 U_BOOT_ENV_CALLBACK(silent, on_silent);
  95 #endif
  96
  97 #ifdef CONFIG_CONSOLE_RECORD
  98 /* helper function: access to gd->console_out and gd->console_in */
  99 static void console_record_putc(const char c)
 100 {
 101         if (!(gd->flags & GD_FLG_RECORD))
 102                 return;
 103         if  (gd->console_out.start &&
 104              !membuff_putbyte((struct membuff *)&gd->console_out, c))
 105                 gd->flags |= GD_FLG_RECORD_OVF;
 106 }
 107
 108 static void console_record_puts(const char *s)
 109 {
 110         if (!(gd->flags & GD_FLG_RECORD))
 111                 return;
 112         if  (gd->console_out.start) {
 113                 int len = strlen(s);
 114
 115                 if (membuff_put((struct membuff *)&gd->console_out, s, len) !=
 116                     len)
 117                         gd->flags |= GD_FLG_RECORD_OVF;
 118         }
 119 }
 120
 121 static int console_record_getc(void)
 122 {
 123         if (!(gd->flags & GD_FLG_RECORD))
 124                 return -1;
 125         if (!gd->console_in.start)
 126                 return -1;
 127
 128         return membuff_getbyte((struct membuff *)&gd->console_in);
 129 }
 130
 131 static int console_record_tstc(void)
 132 {
 133         if (!(gd->flags & GD_FLG_RECORD))
 134                 return 0;
 135         if (gd->console_in.start) {
 136                 if (membuff_peekbyte((struct membuff *)&gd->console_in) != -1)
 137                         return 1;
 138         }
 139         return 0;
 140 }
 141 #else
 142 static void console_record_putc(char c)
 143 {
 144 }
 145
 146 static void console_record_puts(const char *s)
 147 {
 148 }
 149
 150 static int console_record_getc(void)
 151 {
 152         return -1;
 153 }
 154
 155 static int console_record_tstc(void)
 156 {
 157         return 0;
 158 }
 159 #endif
 160
 161 #if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
 162 /*
 163  * if overwrite_console returns 1, the stdin, stderr and stdout
 164  * are switched to the serial port, else the settings in the
 165  * environment are used
 166  */
 167 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
 168 extern int overwrite_console(void);
 169 #define OVERWRITE_CONSOLE overwrite_console()
 170 #else
 171 #define OVERWRITE_CONSOLE 0
 172 #endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
 173
 174 #endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
 175
 176 static int console_setfile(int file, struct stdio_dev * dev)
 177 {
 178         int error = 0;
 179
 180         if (dev == NULL)
 181                 return -1;
 182
 183         switch (file) {
 184         case stdin:
 185         case stdout:
 186         case stderr:
 187                 error = console_start(file, dev);
 188                 if (error)
 189                         break;
 190
 191                 /* Assign the new device (leaving the existing one started) */
 192                 stdio_devices[file] = dev;
 193
 194 #ifndef CONFIG_XPL_BUILD
 195                 /*
 196                  * Update monitor functions
 197                  * (to use the console stuff by other applications)
 198                  */
 199                 switch (file) {
 200                 case stdin:
 201                         gd->jt->getc = getchar;
 202                         gd->jt->tstc = tstc;
 203                         break;
 204                 case stdout:
 205                         gd->jt->putc  = putc;
 206                         gd->jt->puts  = puts;
 207                         STDIO_DEV_ASSIGN_FLUSH(gd->jt, flush);
 208                         gd->jt->printf = printf;
 209                         break;
 210                 }
 211                 break;
 212 #endif
 213         default:                /* Invalid file ID */
 214                 error = -1;
 215         }
 216         return error;
 217 }
 218
 219 /**
 220  * console_dev_is_serial() - Check if a stdio device is a serial device
 221  *
 222  * @sdev: Device to check
 223  * Return: true if this device is in the serial uclass (or for pre-driver-model,
 224  * whether it is called "serial".
 225  */
 226 static bool console_dev_is_serial(struct stdio_dev *sdev)
 227 {
 228         bool is_serial;
 229
 230         if (IS_ENABLED(CONFIG_DM_SERIAL) && (sdev->flags & DEV_FLAGS_DM)) {
 231                 struct udevice *dev = sdev->priv;
 232
 233                 is_serial = device_get_uclass_id(dev) == UCLASS_SERIAL;
 234         } else {
 235                 is_serial = !strcmp(sdev->name, "serial");
 236         }
 237
 238         return is_serial;
 239 }
 240
 241 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
 242 /** Console I/O multiplexing *******************************************/
 243
 244 /* tstcdev: save the last stdio device with pending characters, with tstc != 0 */
 245 static struct stdio_dev *tstcdev;
 246 struct stdio_dev **console_devices[MAX_FILES];
 247 int cd_count[MAX_FILES];
 248
 249 static void console_devices_set(int file, struct stdio_dev *dev)
 250 {
 251         console_devices[file][0] = dev;
 252         cd_count[file] = 1;
 253 }
 254
 255 /**
 256  * console_needs_start_stop() - check if we need to start or stop the STDIO device
 257  * @file: STDIO file
 258  * @sdev: STDIO device in question
 259  *
 260  * This function checks if we need to start or stop the stdio device used for
 261  * a console. For IOMUX case it simply enforces one time start and one time
 262  * stop of the device independently of how many STDIO files are using it. In
 263  * other words, we start console once before first STDIO device wants it and
 264  * stop after the last is gone.
 265  */
 266 static bool console_needs_start_stop(int file, struct stdio_dev *sdev)
 267 {
 268         int i;
 269
 270         for (i = 0; i < ARRAY_SIZE(cd_count); i++) {
 271                 if (i == file)
 272                         continue;
 273
 274                 if (iomux_match_device(console_devices[i], cd_count[i], sdev) >= 0)
 275                         return false;
 276         }
 277         return true;
 278 }
 279
 280 /*
 281  * This depends on tstc() always being called before getchar().
 282  * This is guaranteed to be true because this routine is called
 283  * only from fgetc() which assures it.
 284  * No attempt is made to demultiplex multiple input sources.
 285  */
 286 static int console_getc(int file)
 287 {
 288         unsigned char ret;
 289
 290         /* This is never called with testcdev == NULL */
 291         ret = tstcdev->getc(tstcdev);
 292         tstcdev = NULL;
 293         return ret;
 294 }
 295
 296 /*  Upper layer may have already called tstc(): check the saved result */
 297 static bool console_has_tstc(void)
 298 {
 299         return !!tstcdev;
 300 }
 301
 302 static int console_tstc(int file)
 303 {
 304         int i, ret;
 305         struct stdio_dev *dev;
 306         int prev;
 307
 308         prev = disable_ctrlc(1);
 309         for_each_console_dev(i, file, dev) {
 310                 if (dev->tstc != NULL) {
 311                         ret = dev->tstc(dev);
 312                         if (ret > 0) {
 313                                 tstcdev = dev;
 314                                 disable_ctrlc(prev);
 315                                 return ret;
 316                         }
 317                 }
 318         }
 319         disable_ctrlc(prev);
 320
 321         return 0;
 322 }
 323
 324 static void console_putc(int file, const char c)
 325 {
 326         int i;
 327         struct stdio_dev *dev;
 328
 329         for_each_console_dev(i, file, dev) {
 330                 if (dev->putc != NULL)
 331                         dev->putc(dev, c);
 332         }
 333 }
 334
 335 /**
 336  * console_puts_select() - Output a string to all console devices
 337  *
 338  * @file: File number to output to (e,g, stdout, see stdio.h)
 339  * @serial_only: true to output only to serial, false to output to everything
 340  *      else
 341  * @s: String to output
 342  */
 343 static void console_puts_select(int file, bool serial_only, const char *s)
 344 {
 345         int i;
 346         struct stdio_dev *dev;
 347
 348         for_each_console_dev(i, file, dev) {
 349                 bool is_serial = console_dev_is_serial(dev);
 350
 351                 if (dev->puts && serial_only == is_serial)
 352                         dev->puts(dev, s);
 353         }
 354 }
 355
 356 void console_puts_select_stderr(bool serial_only, const char *s)
 357 {
 358         if (gd->flags & GD_FLG_DEVINIT)
 359                 console_puts_select(stderr, serial_only, s);
 360 }
 361
 362 static void console_puts(int file, const char *s)
 363 {
 364         int i;
 365         struct stdio_dev *dev;
 366
 367         for_each_console_dev(i, file, dev) {
 368                 if (dev->puts != NULL)
 369                         dev->puts(dev, s);
 370         }
 371 }
 372
 373 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 374 static void console_flush(int file)
 375 {
 376         int i;
 377         struct stdio_dev *dev;
 378
 379         for_each_console_dev(i, file, dev) {
 380                 if (dev->flush != NULL)
 381                         dev->flush(dev);
 382         }
 383 }
 384 #endif
 385
 386 #if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
 387 static inline void console_doenv(int file, struct stdio_dev *dev)
 388 {
 389         iomux_doenv(file, dev->name);
 390 }
 391 #endif
 392 #else
 393
 394 static void console_devices_set(int file, struct stdio_dev *dev)
 395 {
 396 }
 397
 398 static inline bool console_needs_start_stop(int file, struct stdio_dev *sdev)
 399 {
 400         return true;
 401 }
 402
 403 static inline int console_getc(int file)
 404 {
 405         return stdio_devices[file]->getc(stdio_devices[file]);
 406 }
 407
 408 static bool console_has_tstc(void)
 409 {
 410         return false;
 411 }
 412
 413 static inline int console_tstc(int file)
 414 {
 415         return stdio_devices[file]->tstc(stdio_devices[file]);
 416 }
 417
 418 static inline void console_putc(int file, const char c)
 419 {
 420         stdio_devices[file]->putc(stdio_devices[file], c);
 421 }
 422
 423 void console_puts_select(int file, bool serial_only, const char *s)
 424 {
 425         if ((gd->flags & GD_FLG_DEVINIT) &&
 426             serial_only == console_dev_is_serial(stdio_devices[file]))
 427                 stdio_devices[file]->puts(stdio_devices[file], s);
 428 }
 429
 430 static inline void console_puts(int file, const char *s)
 431 {
 432         stdio_devices[file]->puts(stdio_devices[file], s);
 433 }
 434
 435 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 436 static inline void console_flush(int file)
 437 {
 438         if (stdio_devices[file]->flush)
 439                 stdio_devices[file]->flush(stdio_devices[file]);
 440 }
 441 #endif
 442
 443 #if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
 444 static inline void console_doenv(int file, struct stdio_dev *dev)
 445 {
 446         console_setfile(file, dev);
 447 }
 448 #endif
 449 #endif /* CONIFIG_IS_ENABLED(CONSOLE_MUX) */
 450
 451 static void __maybe_unused console_setfile_and_devices(int file, struct stdio_dev *dev)
 452 {
 453         console_setfile(file, dev);
 454         console_devices_set(file, dev);
 455 }
 456
 457 int console_start(int file, struct stdio_dev *sdev)
 458 {
 459         int error;
 460
 461         if (!console_needs_start_stop(file, sdev))
 462                 return 0;
 463
 464         /* Start new device */
 465         if (sdev->start) {
 466                 error = sdev->start(sdev);
 467                 /* If it's not started don't use it */
 468                 if (error < 0)
 469                         return error;
 470         }
 471         return 0;
 472 }
 473
 474 void console_stop(int file, struct stdio_dev *sdev)
 475 {
 476         if (!console_needs_start_stop(file, sdev))
 477                 return;
 478
 479         if (sdev->stop)
 480                 sdev->stop(sdev);
 481 }
 482
 483 /** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
 484
 485 int serial_printf(const char *fmt, ...)
 486 {
 487         va_list args;
 488         uint i;
 489         char printbuffer[CONFIG_SYS_PBSIZE];
 490
 491         va_start(args, fmt);
 492
 493         /* For this to work, printbuffer must be larger than
 494          * anything we ever want to print.
 495          */
 496         i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
 497         va_end(args);
 498
 499         serial_puts(printbuffer);
 500         return i;
 501 }
 502
 503 int fgetc(int file)
 504 {
 505         if ((unsigned int)file < MAX_FILES) {
 506                 /*
 507                  * Effectively poll for input wherever it may be available.
 508                  */
 509                 for (;;) {
 510                         schedule();
 511                         if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
 512                                 /*
 513                                  * Upper layer may have already called tstc() so
 514                                  * check for that first.
 515                                  */
 516                                 if (console_has_tstc())
 517                                         return console_getc(file);
 518                                 console_tstc(file);
 519                         } else {
 520                                 if (console_tstc(file))
 521                                         return console_getc(file);
 522                         }
 523
 524                         /*
 525                          * If the watchdog must be rate-limited then it should
 526                          * already be handled in board-specific code.
 527                          */
 528                         if (IS_ENABLED(CONFIG_WATCHDOG))
 529                                 udelay(1);
 530                 }
 531         }
 532
 533         return -1;
 534 }
 535
 536 int ftstc(int file)
 537 {
 538         if ((unsigned int)file < MAX_FILES)
 539                 return console_tstc(file);
 540
 541         return -1;
 542 }
 543
 544 void fputc(int file, const char c)
 545 {
 546         if ((unsigned int)file < MAX_FILES)
 547                 console_putc(file, c);
 548 }
 549
 550 void fputs(int file, const char *s)
 551 {
 552         if ((unsigned int)file < MAX_FILES)
 553                 console_puts(file, s);
 554 }
 555
 556 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 557 void fflush(int file)
 558 {
 559         if ((unsigned int)file < MAX_FILES)
 560                 console_flush(file);
 561 }
 562 #endif
 563
 564 int fprintf(int file, const char *fmt, ...)
 565 {
 566         va_list args;
 567         uint i;
 568         char printbuffer[CONFIG_SYS_PBSIZE];
 569
 570         va_start(args, fmt);
 571
 572         /* For this to work, printbuffer must be larger than
 573          * anything we ever want to print.
 574          */
 575         i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
 576         va_end(args);
 577
 578         /* Send to desired file */
 579         fputs(file, printbuffer);
 580         return i;
 581 }
 582
 583 /** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
 584
 585 int getchar(void)
 586 {
 587         int ch;
 588
 589         if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
 590                 return 0;
 591
 592         if (!(gd->flags & GD_FLG_HAVE_CONSOLE))
 593                 return 0;
 594
 595         ch = console_record_getc();
 596         if (ch != -1)
 597                 return ch;
 598
 599         if (gd->flags & GD_FLG_DEVINIT) {
 600                 /* Get from the standard input */
 601                 return fgetc(stdin);
 602         }
 603
 604         /* Send directly to the handler */
 605         return serial_getc();
 606 }
 607
 608 int tstc(void)
 609 {
 610         if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
 611                 return 0;
 612
 613         if (!(gd->flags & GD_FLG_HAVE_CONSOLE))
 614                 return 0;
 615
 616         if (console_record_tstc())
 617                 return 1;
 618
 619         if (gd->flags & GD_FLG_DEVINIT) {
 620                 /* Test the standard input */
 621                 return ftstc(stdin);
 622         }
 623
 624         /* Send directly to the handler */
 625         return serial_tstc();
 626 }
 627
 628 #define PRE_CONSOLE_FLUSHPOINT1_SERIAL                  0
 629 #define PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL   1
 630
 631 #if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
 632 #define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_VAL(PRE_CON_BUF_SZ))
 633
 634 static void pre_console_putc(const char c)
 635 {
 636         char *buffer;
 637
 638         if (gd->precon_buf_idx < 0)
 639                 return;
 640
 641         buffer = map_sysmem(CONFIG_VAL(PRE_CON_BUF_ADDR), CONFIG_VAL(PRE_CON_BUF_SZ));
 642
 643         buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c;
 644
 645         unmap_sysmem(buffer);
 646 }
 647
 648 static void pre_console_puts(const char *s)
 649 {
 650         if (gd->precon_buf_idx < 0)
 651                 return;
 652
 653         while (*s)
 654                 pre_console_putc(*s++);
 655 }
 656
 657 static void print_pre_console_buffer(int flushpoint)
 658 {
 659         long in = 0, out = 0;
 660         char buf_out[CONFIG_VAL(PRE_CON_BUF_SZ) + 1];
 661         char *buf_in;
 662
 663         if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
 664                 return;
 665
 666         buf_in = map_sysmem(CONFIG_VAL(PRE_CON_BUF_ADDR), CONFIG_VAL(PRE_CON_BUF_SZ));
 667         if (gd->precon_buf_idx > CONFIG_VAL(PRE_CON_BUF_SZ))
 668                 in = gd->precon_buf_idx - CONFIG_VAL(PRE_CON_BUF_SZ);
 669
 670         while (in < gd->precon_buf_idx)
 671                 buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];
 672         unmap_sysmem(buf_in);
 673
 674         buf_out[out] = 0;
 675
 676         gd->precon_buf_idx = -1;
 677         switch (flushpoint) {
 678         case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
 679                 puts(buf_out);
 680                 break;
 681         case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
 682                 console_puts_select(stdout, false, buf_out);
 683                 break;
 684         }
 685         gd->precon_buf_idx = in;
 686 }
 687 #else
 688 static inline void pre_console_putc(const char c) {}
 689 static inline void pre_console_puts(const char *s) {}
 690 static inline void print_pre_console_buffer(int flushpoint) {}
 691 #endif
 692
 693 void putc(const char c)
 694 {
 695         if (!gd)
 696                 return;
 697
 698         console_record_putc(c);
 699
 700         /* sandbox can send characters to stdout before it has a console */
 701         if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
 702                 os_putc(c);
 703                 return;
 704         }
 705
 706         /* if we don't have a console yet, use the debug UART */
 707         if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
 708                 printch(c);
 709                 return;
 710         }
 711
 712         if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
 713                 if (!(gd->flags & GD_FLG_DEVINIT))
 714                         pre_console_putc(c);
 715                 return;
 716         }
 717
 718         if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
 719                 return;
 720
 721         if (!(gd->flags & GD_FLG_HAVE_CONSOLE))
 722                 return pre_console_putc(c);
 723
 724         if (gd->flags & GD_FLG_DEVINIT) {
 725                 /* Send to the standard output */
 726                 fputc(stdout, c);
 727         } else {
 728                 /* Send directly to the handler */
 729                 pre_console_putc(c);
 730                 serial_putc(c);
 731         }
 732 }
 733
 734 void puts(const char *s)
 735 {
 736         if (!gd)
 737                 return;
 738
 739         console_record_puts(s);
 740
 741         /* sandbox can send characters to stdout before it has a console */
 742         if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
 743                 os_puts(s);
 744                 return;
 745         }
 746
 747         if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
 748                 while (*s) {
 749                         int ch = *s++;
 750
 751                         printch(ch);
 752                 }
 753                 return;
 754         }
 755
 756         if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT)) {
 757                 if (!(gd->flags & GD_FLG_DEVINIT))
 758                         pre_console_puts(s);
 759                 return;
 760         }
 761
 762         if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
 763                 return;
 764
 765         if (!(gd->flags & GD_FLG_HAVE_CONSOLE))
 766                 return pre_console_puts(s);
 767
 768         if (gd->flags & GD_FLG_DEVINIT) {
 769                 /* Send to the standard output */
 770                 fputs(stdout, s);
 771         } else {
 772                 /* Send directly to the handler */
 773                 pre_console_puts(s);
 774                 serial_puts(s);
 775         }
 776 }
 777
 778 #ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
 779 void flush(void)
 780 {
 781         if (!gd)
 782                 return;
 783
 784         /* sandbox can send characters to stdout before it has a console */
 785         if (IS_ENABLED(CONFIG_SANDBOX) && !(gd->flags & GD_FLG_SERIAL_READY)) {
 786                 os_flush();
 787                 return;
 788         }
 789
 790         if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY))
 791                 return;
 792
 793         if (IS_ENABLED(CONFIG_SILENT_CONSOLE) && (gd->flags & GD_FLG_SILENT))
 794                 return;
 795
 796         if (IS_ENABLED(CONFIG_DISABLE_CONSOLE) && (gd->flags & GD_FLG_DISABLE_CONSOLE))
 797                 return;
 798
 799         if (!(gd->flags & GD_FLG_HAVE_CONSOLE))
 800                 return;
 801
 802         if (gd->flags & GD_FLG_DEVINIT) {
 803                 /* Send to the standard output */
 804                 fflush(stdout);
 805         } else {
 806                 /* Send directly to the handler */
 807                 serial_flush();
 808         }
 809 }
 810 #endif
 811
 812 #ifdef CONFIG_CONSOLE_RECORD
 813 int console_record_init(void)
 814 {
 815         int ret;
 816
 817         ret = membuff_new((struct membuff *)&gd->console_out,
 818                           gd->flags & GD_FLG_RELOC ?
 819                                   CONFIG_CONSOLE_RECORD_OUT_SIZE :
 820                                   CONFIG_CONSOLE_RECORD_OUT_SIZE_F);
 821         if (ret)
 822                 return ret;
 823         ret = membuff_new((struct membuff *)&gd->console_in,
 824                           CONFIG_CONSOLE_RECORD_IN_SIZE);
 825
 826         /* Start recording from the beginning */
 827         gd->flags |= GD_FLG_RECORD;
 828
 829         return ret;
 830 }
 831
 832 void console_record_reset(void)
 833 {
 834         membuff_purge((struct membuff *)&gd->console_out);
 835         membuff_purge((struct membuff *)&gd->console_in);
 836         gd->flags &= ~GD_FLG_RECORD_OVF;
 837 }
 838
 839 int console_record_reset_enable(void)
 840 {
 841         console_record_reset();
 842         gd->flags |= GD_FLG_RECORD;
 843
 844         return 0;
 845 }
 846
 847 int console_record_readline(char *str, int maxlen)
 848 {
 849         if (gd->flags & GD_FLG_RECORD_OVF)
 850                 return -ENOSPC;
 851         if (console_record_isempty())
 852                 return -ENOENT;
 853
 854         return membuff_readline((struct membuff *)&gd->console_out, str,
 855                                 maxlen, '\0', false);
 856 }
 857
 858 int console_record_avail(void)
 859 {
 860         return membuff_avail((struct membuff *)&gd->console_out);
 861 }
 862
 863 bool console_record_isempty(void)
 864 {
 865         return membuff_isempty((struct membuff *)&gd->console_out);
 866 }
 867
 868 int console_in_puts(const char *str)
 869 {
 870         return membuff_put((struct membuff *)&gd->console_in, str, strlen(str));
 871 }
 872
 873 #endif
 874
 875 /* test if ctrl-c was pressed */
 876 static int ctrlc_disabled = 0;  /* see disable_ctrl() */
 877 static int ctrlc_was_pressed = 0;
 878 int ctrlc(void)
 879 {
 880         if (!ctrlc_disabled && (gd->flags & GD_FLG_HAVE_CONSOLE)) {
 881                 if (tstc()) {
 882                         switch (getchar()) {
 883                         case 0x03:              /* ^C - Control C */
 884                                 ctrlc_was_pressed = 1;
 885                                 return 1;
 886                         default:
 887                                 break;
 888                         }
 889                 }
 890         }
 891
 892         return 0;
 893 }
 894 /* Reads user's confirmation.
 895    Returns 1 if user's input is "y", "Y", "yes" or "YES"
 896 */
 897 int confirm_yesno(void)
 898 {
 899         int i;
 900         char str_input[5];
 901
 902         /* Flush input */
 903         while (tstc())
 904                 getchar();
 905         i = 0;
 906         while (i < sizeof(str_input)) {
 907                 str_input[i] = getchar();
 908                 putc(str_input[i]);
 909                 if (str_input[i] == '\r')
 910                         break;
 911                 i++;
 912         }
 913         putc('\n');
 914         if (strncmp(str_input, "y\r", 2) == 0 ||
 915             strncmp(str_input, "Y\r", 2) == 0 ||
 916             strncmp(str_input, "yes\r", 4) == 0 ||
 917             strncmp(str_input, "YES\r", 4) == 0)
 918                 return 1;
 919         return 0;
 920 }
 921 /* pass 1 to disable ctrlc() checking, 0 to enable.
 922  * returns previous state
 923  */
 924 int disable_ctrlc(int disable)
 925 {
 926         int prev = ctrlc_disabled;      /* save previous state */
 927
 928         ctrlc_disabled = disable;
 929         return prev;
 930 }
 931
 932 int had_ctrlc (void)
 933 {
 934         return ctrlc_was_pressed;
 935 }
 936
 937 void clear_ctrlc(void)
 938 {
 939         ctrlc_was_pressed = 0;
 940 }
 941
 942 /** U-Boot INIT FUNCTIONS *************************************************/
 943
 944 struct stdio_dev *console_search_dev(int flags, const char *name)
 945 {
 946         struct stdio_dev *dev;
 947
 948         dev = stdio_get_by_name(name);
 949 #ifdef CONFIG_VIDCONSOLE_AS_LCD
 950         if (!dev && !strcmp(name, CONFIG_VIDCONSOLE_AS_NAME))
 951                 dev = stdio_get_by_name("vidconsole");
 952 #endif
 953
 954         if (dev && (dev->flags & flags))
 955                 return dev;
 956
 957         return NULL;
 958 }
 959
 960 int console_assign(int file, const char *devname)
 961 {
 962         int flag;
 963         struct stdio_dev *dev;
 964
 965         /* Check for valid file */
 966         flag = stdio_file_to_flags(file);
 967         if (flag < 0)
 968                 return flag;
 969
 970         /* Check for valid device name */
 971
 972         dev = console_search_dev(flag, devname);
 973
 974         if (dev)
 975                 return console_setfile(file, dev);
 976
 977         return -1;
 978 }
 979
 980 /* return true if the 'silent' flag is removed */
 981 static bool console_update_silent(void)
 982 {
 983         unsigned long flags = gd->flags;
 984
 985         if (!IS_ENABLED(CONFIG_SILENT_CONSOLE))
 986                 return false;
 987
 988         if (IS_ENABLED(CONFIG_SILENT_CONSOLE_UNTIL_ENV) && !(gd->flags & GD_FLG_ENV_READY)) {
 989                 gd->flags |= GD_FLG_SILENT;
 990                 return false;
 991         }
 992
 993         if (env_get("silent")) {
 994                 gd->flags |= GD_FLG_SILENT;
 995                 return false;
 996         }
 997
 998         gd->flags &= ~GD_FLG_SILENT;
 999
1000         return !!(flags & GD_FLG_SILENT);
1001 }
1002
1003 int console_announce_r(void)
1004 {
1005 #if !CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
1006         char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
1007
1008         display_options_get_banner(false, buf, sizeof(buf));
1009
1010         console_puts_select(stdout, false, buf);
1011 #endif
1012
1013         return 0;
1014 }
1015
1016 /* Called before relocation - use serial functions */
1017 int console_init_f(void)
1018 {
1019         gd->flags |= GD_FLG_HAVE_CONSOLE;
1020
1021         console_update_silent();
1022
1023         print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL);
1024
1025         return 0;
1026 }
1027
1028 int console_clear(void)
1029 {
1030         /*
1031          * Send clear screen and home
1032          *
1033          * FIXME(Heinrich Schuchardt <[email protected]>): This should go
1034          * through an API and only be written to serial terminals, not video
1035          * displays
1036          */
1037         printf(CSI "2J" CSI "1;1H");
1038         if (IS_ENABLED(CONFIG_VIDEO_ANSI))
1039                 return 0;
1040
1041         if (IS_ENABLED(CONFIG_VIDEO)) {
1042                 struct udevice *dev;
1043                 int ret;
1044
1045                 ret = uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev);
1046                 if (ret)
1047                         return ret;
1048                 ret = vidconsole_clear_and_reset(dev);
1049                 if (ret)
1050                         return ret;
1051         }
1052
1053         return 0;
1054 }
1055
1056 static char *get_stdio(const u8 std)
1057 {
1058         return stdio_devices[std] ? stdio_devices[std]->name : "No devices available!";
1059 }
1060
1061 static void stdio_print_current_devices(void)
1062 {
1063         char *stdinname = NULL;
1064         char *stdoutname = NULL;
1065         char *stderrname = NULL;
1066
1067         if (CONFIG_IS_ENABLED(CONSOLE_MUX) &&
1068             CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)) {
1069                 /* stdin stdout and stderr are in environment */
1070                 stdinname  = env_get("stdin");
1071                 stdoutname = env_get("stdout");
1072                 stderrname = env_get("stderr");
1073         }
1074
1075         stdinname = stdinname ? : get_stdio(stdin);
1076         stdoutname = stdoutname ? : get_stdio(stdout);
1077         stderrname = stderrname ? : get_stdio(stderr);
1078
1079         /* Print information */
1080         puts("In:    ");
1081         printf("%s\n", stdinname);
1082
1083         puts("Out:   ");
1084         printf("%s\n", stdoutname);
1085
1086         puts("Err:   ");
1087         printf("%s\n", stderrname);
1088 }
1089
1090 #if CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV)
1091 /* Called after the relocation - use desired console functions */
1092 int console_init_r(void)
1093 {
1094         char *stdinname, *stdoutname, *stderrname;
1095         struct stdio_dev *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
1096         int i;
1097         int iomux_err = 0;
1098         int flushpoint;
1099
1100         /* update silent for env loaded from flash (initr_env) */
1101         if (console_update_silent())
1102                 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1103         else
1104                 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
1105
1106         /* set default handlers at first */
1107         gd->jt->getc  = serial_getc;
1108         gd->jt->tstc  = serial_tstc;
1109         gd->jt->putc  = serial_putc;
1110         gd->jt->puts  = serial_puts;
1111         gd->jt->printf = serial_printf;
1112
1113         /* stdin stdout and stderr are in environment */
1114         /* scan for it */
1115         stdinname  = env_get("stdin");
1116         stdoutname = env_get("stdout");
1117         stderrname = env_get("stderr");
1118
1119         if (OVERWRITE_CONSOLE == 0) {   /* if not overwritten by config switch */
1120                 inputdev  = console_search_dev(DEV_FLAGS_INPUT,  stdinname);
1121                 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, stdoutname);
1122                 errdev    = console_search_dev(DEV_FLAGS_OUTPUT, stderrname);
1123                 if (CONFIG_IS_ENABLED(CONSOLE_MUX)) {
1124                         iomux_err = iomux_doenv(stdin, stdinname);
1125                         iomux_err += iomux_doenv(stdout, stdoutname);
1126                         iomux_err += iomux_doenv(stderr, stderrname);
1127                         if (!iomux_err)
1128                                 /* Successful, so skip all the code below. */
1129                                 goto done;
1130                 }
1131         }
1132         /* if the devices are overwritten or not found, use default device */
1133         if (inputdev == NULL) {
1134                 inputdev  = console_search_dev(DEV_FLAGS_INPUT,  "serial");
1135         }
1136         if (outputdev == NULL) {
1137                 outputdev = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
1138         }
1139         if (errdev == NULL) {
1140                 errdev    = console_search_dev(DEV_FLAGS_OUTPUT, "serial");
1141         }
1142         /* Initializes output console first */
1143         if (outputdev != NULL) {
1144                 /* need to set a console if not done above. */
1145                 console_doenv(stdout, outputdev);
1146         }
1147         if (errdev != NULL) {
1148                 /* need to set a console if not done above. */
1149                 console_doenv(stderr, errdev);
1150         }
1151         if (inputdev != NULL) {
1152                 /* need to set a console if not done above. */
1153                 console_doenv(stdin, inputdev);
1154         }
1155
1156 done:
1157
1158         if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1159                 stdio_print_current_devices();
1160
1161 #ifdef CONFIG_VIDCONSOLE_AS_LCD
1162         if (strstr(stdoutname, CONFIG_VIDCONSOLE_AS_NAME))
1163                 printf("Warning: Please change '%s' to 'vidconsole' in stdout/stderr environment vars\n",
1164                        CONFIG_VIDCONSOLE_AS_NAME);
1165 #endif
1166
1167         if (IS_ENABLED(CONFIG_SYS_CONSOLE_ENV_OVERWRITE)) {
1168                 /* set the environment variables (will overwrite previous env settings) */
1169                 for (i = 0; i < MAX_FILES; i++)
1170                         env_set(stdio_names[i], stdio_devices[i]->name);
1171         }
1172
1173         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
1174
1175         print_pre_console_buffer(flushpoint);
1176         return 0;
1177 }
1178
1179 #else /* !CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
1180
1181 /* Called after the relocation - use desired console functions */
1182 int console_init_r(void)
1183 {
1184         struct stdio_dev *inputdev = NULL, *outputdev = NULL;
1185         int i;
1186         struct list_head *list = stdio_get_list();
1187         struct list_head *pos;
1188         struct stdio_dev *dev;
1189         int flushpoint;
1190
1191         /* update silent for env loaded from flash (initr_env) */
1192         if (console_update_silent())
1193                 flushpoint = PRE_CONSOLE_FLUSHPOINT1_SERIAL;
1194         else
1195                 flushpoint = PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL;
1196
1197         /*
1198          * suppress all output if splash screen is enabled and we have
1199          * a bmp to display. We redirect the output from frame buffer
1200          * console to serial console in this case or suppress it if
1201          * "silent" mode was requested.
1202          */
1203         if (IS_ENABLED(CONFIG_SPLASH_SCREEN) && env_get("splashimage")) {
1204                 if (!(gd->flags & GD_FLG_SILENT))
1205                         outputdev = console_search_dev (DEV_FLAGS_OUTPUT, "serial");
1206         }
1207
1208         /* Scan devices looking for input and output devices */
1209         list_for_each(pos, list) {
1210                 dev = list_entry(pos, struct stdio_dev, list);
1211
1212                 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
1213                         inputdev = dev;
1214                 }
1215                 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
1216                         outputdev = dev;
1217                 }
1218                 if(inputdev && outputdev)
1219                         break;
1220         }
1221
1222         /* Initializes output console first */
1223         if (outputdev != NULL) {
1224                 console_setfile_and_devices(stdout, outputdev);
1225                 console_setfile_and_devices(stderr, outputdev);
1226         }
1227
1228         /* Initializes input console */
1229         if (inputdev != NULL)
1230                 console_setfile_and_devices(stdin, inputdev);
1231
1232         if (!IS_ENABLED(CONFIG_SYS_CONSOLE_INFO_QUIET))
1233                 stdio_print_current_devices();
1234
1235         /* Setting environment variables */
1236         for (i = 0; i < MAX_FILES; i++) {
1237                 env_set(stdio_names[i], stdio_devices[i]->name);
1238         }
1239
1240         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
1241
1242         print_pre_console_buffer(flushpoint);
1243         return 0;
1244 }
1245
1246 #endif /* CONFIG_IS_ENABLED(SYS_CONSOLE_IS_IN_ENV) */
1247
1248 int console_remove_by_name(const char *name)
1249 {
1250         int err = 0;
1251
1252 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
1253         int fnum;
1254
1255         log_debug("removing console device %s\n", name);
1256         for (fnum = 0; fnum < MAX_FILES; fnum++) {
1257                 struct stdio_dev **src, **dest;
1258                 int i;
1259
1260                 log_debug("file %d: %d devices: ", fnum, cd_count[fnum]);
1261                 src = console_devices[fnum];
1262                 dest = src;
1263                 for (i = 0; i < cd_count[fnum]; i++, src++) {
1264                         struct stdio_dev *sdev = *src;
1265                         int ret = 0;
1266
1267                         if (!strcmp(sdev->name, name))
1268                                 ret = stdio_deregister_dev(sdev, true);
1269                         else
1270                                 *dest++ = *src;
1271                         if (ret && !err)
1272                                 err = ret;
1273                 }
1274                 cd_count[fnum] = dest - console_devices[fnum];
1275                 log_debug("now %d\n", cd_count[fnum]);
1276         }
1277 #endif /* CONSOLE_MUX */
1278
1279         return err;
1280 }