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 <config.h>
  25 #include <common.h>
  26 #include <stdarg.h>
  27 #include <malloc.h>
  28 #include <param.h>
  29 #include <console.h>
  30 #include <driver.h>
  31 #include <fs.h>
  32 #include <reloc.h>
  33 #include <init.h>
  34 #include <clock.h>
  35 #include <kfifo.h>
  36 #include <module.h>
  37 #include <linux/list.h>
  38
  39 LIST_HEAD(console_list);
  40 EXPORT_SYMBOL(console_list);
  41
  42 #define CONSOLE_UNINITIALIZED   0
  43 #define CONSOLE_INIT_EARLY      1
  44 #define CONSOLE_INIT_FULL       2
  45
  46 extern char version_string[];
  47
  48 static void display_banner (void)
  49 {
  50         printf (RELOC("\n\n%s\n\n"), RELOC_VAR(version_string));
  51         printf(RELOC("Board: " CONFIG_BOARDINFO "\n"));
  52 }
  53
  54 static int __initdata initialized = 0;
  55
  56 static int console_std_set(struct device_d *dev, struct param_d *param,
  57                 const char *val)
  58 {
  59         struct console_device *cdev = dev->type_data;
  60         char active[4];
  61         unsigned int flag = 0, i = 0;
  62
  63         if (!val)
  64                 dev_param_set_generic(dev, param, NULL);
  65
  66         if (strchr(val, 'i') && cdev->f_caps & CONSOLE_STDIN) {
  67                 active[i++] = 'i';
  68                 flag |= CONSOLE_STDIN;
  69         }
  70
  71         if (strchr(val, 'o') && cdev->f_caps & CONSOLE_STDOUT) {
  72                 active[i++] = 'o';
  73                 flag |= CONSOLE_STDOUT;
  74         }
  75
  76         if (strchr(val, 'e') && cdev->f_caps & CONSOLE_STDERR) {
  77                 active[i++] = 'e';
  78                 flag |= CONSOLE_STDERR;
  79         }
  80
  81         active[i] = 0;
  82         cdev->f_active = flag;
  83
  84         dev_param_set_generic(dev, param, active);
  85
  86         return 0;
  87 }
  88
  89 static int console_baudrate_set(struct device_d *dev, struct param_d *param,
  90                 const char *val)
  91 {
  92         struct console_device *cdev = dev->type_data;
  93         int baudrate;
  94         char baudstr[16];
  95         unsigned char c;
  96
  97         if (!val)
  98                 dev_param_set_generic(dev, param, NULL);
  99
 100         baudrate = simple_strtoul(val, NULL, 10);
 101
 102         if (cdev->f_active) {
 103                 printf("## Switch baudrate to %d bps and press ENTER ...\n",
 104                         baudrate);
 105                 mdelay(50);
 106                 cdev->setbrg(cdev, baudrate);
 107                 mdelay(50);
 108                 do {
 109                         c = getc();
 110                 } while (c != '\r' && c != '\n');
 111         } else
 112                 cdev->setbrg(cdev, baudrate);
 113
 114         sprintf(baudstr, "%d", baudrate);
 115         dev_param_set_generic(dev, param, baudstr);
 116
 117         return 0;
 118 }
 119
 120 static struct kfifo *console_input_buffer;
 121 static struct kfifo *console_output_buffer;
 122
 123 int getc_buffer_flush(void)
 124 {
 125         console_input_buffer = kfifo_alloc(1024);
 126         console_output_buffer = kfifo_alloc(1024);
 127         return 0;
 128 }
 129
 130 postcore_initcall(getc_buffer_flush);
 131
 132 int console_register(struct console_device *newcdev)
 133 {
 134         struct device_d *dev = &newcdev->class_dev;
 135         int first = 0;
 136         char ch;
 137
 138         strcpy(dev->name, "cs");
 139         dev->type_data = newcdev;
 140         register_device(dev);
 141
 142         if (newcdev->setbrg) {
 143                 dev_add_param(dev, "baudrate", console_baudrate_set, NULL, 0);
 144                 dev_set_param(dev, "baudrate", "115200");
 145         }
 146
 147         dev_add_param(dev, "active", console_std_set, NULL, 0);
 148
 149         initialized = CONSOLE_INIT_FULL;
 150 #ifdef CONFIG_CONSOLE_ACTIVATE_ALL
 151         dev_set_param(dev, "active", "ioe");
 152 #endif
 153 #ifdef CONFIG_CONSOLE_ACTIVATE_FIRST
 154         if (list_empty(&console_list)) {
 155                 first = 1;
 156                 dev_set_param(dev, "active", "ioe");
 157         }
 158 #endif
 159
 160         list_add_tail(&newcdev->list, &console_list);
 161
 162         if (console_output_buffer) {
 163                 while (kfifo_getc(console_output_buffer, &ch) == 0)
 164                         console_putc(CONSOLE_STDOUT, ch);
 165                 kfifo_free(console_output_buffer);
 166                 console_output_buffer = NULL;
 167         }
 168
 169 #ifndef CONFIG_HAS_EARLY_INIT
 170         if (first)
 171                 display_banner();
 172 #endif
 173
 174         return 0;
 175 }
 176 EXPORT_SYMBOL(console_register);
 177
 178 static int getc_raw(void)
 179 {
 180         struct console_device *cdev;
 181         int active = 0;
 182
 183         while (1) {
 184                 for_each_console(cdev) {
 185                         if (!(cdev->f_active & CONSOLE_STDIN))
 186                                 continue;
 187                         active = 1;
 188                         if (cdev->tstc(cdev))
 189                                 return cdev->getc(cdev);
 190                 }
 191                 if (!active)
 192                         /* no active console found. bail out */
 193                         return -1;
 194         }
 195 }
 196
 197 int getc(void)
 198 {
 199         unsigned char ch;
 200         uint64_t start;
 201
 202         /*
 203          * For 100us we read the characters from the serial driver
 204          * into a kfifo. This helps us not to lose characters
 205          * in small hardware fifos.
 206          */
 207         start = get_time_ns();
 208         while (1) {
 209                 if (tstc()) {
 210                         kfifo_putc(console_input_buffer, getc_raw());
 211
 212                         start = get_time_ns();
 213                 }
 214                 if (is_timeout(start, 100 * USECOND) &&
 215                                 kfifo_len(console_input_buffer))
 216                         break;
 217         }
 218
 219         kfifo_getc(console_input_buffer, &ch);
 220         return ch;
 221 }
 222 EXPORT_SYMBOL(getc);
 223
 224 int fgetc(int fd)
 225 {
 226         char c;
 227
 228         if (!fd)
 229                 return getc();
 230         return read(fd, &c, 1);
 231 }
 232 EXPORT_SYMBOL(fgetc);
 233
 234 int tstc(void)
 235 {
 236         struct console_device *cdev;
 237
 238         for_each_console(cdev) {
 239                 if (!(cdev->f_active & CONSOLE_STDIN))
 240                         continue;
 241                 if (cdev->tstc(cdev))
 242                         return 1;
 243         }
 244
 245         return 0;
 246 }
 247 EXPORT_SYMBOL(tstc);
 248
 249 void __initdata *early_console_base;
 250
 251 void console_putc(unsigned int ch, char c)
 252 {
 253         struct console_device *cdev;
 254         int init = INITDATA(initialized);
 255
 256         switch (init) {
 257         case CONSOLE_UNINITIALIZED:
 258                 kfifo_putc(console_output_buffer, c);
 259                 return;
 260
 261 #ifdef CONFIG_HAS_EARLY_INIT
 262         case CONSOLE_INIT_EARLY:
 263                 early_console_putc(INITDATA(early_console_base), c);
 264                 return;
 265 #endif
 266
 267         case CONSOLE_INIT_FULL:
 268                 for_each_console(cdev) {
 269                         if (cdev->f_active & ch) {
 270                                 if (c == '\n')
 271                                         cdev->putc(cdev, '\r');
 272                                 cdev->putc(cdev, c);
 273                         }
 274                 }
 275                 return;
 276         default:
 277                 /* If we have problems inititalizing our data
 278                  * get them early
 279                  */
 280                 hang();
 281         }
 282 }
 283 EXPORT_SYMBOL(console_putc);
 284
 285 int fputc(int fd, char c)
 286 {
 287         if(list_empty(&console_list)) {
 288                 if(!fd)
 289                         console_putc(0, c);
 290                 return 0;
 291         }
 292
 293         if (fd == 1)
 294                 putchar(c);
 295         else if (fd == 2)
 296                 eputc(c);
 297         else
 298                 return write(fd, &c, 1);
 299         return 0;
 300 }
 301 EXPORT_SYMBOL(fputc);
 302
 303 void console_puts(unsigned int ch, const char *str)
 304 {
 305         const char *s = str;
 306         while (*s) {
 307                 if (*s == '\n')
 308                         console_putc(ch, '\r');
 309                 console_putc(ch, *s);
 310                 s++;
 311         }
 312 }
 313 EXPORT_SYMBOL(console_puts);
 314
 315 int fputs(int fd, const char *s)
 316 {
 317         if (fd == 1)
 318                 puts(s);
 319         else if (fd == 2)
 320                 eputs(s);
 321         else
 322                 return write(fd, s, strlen(s));
 323         return 0;
 324 }
 325 EXPORT_SYMBOL(fputs);
 326
 327 void console_flush(void)
 328 {
 329         struct console_device *cdev;
 330
 331         for_each_console(cdev) {
 332                 if (cdev->flush)
 333                         cdev->flush(cdev);
 334         }
 335 }
 336 EXPORT_SYMBOL(console_flush);
 337
 338 void fprintf (int file, const char *fmt, ...)
 339 {
 340         va_list args;
 341         uint i;
 342         char printbuffer[CFG_PBSIZE];
 343
 344         va_start (args, fmt);
 345
 346         /* For this to work, printbuffer must be larger than
 347          * anything we ever want to print.
 348          */
 349         i = vsprintf (printbuffer, fmt, args);
 350         va_end (args);
 351
 352         /* Print the string */
 353         fputs (file, printbuffer);
 354 }
 355 EXPORT_SYMBOL(fprintf);
 356
 357 int printf (const char *fmt, ...)
 358 {
 359         va_list args;
 360         uint i;
 361         char printbuffer[CFG_PBSIZE];
 362
 363         va_start (args, fmt);
 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         va_end (args);
 370
 371         /* Print the string */
 372         puts (printbuffer);
 373
 374         return i;
 375 }
 376 EXPORT_SYMBOL(printf);
 377
 378 int vprintf (const char *fmt, va_list args)
 379 {
 380         uint i;
 381         char printbuffer[CFG_PBSIZE];
 382
 383         /* For this to work, printbuffer must be larger than
 384          * anything we ever want to print.
 385          */
 386         i = vsprintf (printbuffer, fmt, args);
 387
 388         /* Print the string */
 389         puts (printbuffer);
 390
 391         return i;
 392 }
 393 EXPORT_SYMBOL(vprintf);
 394
 395 #ifndef ARCH_HAS_CTRLC
 396 /* test if ctrl-c was pressed */
 397 int ctrlc (void)
 398 {
 399         if (tstc() && getc() == 3)
 400                 return 1;
 401         return 0;
 402 }
 403 EXPORT_SYMBOL(ctrlc);
 404 #endif /* ARCH_HAS_CTRC */
 405
 406 #ifdef CONFIG_HAS_EARLY_INIT
 407
 408 void early_console_start(const char *name, int baudrate)
 409 {
 410         void *base = get_early_console_base(name);
 411
 412         if (base) {
 413                 early_console_init(base, baudrate);
 414                 INITDATA(initialized) = CONSOLE_INIT_EARLY;
 415                 INITDATA(early_console_base) = base;
 416                 display_banner();
 417         }
 418 }
 419
 420 #endif