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