common/console.c

   1 /*
   2  * (C) Copyright 2000
   3  * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <common.h>
  25 #include <stdarg.h>
  26 #include <malloc.h>
  27 #include <console.h>
  28 #include <exports.h>
  29
  30 DECLARE_GLOBAL_DATA_PTR;
  31
  32 #ifdef CONFIG_AMIGAONEG3SE
  33 int console_changed = 0;
  34 #endif
  35
  36 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV
  37 /*
  38  * if overwrite_console returns 1, the stdin, stderr and stdout
  39  * are switched to the serial port, else the settings in the
  40  * environment are used
  41  */
  42 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
  43 extern int overwrite_console (void);
  44 #define OVERWRITE_CONSOLE overwrite_console ()
  45 #else
  46 #define OVERWRITE_CONSOLE 0
  47 #endif /* CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE */
  48
  49 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */
  50
  51 static int console_setfile (int file, device_t * dev)
  52 {
  53         int error = 0;
  54
  55         if (dev == NULL)
  56                 return -1;
  57
  58         switch (file) {
  59         case stdin:
  60         case stdout:
  61         case stderr:
  62                 /* Start new device */
  63                 if (dev->start) {
  64                         error = dev->start ();
  65                         /* If it's not started dont use it */
  66                         if (error < 0)
  67                                 break;
  68                 }
  69
  70                 /* Assign the new device (leaving the existing one started) */
  71                 stdio_devices[file] = dev;
  72
  73                 /*
  74                  * Update monitor functions
  75                  * (to use the console stuff by other applications)
  76                  */
  77                 switch (file) {
  78                 case stdin:
  79                         gd->jt[XF_getc] = dev->getc;
  80                         gd->jt[XF_tstc] = dev->tstc;
  81                         break;
  82                 case stdout:
  83                         gd->jt[XF_putc] = dev->putc;
  84                         gd->jt[XF_puts] = dev->puts;
  85                         gd->jt[XF_printf] = printf;
  86                         break;
  87                 }
  88                 break;
  89
  90         default:                /* Invalid file ID */
  91                 error = -1;
  92         }
  93         return error;
  94 }
  95
  96 #if defined(CONFIG_CONSOLE_MUX)
  97 /** Console I/O multiplexing *******************************************/
  98
  99 static device_t *tstcdev;
 100 device_t **console_devices[MAX_FILES];
 101 int cd_count[MAX_FILES];
 102
 103 /*
 104  * This depends on tstc() always being called before getc().
 105  * This is guaranteed to be true because this routine is called
 106  * only from fgetc() which assures it.
 107  * No attempt is made to demultiplex multiple input sources.
 108  */
 109 static int iomux_getc(void)
 110 {
 111         unsigned char ret;
 112
 113         /* This is never called with testcdev == NULL */
 114         ret = tstcdev->getc();
 115         tstcdev = NULL;
 116         return ret;
 117 }
 118
 119 static int iomux_tstc(int file)
 120 {
 121         int i, ret;
 122         device_t *dev;
 123
 124         disable_ctrlc(1);
 125         for (i = 0; i < cd_count[file]; i++) {
 126                 dev = console_devices[file][i];
 127                 if (dev->tstc != NULL) {
 128                         ret = dev->tstc();
 129                         if (ret > 0) {
 130                                 tstcdev = dev;
 131                                 disable_ctrlc(0);
 132                                 return ret;
 133                         }
 134                 }
 135         }
 136         disable_ctrlc(0);
 137
 138         return 0;
 139 }
 140
 141 static void iomux_putc(int file, const char c)
 142 {
 143         int i;
 144         device_t *dev;
 145
 146         for (i = 0; i < cd_count[file]; i++) {
 147                 dev = console_devices[file][i];
 148                 if (dev->putc != NULL)
 149                         dev->putc(c);
 150         }
 151 }
 152
 153 static void iomux_puts(int file, const char *s)
 154 {
 155         int i;
 156         device_t *dev;
 157
 158         for (i = 0; i < cd_count[file]; i++) {
 159                 dev = console_devices[file][i];
 160                 if (dev->puts != NULL)
 161                         dev->puts(s);
 162         }
 163 }
 164 #endif /* defined(CONFIG_CONSOLE_MUX) */
 165
 166 /** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
 167
 168 void serial_printf (const char *fmt, ...)
 169 {
 170         va_list args;
 171         uint i;
 172         char printbuffer[CONFIG_SYS_PBSIZE];
 173
 174         va_start (args, fmt);
 175
 176         /* For this to work, printbuffer must be larger than
 177          * anything we ever want to print.
 178          */
 179         i = vsprintf (printbuffer, fmt, args);
 180         va_end (args);
 181
 182         serial_puts (printbuffer);
 183 }
 184
 185 int fgetc (int file)
 186 {
 187         if (file < MAX_FILES) {
 188 #if defined(CONFIG_CONSOLE_MUX)
 189                 /*
 190                  * Effectively poll for input wherever it may be available.
 191                  */
 192                 for (;;) {
 193                         /*
 194                          * Upper layer may have already called tstc() so
 195                          * check for that first.
 196                          */
 197                         if (tstcdev != NULL)
 198                                 return iomux_getc();
 199                         iomux_tstc(file);
 200 #ifdef CONFIG_WATCHDOG
 201                         /*
 202                          * If the watchdog must be rate-limited then it should
 203                          * already be handled in board-specific code.
 204                          */
 205                          udelay(1);
 206 #endif
 207                 }
 208 #else
 209                 return stdio_devices[file]->getc ();
 210 #endif
 211         }
 212
 213         return -1;
 214 }
 215
 216 int ftstc (int file)
 217 {
 218         if (file < MAX_FILES)
 219 #if defined(CONFIG_CONSOLE_MUX)
 220                 return iomux_tstc(file);
 221 #else
 222                 return stdio_devices[file]->tstc ();
 223 #endif
 224
 225         return -1;
 226 }
 227
 228 void fputc (int file, const char c)
 229 {
 230         if (file < MAX_FILES)
 231 #if defined(CONFIG_CONSOLE_MUX)
 232                 iomux_putc(file, c);
 233 #else
 234                 stdio_devices[file]->putc (c);
 235 #endif
 236 }
 237
 238 void fputs (int file, const char *s)
 239 {
 240         if (file < MAX_FILES)
 241 #if defined(CONFIG_CONSOLE_MUX)
 242                 iomux_puts(file, s);
 243 #else
 244                 stdio_devices[file]->puts (s);
 245 #endif
 246 }
 247
 248 void fprintf (int file, const char *fmt, ...)
 249 {
 250         va_list args;
 251         uint i;
 252         char printbuffer[CONFIG_SYS_PBSIZE];
 253
 254         va_start (args, fmt);
 255
 256         /* For this to work, printbuffer must be larger than
 257          * anything we ever want to print.
 258          */
 259         i = vsprintf (printbuffer, fmt, args);
 260         va_end (args);
 261
 262         /* Send to desired file */
 263         fputs (file, printbuffer);
 264 }
 265
 266 /** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
 267
 268 int getc (void)
 269 {
 270 #ifdef CONFIG_DISABLE_CONSOLE
 271         if (gd->flags & GD_FLG_DISABLE_CONSOLE)
 272                 return 0;
 273 #endif
 274
 275         if (gd->flags & GD_FLG_DEVINIT) {
 276                 /* Get from the standard input */
 277                 return fgetc (stdin);
 278         }
 279
 280         /* Send directly to the handler */
 281         return serial_getc ();
 282 }
 283
 284 int tstc (void)
 285 {
 286 #ifdef CONFIG_DISABLE_CONSOLE
 287         if (gd->flags & GD_FLG_DISABLE_CONSOLE)
 288                 return 0;
 289 #endif
 290
 291         if (gd->flags & GD_FLG_DEVINIT) {
 292                 /* Test the standard input */
 293                 return ftstc (stdin);
 294         }
 295
 296         /* Send directly to the handler */
 297         return serial_tstc ();
 298 }
 299
 300 void putc (const char c)
 301 {
 302 #ifdef CONFIG_SILENT_CONSOLE
 303         if (gd->flags & GD_FLG_SILENT)
 304                 return;
 305 #endif
 306
 307 #ifdef CONFIG_DISABLE_CONSOLE
 308         if (gd->flags & GD_FLG_DISABLE_CONSOLE)
 309                 return;
 310 #endif
 311
 312         if (gd->flags & GD_FLG_DEVINIT) {
 313                 /* Send to the standard output */
 314                 fputc (stdout, c);
 315         } else {
 316                 /* Send directly to the handler */
 317                 serial_putc (c);
 318         }
 319 }
 320
 321 void puts (const char *s)
 322 {
 323 #ifdef CONFIG_SILENT_CONSOLE
 324         if (gd->flags & GD_FLG_SILENT)
 325                 return;
 326 #endif
 327
 328 #ifdef CONFIG_DISABLE_CONSOLE
 329         if (gd->flags & GD_FLG_DISABLE_CONSOLE)
 330                 return;
 331 #endif
 332
 333         if (gd->flags & GD_FLG_DEVINIT) {
 334                 /* Send to the standard output */
 335                 fputs (stdout, s);
 336         } else {
 337                 /* Send directly to the handler */
 338                 serial_puts (s);
 339         }
 340 }
 341
 342 void printf (const char *fmt, ...)
 343 {
 344         va_list args;
 345         uint i;
 346         char printbuffer[CONFIG_SYS_PBSIZE];
 347
 348         va_start (args, fmt);
 349
 350         /* For this to work, printbuffer must be larger than
 351          * anything we ever want to print.
 352          */
 353         i = vsprintf (printbuffer, fmt, args);
 354         va_end (args);
 355
 356         /* Print the string */
 357         puts (printbuffer);
 358 }
 359
 360 void vprintf (const char *fmt, va_list args)
 361 {
 362         uint i;
 363         char printbuffer[CONFIG_SYS_PBSIZE];
 364
 365         /* For this to work, printbuffer must be larger than
 366          * anything we ever want to print.
 367          */
 368         i = vsprintf (printbuffer, fmt, args);
 369
 370         /* Print the string */
 371         puts (printbuffer);
 372 }
 373
 374 /* test if ctrl-c was pressed */
 375 static int ctrlc_disabled = 0;  /* see disable_ctrl() */
 376 static int ctrlc_was_pressed = 0;
 377 int ctrlc (void)
 378 {
 379         if (!ctrlc_disabled && gd->have_console) {
 380                 if (tstc ()) {
 381                         switch (getc ()) {
 382                         case 0x03:              /* ^C - Control C */
 383                                 ctrlc_was_pressed = 1;
 384                                 return 1;
 385                         default:
 386                                 break;
 387                         }
 388                 }
 389         }
 390         return 0;
 391 }
 392
 393 /* pass 1 to disable ctrlc() checking, 0 to enable.
 394  * returns previous state
 395  */
 396 int disable_ctrlc (int disable)
 397 {
 398         int prev = ctrlc_disabled;      /* save previous state */
 399
 400         ctrlc_disabled = disable;
 401         return prev;
 402 }
 403
 404 int had_ctrlc (void)
 405 {
 406         return ctrlc_was_pressed;
 407 }
 408
 409 void clear_ctrlc (void)
 410 {
 411         ctrlc_was_pressed = 0;
 412 }
 413
 414 #ifdef CONFIG_MODEM_SUPPORT_DEBUG
 415 char    screen[1024];
 416 char *cursor = screen;
 417 int once = 0;
 418 inline void dbg(const char *fmt, ...)
 419 {
 420         va_list args;
 421         uint    i;
 422         char    printbuffer[CONFIG_SYS_PBSIZE];
 423
 424         if (!once) {
 425                 memset(screen, 0, sizeof(screen));
 426                 once++;
 427         }
 428
 429         va_start(args, fmt);
 430
 431         /* For this to work, printbuffer must be larger than
 432          * anything we ever want to print.
 433          */
 434         i = vsprintf(printbuffer, fmt, args);
 435         va_end(args);
 436
 437         if ((screen + sizeof(screen) - 1 - cursor) < strlen(printbuffer)+1) {
 438                 memset(screen, 0, sizeof(screen));
 439                 cursor = screen;
 440         }
 441         sprintf(cursor, printbuffer);
 442         cursor += strlen(printbuffer);
 443
 444 }
 445 #else
 446 inline void dbg(const char *fmt, ...)
 447 {
 448 }
 449 #endif
 450
 451 /** U-Boot INIT FUNCTIONS *************************************************/
 452
 453 device_t *search_device (int flags, char *name)
 454 {
 455         device_t *dev;
 456
 457         dev = device_get_by_name(name);
 458
 459         if(dev && (dev->flags & flags))
 460                 return dev;
 461
 462         return NULL;
 463 }
 464
 465 int console_assign (int file, char *devname)
 466 {
 467         int flag;
 468         device_t *dev;
 469
 470         /* Check for valid file */
 471         switch (file) {
 472         case stdin:
 473                 flag = DEV_FLAGS_INPUT;
 474                 break;
 475         case stdout:
 476         case stderr:
 477                 flag = DEV_FLAGS_OUTPUT;
 478                 break;
 479         default:
 480                 return -1;
 481         }
 482
 483         /* Check for valid device name */
 484
 485         dev = search_device(flag, devname);
 486
 487         if(dev)
 488                 return console_setfile (file, dev);
 489
 490         return -1;
 491 }
 492
 493 /* Called before relocation - use serial functions */
 494 int console_init_f (void)
 495 {
 496         gd->have_console = 1;
 497
 498 #ifdef CONFIG_SILENT_CONSOLE
 499         if (getenv("silent") != NULL)
 500                 gd->flags |= GD_FLG_SILENT;
 501 #endif
 502
 503         return (0);
 504 }
 505
 506 #ifdef CONFIG_SYS_CONSOLE_IS_IN_ENV
 507 /* Called after the relocation - use desired console functions */
 508 int console_init_r (void)
 509 {
 510         char *stdinname, *stdoutname, *stderrname;
 511         device_t *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
 512 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
 513         int i;
 514 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */
 515 #ifdef CONFIG_CONSOLE_MUX
 516         int iomux_err = 0;
 517 #endif
 518
 519         /* set default handlers at first */
 520         gd->jt[XF_getc] = serial_getc;
 521         gd->jt[XF_tstc] = serial_tstc;
 522         gd->jt[XF_putc] = serial_putc;
 523         gd->jt[XF_puts] = serial_puts;
 524         gd->jt[XF_printf] = serial_printf;
 525
 526         /* stdin stdout and stderr are in environment */
 527         /* scan for it */
 528         stdinname  = getenv ("stdin");
 529         stdoutname = getenv ("stdout");
 530         stderrname = getenv ("stderr");
 531
 532         if (OVERWRITE_CONSOLE == 0) {   /* if not overwritten by config switch */
 533                 inputdev  = search_device (DEV_FLAGS_INPUT,  stdinname);
 534                 outputdev = search_device (DEV_FLAGS_OUTPUT, stdoutname);
 535                 errdev    = search_device (DEV_FLAGS_OUTPUT, stderrname);
 536 #ifdef CONFIG_CONSOLE_MUX
 537                 iomux_err = iomux_doenv(stdin, stdinname);
 538                 iomux_err += iomux_doenv(stdout, stdoutname);
 539                 iomux_err += iomux_doenv(stderr, stderrname);
 540                 if (!iomux_err)
 541                         /* Successful, so skip all the code below. */
 542                         goto done;
 543 #endif
 544         }
 545         /* if the devices are overwritten or not found, use default device */
 546         if (inputdev == NULL) {
 547                 inputdev  = search_device (DEV_FLAGS_INPUT,  "serial");
 548         }
 549         if (outputdev == NULL) {
 550                 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
 551         }
 552         if (errdev == NULL) {
 553                 errdev    = search_device (DEV_FLAGS_OUTPUT, "serial");
 554         }
 555         /* Initializes output console first */
 556         if (outputdev != NULL) {
 557 #ifdef CONFIG_CONSOLE_MUX
 558                 /* need to set a console if not done above. */
 559                 iomux_doenv(stdout, outputdev->name);
 560 #else
 561                 console_setfile (stdout, outputdev);
 562 #endif
 563         }
 564         if (errdev != NULL) {
 565 #ifdef CONFIG_CONSOLE_MUX
 566                 /* need to set a console if not done above. */
 567                 iomux_doenv(stderr, errdev->name);
 568 #else
 569                 console_setfile (stderr, errdev);
 570 #endif
 571         }
 572         if (inputdev != NULL) {
 573 #ifdef CONFIG_CONSOLE_MUX
 574                 /* need to set a console if not done above. */
 575                 iomux_doenv(stdin, inputdev->name);
 576 #else
 577                 console_setfile (stdin, inputdev);
 578 #endif
 579         }
 580
 581 #ifdef CONFIG_CONSOLE_MUX
 582 done:
 583 #endif
 584
 585         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
 586
 587 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
 588         /* Print information */
 589         puts ("In:    ");
 590         if (stdio_devices[stdin] == NULL) {
 591                 puts ("No input devices available!\n");
 592         } else {
 593 #ifdef CONFIG_CONSOLE_MUX
 594                 iomux_printdevs(stdin);
 595 #else
 596                 printf ("%s\n", stdio_devices[stdin]->name);
 597 #endif
 598         }
 599
 600         puts ("Out:   ");
 601         if (stdio_devices[stdout] == NULL) {
 602                 puts ("No output devices available!\n");
 603         } else {
 604 #ifdef CONFIG_CONSOLE_MUX
 605                 iomux_printdevs(stdout);
 606 #else
 607                 printf ("%s\n", stdio_devices[stdout]->name);
 608 #endif
 609         }
 610
 611         puts ("Err:   ");
 612         if (stdio_devices[stderr] == NULL) {
 613                 puts ("No error devices available!\n");
 614         } else {
 615 #ifdef CONFIG_CONSOLE_MUX
 616                 iomux_printdevs(stderr);
 617 #else
 618                 printf ("%s\n", stdio_devices[stderr]->name);
 619 #endif
 620         }
 621 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */
 622
 623 #ifdef CONFIG_SYS_CONSOLE_ENV_OVERWRITE
 624         /* set the environment variables (will overwrite previous env settings) */
 625         for (i = 0; i < 3; i++) {
 626                 setenv (stdio_names[i], stdio_devices[i]->name);
 627         }
 628 #endif /* CONFIG_SYS_CONSOLE_ENV_OVERWRITE */
 629
 630 #if 0
 631         /* If nothing usable installed, use only the initial console */
 632         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
 633                 return (0);
 634 #endif
 635         return (0);
 636 }
 637
 638 #else /* CONFIG_SYS_CONSOLE_IS_IN_ENV */
 639
 640 /* Called after the relocation - use desired console functions */
 641 int console_init_r (void)
 642 {
 643         device_t *inputdev = NULL, *outputdev = NULL;
 644         int i;
 645         struct list_head *list = device_get_list();
 646         struct list_head *pos;
 647         device_t *dev;
 648
 649 #ifdef CONFIG_SPLASH_SCREEN
 650         /* suppress all output if splash screen is enabled and we have
 651            a bmp to display                                            */
 652         if (getenv("splashimage") != NULL)
 653                 gd->flags |= GD_FLG_SILENT;
 654 #endif
 655
 656         /* Scan devices looking for input and output devices */
 657         list_for_each(pos, list) {
 658                 dev = list_entry(pos, device_t, list);
 659
 660                 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
 661                         inputdev = dev;
 662                 }
 663                 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
 664                         outputdev = dev;
 665                 }
 666                 if(inputdev && outputdev)
 667                         break;
 668         }
 669
 670         /* Initializes output console first */
 671         if (outputdev != NULL) {
 672                 console_setfile (stdout, outputdev);
 673                 console_setfile (stderr, outputdev);
 674 #ifdef CONFIG_CONSOLE_MUX
 675                 console_devices[stdout][0] = outputdev;
 676                 console_devices[stderr][0] = outputdev;
 677 #endif
 678         }
 679
 680         /* Initializes input console */
 681         if (inputdev != NULL) {
 682                 console_setfile (stdin, inputdev);
 683 #ifdef CONFIG_CONSOLE_MUX
 684                 console_devices[stdin][0] = inputdev;
 685 #endif
 686         }
 687
 688         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
 689
 690 #ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
 691         /* Print information */
 692         puts ("In:    ");
 693         if (stdio_devices[stdin] == NULL) {
 694                 puts ("No input devices available!\n");
 695         } else {
 696                 printf ("%s\n", stdio_devices[stdin]->name);
 697         }
 698
 699         puts ("Out:   ");
 700         if (stdio_devices[stdout] == NULL) {
 701                 puts ("No output devices available!\n");
 702         } else {
 703                 printf ("%s\n", stdio_devices[stdout]->name);
 704         }
 705
 706         puts ("Err:   ");
 707         if (stdio_devices[stderr] == NULL) {
 708                 puts ("No error devices available!\n");
 709         } else {
 710                 printf ("%s\n", stdio_devices[stderr]->name);
 711         }
 712 #endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */
 713
 714         /* Setting environment variables */
 715         for (i = 0; i < 3; i++) {
 716                 setenv (stdio_names[i], stdio_devices[i]->name);
 717         }
 718
 719 #if 0
 720         /* If nothing usable installed, use only the initial console */
 721         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
 722                 return (0);
 723 #endif
 724
 725         return (0);
 726 }
 727
 728 #endif /* CONFIG_SYS_CONSOLE_IS_IN_ENV */