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 #ifdef CONFIG_AMIGAONEG3SE
  31 int console_changed = 0;
  32 #endif
  33
  34 #ifdef CFG_CONSOLE_IS_IN_ENV
  35 /*
  36  * if overwrite_console returns 1, the stdin, stderr and stdout
  37  * are switched to the serial port, else the settings in the
  38  * environment are used
  39  */
  40 #ifdef CFG_CONSOLE_OVERWRITE_ROUTINE
  41 extern int overwrite_console (void);
  42 #else
  43 int overwrite_console (void)
  44 {
  45         return (0);
  46 }
  47 #endif /* CFG_CONSOLE_OVERWRITE_ROUTINE */
  48
  49 #endif /* CFG_CONSOLE_IS_IN_ENV */
  50
  51 static int console_setfile (int file, device_t * dev)
  52 {
  53         DECLARE_GLOBAL_DATA_PTR;
  54         int error = 0;
  55
  56         if (dev == NULL)
  57                 return -1;
  58
  59         switch (file) {
  60         case stdin:
  61         case stdout:
  62         case stderr:
  63                 /* Start new device */
  64                 if (dev->start) {
  65                         error = dev->start ();
  66                         /* If it's not started dont use it */
  67                         if (error < 0)
  68                                 break;
  69                 }
  70
  71                 /* Assign the new device (leaving the existing one started) */
  72                 stdio_devices[file] = dev;
  73
  74                 /*
  75                  * Update monitor functions
  76                  * (to use the console stuff by other applications)
  77                  */
  78                 switch (file) {
  79                 case stdin:
  80                         gd->jt[XF_getc] = dev->getc;
  81                         gd->jt[XF_tstc] = dev->tstc;
  82                         break;
  83                 case stdout:
  84                         gd->jt[XF_putc] = dev->putc;
  85                         gd->jt[XF_puts] = dev->puts;
  86                         gd->jt[XF_printf] = printf;
  87                         break;
  88                 }
  89                 break;
  90
  91         default:                /* Invalid file ID */
  92                 error = -1;
  93         }
  94         return error;
  95 }
  96
  97 /** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/
  98
  99 void serial_printf (const char *fmt, ...)
 100 {
 101         va_list args;
 102         uint i;
 103         char printbuffer[CFG_PBSIZE];
 104
 105         va_start (args, fmt);
 106
 107         /* For this to work, printbuffer must be larger than
 108          * anything we ever want to print.
 109          */
 110         i = vsprintf (printbuffer, fmt, args);
 111         va_end (args);
 112
 113         serial_puts (printbuffer);
 114 }
 115
 116 int fgetc (int file)
 117 {
 118         if (file < MAX_FILES)
 119                 return stdio_devices[file]->getc ();
 120
 121         return -1;
 122 }
 123
 124 int ftstc (int file)
 125 {
 126         if (file < MAX_FILES)
 127                 return stdio_devices[file]->tstc ();
 128
 129         return -1;
 130 }
 131
 132 void fputc (int file, const char c)
 133 {
 134         if (file < MAX_FILES)
 135                 stdio_devices[file]->putc (c);
 136 }
 137
 138 void fputs (int file, const char *s)
 139 {
 140         if (file < MAX_FILES)
 141                 stdio_devices[file]->puts (s);
 142 }
 143
 144 void fprintf (int file, const char *fmt, ...)
 145 {
 146         va_list args;
 147         uint i;
 148         char printbuffer[CFG_PBSIZE];
 149
 150         va_start (args, fmt);
 151
 152         /* For this to work, printbuffer must be larger than
 153          * anything we ever want to print.
 154          */
 155         i = vsprintf (printbuffer, fmt, args);
 156         va_end (args);
 157
 158         /* Send to desired file */
 159         fputs (file, printbuffer);
 160 }
 161
 162 /** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/
 163
 164 int getc (void)
 165 {
 166         DECLARE_GLOBAL_DATA_PTR;
 167
 168         if (gd->flags & GD_FLG_DEVINIT) {
 169                 /* Get from the standard input */
 170                 return fgetc (stdin);
 171         }
 172
 173         /* Send directly to the handler */
 174         return serial_getc ();
 175 }
 176
 177 int tstc (void)
 178 {
 179         DECLARE_GLOBAL_DATA_PTR;
 180
 181         if (gd->flags & GD_FLG_DEVINIT) {
 182                 /* Test the standard input */
 183                 return ftstc (stdin);
 184         }
 185
 186         /* Send directly to the handler */
 187         return serial_tstc ();
 188 }
 189
 190 void putc (const char c)
 191 {
 192         DECLARE_GLOBAL_DATA_PTR;
 193
 194 #ifdef CONFIG_SILENT_CONSOLE
 195         if (gd->flags & GD_FLG_SILENT)
 196                 return;
 197 #endif
 198
 199         if (gd->flags & GD_FLG_DEVINIT) {
 200                 /* Send to the standard output */
 201                 fputc (stdout, c);
 202         } else {
 203                 /* Send directly to the handler */
 204                 serial_putc (c);
 205         }
 206 }
 207
 208 void puts (const char *s)
 209 {
 210         DECLARE_GLOBAL_DATA_PTR;
 211
 212 #ifdef CONFIG_SILENT_CONSOLE
 213         if (gd->flags & GD_FLG_SILENT)
 214                 return;
 215 #endif
 216
 217         if (gd->flags & GD_FLG_DEVINIT) {
 218                 /* Send to the standard output */
 219                 fputs (stdout, s);
 220         } else {
 221                 /* Send directly to the handler */
 222                 serial_puts (s);
 223         }
 224 }
 225
 226 void printf (const char *fmt, ...)
 227 {
 228         va_list args;
 229         uint i;
 230         char printbuffer[CFG_PBSIZE];
 231
 232         va_start (args, fmt);
 233
 234         /* For this to work, printbuffer must be larger than
 235          * anything we ever want to print.
 236          */
 237         i = vsprintf (printbuffer, fmt, args);
 238         va_end (args);
 239
 240         /* Print the string */
 241         puts (printbuffer);
 242 }
 243
 244 void vprintf (const char *fmt, va_list args)
 245 {
 246         uint i;
 247         char printbuffer[CFG_PBSIZE];
 248
 249         /* For this to work, printbuffer must be larger than
 250          * anything we ever want to print.
 251          */
 252         i = vsprintf (printbuffer, fmt, args);
 253
 254         /* Print the string */
 255         puts (printbuffer);
 256 }
 257
 258 /* test if ctrl-c was pressed */
 259 static int ctrlc_disabled = 0;  /* see disable_ctrl() */
 260 static int ctrlc_was_pressed = 0;
 261 int ctrlc (void)
 262 {
 263         DECLARE_GLOBAL_DATA_PTR;
 264
 265         if (!ctrlc_disabled && gd->have_console) {
 266                 if (tstc ()) {
 267                         switch (getc ()) {
 268                         case 0x03:              /* ^C - Control C */
 269                                 ctrlc_was_pressed = 1;
 270                                 return 1;
 271                         default:
 272                                 break;
 273                         }
 274                 }
 275         }
 276         return 0;
 277 }
 278
 279 /* pass 1 to disable ctrlc() checking, 0 to enable.
 280  * returns previous state
 281  */
 282 int disable_ctrlc (int disable)
 283 {
 284         int prev = ctrlc_disabled;      /* save previous state */
 285
 286         ctrlc_disabled = disable;
 287         return prev;
 288 }
 289
 290 int had_ctrlc (void)
 291 {
 292         return ctrlc_was_pressed;
 293 }
 294
 295 void clear_ctrlc (void)
 296 {
 297         ctrlc_was_pressed = 0;
 298 }
 299
 300 #ifdef CONFIG_MODEM_SUPPORT_DEBUG
 301 char    screen[1024];
 302 char *cursor = screen;
 303 int once = 0;
 304 inline void dbg(const char *fmt, ...)
 305 {
 306         va_list args;
 307         uint    i;
 308         char    printbuffer[CFG_PBSIZE];
 309
 310         if (!once) {
 311                 memset(screen, 0, sizeof(screen));
 312                 once++;
 313         }
 314
 315         va_start(args, fmt);
 316
 317         /* For this to work, printbuffer must be larger than
 318          * anything we ever want to print.
 319          */
 320         i = vsprintf(printbuffer, fmt, args);
 321         va_end(args);
 322
 323         if ((screen + sizeof(screen) - 1 - cursor) < strlen(printbuffer)+1) {
 324                 memset(screen, 0, sizeof(screen));
 325                 cursor = screen;
 326         }
 327         sprintf(cursor, printbuffer);
 328         cursor += strlen(printbuffer);
 329
 330 }
 331 #else
 332 inline void dbg(const char *fmt, ...)
 333 {
 334 }
 335 #endif
 336
 337 /** U-Boot INIT FUNCTIONS *************************************************/
 338
 339 int console_assign (int file, char *devname)
 340 {
 341         int flag, i;
 342
 343         /* Check for valid file */
 344         switch (file) {
 345         case stdin:
 346                 flag = DEV_FLAGS_INPUT;
 347                 break;
 348         case stdout:
 349         case stderr:
 350                 flag = DEV_FLAGS_OUTPUT;
 351                 break;
 352         default:
 353                 return -1;
 354         }
 355
 356         /* Check for valid device name */
 357
 358         for (i = 1; i <= ListNumItems (devlist); i++) {
 359                 device_t *dev = ListGetPtrToItem (devlist, i);
 360
 361                 if (strcmp (devname, dev->name) == 0) {
 362                         if (dev->flags & flag)
 363                                 return console_setfile (file, dev);
 364
 365                         return -1;
 366                 }
 367         }
 368
 369         return -1;
 370 }
 371
 372 /* Called before relocation - use serial functions */
 373 int console_init_f (void)
 374 {
 375         DECLARE_GLOBAL_DATA_PTR;
 376
 377         gd->have_console = 1;
 378
 379 #ifdef CONFIG_SILENT_CONSOLE
 380         if (getenv("silent") != NULL)
 381                 gd->flags |= GD_FLG_SILENT;
 382 #endif
 383
 384         return (0);
 385 }
 386
 387 #if defined(CFG_CONSOLE_IS_IN_ENV) || defined(CONFIG_SPLASH_SCREEN) || defined(CONFIG_SILENT_CONSOLE)
 388 /* search a device */
 389 device_t *search_device (int flags, char *name)
 390 {
 391         int i, items;
 392         device_t *dev = NULL;
 393
 394         items = ListNumItems (devlist);
 395         if (name == NULL)
 396                 return dev;
 397
 398         for (i = 1; i <= items; i++) {
 399                 dev = ListGetPtrToItem (devlist, i);
 400                 if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) {
 401                         break;
 402                 }
 403         }
 404         return dev;
 405 }
 406 #endif /* CFG_CONSOLE_IS_IN_ENV || CONFIG_SPLASH_SCREEN */
 407
 408 #ifdef CFG_CONSOLE_IS_IN_ENV
 409 /* Called after the relocation - use desired console functions */
 410 int console_init_r (void)
 411 {
 412         DECLARE_GLOBAL_DATA_PTR;
 413         char *stdinname, *stdoutname, *stderrname;
 414         device_t *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
 415
 416         /* set default handlers at first */
 417         gd->jt[XF_getc] = serial_getc;
 418         gd->jt[XF_tstc] = serial_tstc;
 419         gd->jt[XF_putc] = serial_putc;
 420         gd->jt[XF_puts] = serial_puts;
 421         gd->jt[XF_printf] = serial_printf;
 422
 423         /* stdin stdout and stderr are in environment */
 424         /* scan for it */
 425         stdinname  = getenv ("stdin");
 426         stdoutname = getenv ("stdout");
 427         stderrname = getenv ("stderr");
 428
 429         if (overwrite_console () == 0) { /* if not overwritten by config switch */
 430                 inputdev  = search_device (DEV_FLAGS_INPUT,  stdinname);
 431                 outputdev = search_device (DEV_FLAGS_OUTPUT, stdoutname);
 432                 errdev    = search_device (DEV_FLAGS_OUTPUT, stderrname);
 433         }
 434         /* if the devices are overwritten or not found, use default device */
 435         if (inputdev == NULL) {
 436                 inputdev  = search_device (DEV_FLAGS_INPUT,  "serial");
 437         }
 438         if (outputdev == NULL) {
 439                 outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
 440         }
 441         if (errdev == NULL) {
 442                 errdev    = search_device (DEV_FLAGS_OUTPUT, "serial");
 443         }
 444         /* Initializes output console first */
 445         if (outputdev != NULL) {
 446                 console_setfile (stdout, outputdev);
 447         }
 448         if (errdev != NULL) {
 449                 console_setfile (stderr, errdev);
 450         }
 451         if (inputdev != NULL) {
 452                 console_setfile (stdin, inputdev);
 453         }
 454
 455         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
 456
 457 #ifndef CFG_CONSOLE_INFO_QUIET
 458         /* Print information */
 459         printf ("In:    ");
 460         if (stdio_devices[stdin] == NULL) {
 461                 printf ("No input devices available!\n");
 462         } else {
 463                 printf ("%s\n", stdio_devices[stdin]->name);
 464         }
 465
 466         printf ("Out:   ");
 467         if (stdio_devices[stdout] == NULL) {
 468                 printf ("No output devices available!\n");
 469         } else {
 470                 printf ("%s\n", stdio_devices[stdout]->name);
 471         }
 472
 473         printf ("Err:   ");
 474         if (stdio_devices[stderr] == NULL) {
 475                 printf ("No error devices available!\n");
 476         } else {
 477                 printf ("%s\n", stdio_devices[stderr]->name);
 478         }
 479 #endif /* CFG_CONSOLE_INFO_QUIET */
 480
 481 #ifdef CFG_CONSOLE_ENV_OVERWRITE
 482         /* set the environment variables (will overwrite previous env settings) */
 483         for (i = 0; i < 3; i++) {
 484                 setenv (stdio_names[i], stdio_devices[i]->name);
 485         }
 486 #endif /*  CFG_CONSOLE_ENV_OVERWRITE */
 487
 488 #if 0
 489         /* If nothing usable installed, use only the initial console */
 490         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
 491                 return (0);
 492 #endif
 493         return (0);
 494 }
 495
 496 #else /* CFG_CONSOLE_IS_IN_ENV */
 497
 498 /* Called after the relocation - use desired console functions */
 499 int console_init_r (void)
 500 {
 501         DECLARE_GLOBAL_DATA_PTR;
 502
 503         device_t *inputdev = NULL, *outputdev = NULL;
 504         int i, items = ListNumItems (devlist);
 505
 506 #ifdef CONFIG_SPLASH_SCREEN
 507         /* suppress all output if splash screen is enabled and we have
 508            a bmp to display                                            */
 509         if (getenv("splashimage") != NULL)
 510                 outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
 511 #endif
 512
 513 #ifdef CONFIG_SILENT_CONSOLE
 514         /* Suppress all output if "silent" mode requested               */
 515         if (gd->flags & GD_FLG_SILENT)
 516                 outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
 517 #endif
 518
 519         /* Scan devices looking for input and output devices */
 520         for (i = 1;
 521              (i <= items) && ((inputdev == NULL) || (outputdev == NULL));
 522              i++
 523             ) {
 524                 device_t *dev = ListGetPtrToItem (devlist, i);
 525
 526                 if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
 527                         inputdev = dev;
 528                 }
 529                 if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
 530                         outputdev = dev;
 531                 }
 532         }
 533
 534         /* Initializes output console first */
 535         if (outputdev != NULL) {
 536                 console_setfile (stdout, outputdev);
 537                 console_setfile (stderr, outputdev);
 538         }
 539
 540         /* Initializes input console */
 541         if (inputdev != NULL) {
 542                 console_setfile (stdin, inputdev);
 543         }
 544
 545         gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
 546
 547 #ifndef CFG_CONSOLE_INFO_QUIET
 548         /* Print information */
 549         printf ("In:    ");
 550         if (stdio_devices[stdin] == NULL) {
 551                 printf ("No input devices available!\n");
 552         } else {
 553                 printf ("%s\n", stdio_devices[stdin]->name);
 554         }
 555
 556         printf ("Out:   ");
 557         if (stdio_devices[stdout] == NULL) {
 558                 printf ("No output devices available!\n");
 559         } else {
 560                 printf ("%s\n", stdio_devices[stdout]->name);
 561         }
 562
 563         printf ("Err:   ");
 564         if (stdio_devices[stderr] == NULL) {
 565                 printf ("No error devices available!\n");
 566         } else {
 567                 printf ("%s\n", stdio_devices[stderr]->name);
 568         }
 569 #endif /* CFG_CONSOLE_INFO_QUIET */
 570
 571         /* Setting environment variables */
 572         for (i = 0; i < 3; i++) {
 573                 setenv (stdio_names[i], stdio_devices[i]->name);
 574         }
 575
 576 #if 0
 577         /* If nothing usable installed, use only the initial console */
 578         if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
 579                 return (0);
 580 #endif
 581
 582         return (0);
 583 }
 584
 585 #endif /* CFG_CONSOLE_IS_IN_ENV */