core/conio.c

   1 /*
   2  * -----------------------------------------------------------------------
   3  *
   4  *   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
   5  *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License as published by
   9  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
  10  *   Boston MA 02111-1307, USA; either version 2 of the License, or
  11  *   (at your option) any later version; incorporated herein by reference.
  12  *
  13  * -----------------------------------------------------------------------
  14  *
  15  *
  16  * conio.c
  17  *
  18  * Console I/O code, except:
  19  *   writechr, writestr_early   - module-dependent
  20  *   writestr, crlf             - writestr.inc
  21  *   writehex*                  - writehex.inc
  22  */
  23 #include <sys/io.h>
  24 #include <stddef.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <fs.h>
  28 #include <com32.h>
  29 #include <sys/cpu.h>
  30
  31 #include "bios.h"
  32 #include "graphics.h"
  33
  34 union screen _cursor;
  35 union screen _screensize;
  36
  37 /*
  38  * Serial console stuff.
  39  */
  40 uint16_t SerialPort = 0;            /* Serial port base (or 0 for no serial port) */
  41 uint16_t BaudDivisor = 115200/9600; /* Baud rate divisor */
  42 uint8_t FlowOutput = 0;             /* Output to assert for serial flow */
  43 uint8_t FlowInput = 0;              /* Input bits for serial flow */
  44 uint8_t FlowIgnore = 0;             /* Ignore input unless these bits set */
  45
  46 uint8_t ScrollAttribute = 0x07; /* Grey on white (normal text color) */
  47 uint16_t DisplayCon = 0x01;     /* Display console enabled */
  48 static uint8_t TextAttribute;   /* Text attribute for message file */
  49 static uint8_t DisplayMask;     /* Display modes mask */
  50
  51 /* Routine to interpret next print char */
  52 static void (*NextCharJump)(char);
  53
  54 void msg_initvars(void);
  55 static void msg_setfg(char data);
  56 static void msg_putchar(char ch);
  57
  58 /*
  59  * loadkeys:    Load a LILO-style keymap
  60  *
  61  * Returns 0 on success, or -1 on error.
  62  */
  63 int loadkeys(char *filename)
  64 {
  65         FILE *f;
  66
  67         f = fopen(filename, "r");
  68         if (!f)
  69                 return -1;
  70
  71         fread(KbdMap, 1, sizeof(KbdMap), f);
  72
  73         fclose(f);
  74         return 0;
  75 }
  76
  77 /*
  78  *
  79  * get_msg_file: Load a text file and write its contents to the screen,
  80  *               interpreting color codes.
  81  *
  82  * Returns 0 on success, -1 on failure.
  83  */
  84 int get_msg_file(char *filename)
  85 {
  86         FILE *f;
  87         char ch;
  88
  89         f = fopen(filename, "r");
  90         if (!f)
  91                 return -1;
  92
  93         TextAttribute = 0x7;    /* Default grey on white */
  94         DisplayMask = 0x7;      /* Display text in all modes */
  95         msg_initvars();
  96
  97         /*
  98          * Read the text file a byte at a time and interpret that
  99          * byte.
 100          */
 101         while ((ch = getc(f)) != EOF) {
 102                 /* DOS EOF? */
 103                 if (ch == 0x1A)
 104                         break;
 105
 106                 /*
 107                  * 01h = text mode
 108                  * 02h = graphics mode
 109                  */
 110                 UsingVGA &= 0x1;
 111                 UsingVGA += 1;
 112
 113                 NextCharJump(ch);       /* Do what shall be done */
 114         }
 115
 116         fclose(f);
 117         return 0;
 118 }
 119
 120 static inline void msg_beep(void)
 121 {
 122         com32sys_t ireg, oreg;
 123
 124         ireg.eax.w[0] = 0x0E07; /* Beep */
 125         ireg.ebx.w[0] = 0x0000;
 126         __intcall(0x10, &ireg, &oreg);
 127 }
 128
 129 /*
 130  * write_serial: If serial output is enabled, write character on
 131  * serial port.
 132  */
 133 void write_serial(char data)
 134 {
 135         if (!SerialPort)
 136                 return;
 137
 138         while (1) {
 139                 char ch;
 140
 141                 ch = inb(SerialPort + 5); /* LSR */
 142
 143                 /* Wait for space in transmit register */
 144                 if (!(ch & 0x20))
 145                         continue;
 146
 147                 /* Wait for input flow control */
 148                 ch = inb(SerialPort + 6);
 149                 ch &= FlowInput;
 150                 if (ch != FlowInput)
 151                         continue;
 152
 153                 break;
 154         }
 155
 156         outb(data, SerialPort); /* Send data */
 157         io_delay();
 158 }
 159
 160 void pm_write_serial(com32sys_t *regs)
 161 {
 162         write_serial(regs->eax.b[0]);
 163 }
 164
 165 void pm_serialcfg(com32sys_t *regs)
 166 {
 167         uint8_t al, ah;
 168
 169         regs->eax.w[0] = SerialPort;
 170         regs->ecx.w[0] = BaudDivisor;
 171
 172         al = FlowOutput;
 173         ah = FlowInput;
 174
 175         al |= ah;
 176         ah = FlowIgnore;
 177         ah >>= 4;
 178
 179         if (!DisplayCon)
 180                 ah |= 0x80;
 181
 182         regs->ebx.w[0] = al | (ah << 8);
 183 }
 184
 185 static void write_serial_displaymask(char data)
 186 {
 187         if (DisplayMask & 0x4)
 188                 write_serial(data);
 189 }
 190
 191 /*
 192  * write_serial_str: write_serial for strings
 193  */
 194 void write_serial_str(char *data)
 195 {
 196         char ch;
 197
 198         while ((ch = *data++))
 199                 write_serial(ch);
 200 }
 201
 202 /*
 203  * write_serial_str_displaymask: d:o, but ignore if DisplayMask & 04h == 0
 204  */
 205 static void write_serial_str_displaymask(char *data)
 206 {
 207         if (DisplayMask & 0x4)
 208                 write_serial_str(data);
 209 }
 210
 211 /*
 212  * pollchar: check if we have an input character pending
 213  *
 214  * Returns 1 if character pending.
 215  */
 216 int pollchar(void)
 217 {
 218         com32sys_t ireg, oreg;
 219         uint8_t data = 0;
 220
 221         memset(&ireg, 0, sizeof(ireg));
 222
 223         ireg.eax.b[1] = 0x11;   /* Poll keyboard */
 224         __intcall(0x16, &ireg, &oreg);
 225
 226         if (!(oreg.eflags.l & EFLAGS_ZF))
 227                 return 1;
 228
 229         if (SerialPort) {
 230                 cli();
 231
 232                 /* Already-queued input? */
 233                 if (SerialTail == SerialHead) {
 234                         /* LSR */
 235                         data = inb(SerialPort + 5) & 1;
 236                         if (data) {
 237                                 /* MSR */
 238                                 data = inb(SerialPort + 6);
 239
 240                                 /* Required status bits */
 241                                 if (data) {
 242                                         data &= FlowIgnore;
 243                                         if (data != FlowIgnore)
 244                                                 data = 0;
 245                                         else
 246                                                 data = 1;
 247                                 }
 248                         }
 249                 }
 250                 sti();
 251         }
 252
 253         return data;
 254 }
 255
 256 void pm_pollchar(com32sys_t *regs)
 257 {
 258         if (pollchar())
 259                 regs->eflags.l &= ~EFLAGS_ZF;
 260         else
 261                 regs->eflags.l |= EFLAGS_ZF;
 262 }
 263
 264 extern void do_idle(void);
 265
 266 /*
 267  * getchar: Read a character from keyboard or serial port
 268  */
 269 char getchar(char *hi)
 270 {
 271         com32sys_t ireg, oreg;
 272         unsigned char data;
 273
 274         memset(&ireg, 0, sizeof(ireg));
 275         memset(&oreg, 0, sizeof(oreg));
 276         while (1) {
 277                 call16(do_idle, &zero_regs, NULL);
 278
 279                 ireg.eax.b[1] = 0x11;   /* Poll keyboard */
 280                 __intcall(0x16, &ireg, &oreg);
 281
 282                 if (oreg.eflags.l & EFLAGS_ZF) {
 283                         if (!SerialPort)
 284                                 continue;
 285
 286                         cli();
 287                         if (SerialTail != SerialHead) {
 288                                 /* serial queued */
 289                                 sti(); /* We already know we'll consume data */
 290                                 data = *SerialTail++;
 291
 292                                 SerialTail = (char *)((unsigned long)SerialTail & (serial_buf_size - 1));
 293                         } else {
 294                                 /* LSR */
 295                                 data = inb(SerialPort + 5) & 1;
 296                                 if (!data) {
 297                                         sti();
 298                                         continue;
 299                                 }
 300                                 data = inb(SerialPort + 6);
 301                                 data &= FlowIgnore;
 302                                 if (data != FlowIgnore) {
 303                                         sti();
 304                                         continue;
 305                                 }
 306
 307                                 data = inb(SerialPort);
 308                                 sti();
 309                                 break;
 310                         }
 311                 } else {
 312                         /* Keyboard input? */
 313                         ireg.eax.b[1] = 0x10; /* Get keyboard input */
 314                         __intcall(0x16, &ireg, &oreg);
 315
 316                         data = oreg.eax.b[0];
 317                         *hi = oreg.eax.b[1];
 318
 319                         if (data == 0xE0)
 320                                 data = 0;
 321
 322                         if (data) {
 323                                 /* Convert character sets */
 324                                 data = KbdMap[data];
 325                         }
 326                 }
 327
 328                 break;
 329         }
 330
 331         reset_idle();           /* Character received */
 332         return data;
 333 }
 334
 335 void pm_getchar(com32sys_t *regs)
 336 {
 337         regs->eax.b[0] = getchar((char *)&regs->eax.b[1]);
 338 }
 339
 340 static void msg_setbg(char data)
 341 {
 342         if (unhexchar(&data) == 0) {
 343                 data <<= 4;
 344                 if (DisplayMask & UsingVGA)
 345                         TextAttribute = data;
 346
 347                 NextCharJump = msg_setfg;
 348         } else {
 349                 TextAttribute = 0x7;    /* Default attribute */
 350                 NextCharJump = msg_putchar;
 351         }
 352 }
 353
 354 static void msg_setfg(char data)
 355 {
 356         if (unhexchar(&data) == 0) {
 357                 if (DisplayMask & UsingVGA) {
 358                         /* setbg set foreground to 0 */
 359                         TextAttribute |= data;
 360                 }
 361         } else
 362                 TextAttribute = 0x7;    /* Default attribute */
 363
 364         NextCharJump = msg_putchar;
 365 }
 366
 367 static inline void msg_ctrl_o(void)
 368 {
 369         NextCharJump = msg_setbg;
 370 }
 371
 372 static void msg_gotoxy(void)
 373 {
 374         com32sys_t ireg, oreg;
 375
 376         memset(&ireg, 0, sizeof(ireg));
 377
 378         ireg.ebx.b[1] = *(uint8_t *)BIOS_page;
 379         ireg.edx.w[0] = CursorDX;
 380         ireg.eax.b[1] = 0x02;   /* Set cursor position */
 381
 382         __intcall(0x10, &ireg, &oreg);
 383 }
 384
 385 static void msg_newline(void)
 386 {
 387         com32sys_t ireg, oreg;
 388         char crlf_msg[] = { '\r', '\n', '\0' };
 389
 390         write_serial_str_displaymask(crlf_msg);
 391
 392         if (!(DisplayMask & UsingVGA))
 393                 return;
 394
 395         CursorCol = 0;
 396         if ((CursorRow + 1) <= VidRows)
 397                 CursorRow++;
 398         else {
 399                 ireg.ecx.w[0] = 0x0;    /* Upper left hand corner */
 400                 ireg.edx.w[0] = ScreenSize;
 401
 402                 CursorRow = ireg.edx.b[1]; /* New cursor at the bottom */
 403
 404                 ireg.ebx.b[1] = ScrollAttribute;
 405                 ireg.eax.w[0] = 0x0601; /* Scroll up one line */
 406
 407                 __intcall(0x10, &ireg, &oreg);
 408         }
 409
 410         msg_gotoxy();
 411 }
 412
 413 static void msg_formfeed(void)
 414 {
 415         char crff_msg[] = { '\r', '\f', '\0' };
 416
 417         write_serial_str_displaymask(crff_msg);
 418
 419         if (DisplayMask & UsingVGA) {
 420                 com32sys_t ireg, oreg;
 421
 422                 memset(&ireg, 0, sizeof(ireg));
 423
 424                 CursorDX = 0x0; /* Upper left hand corner */
 425
 426                 ireg.edx.w[0] = ScreenSize;
 427                 ireg.ebx.b[1] = TextAttribute;
 428
 429                 ireg.eax.w[0] = 0x0600; /* Clear screen region */
 430                 __intcall(0x10, &ireg, &oreg);
 431
 432                 msg_gotoxy();
 433         }
 434 }
 435
 436 static void msg_novga(void)
 437 {
 438         syslinux_force_text_mode();
 439         msg_initvars();
 440 }
 441
 442 static void msg_viewimage(void)
 443 {
 444         FILE *f;
 445
 446         *VGAFilePtr = '\0';     /* Zero-terminate filename */
 447
 448         mangle_name(VGAFileMBuf, VGAFileBuf);
 449         f = fopen(VGAFileMBuf, "r");
 450         if (!f) {
 451                 /* Not there */
 452                 NextCharJump = msg_putchar;
 453                 return;
 454         }
 455
 456         vgadisplayfile(f);
 457         fclose(f);
 458         msg_initvars();
 459 }
 460
 461 /*
 462  * Getting VGA filename
 463  */
 464 static void msg_filename(char data)
 465 {
 466         /* <LF> = end of filename */
 467         if (data == 0x0A) {
 468                 msg_viewimage();
 469                 return;
 470         }
 471
 472         /* Ignore space/control char */
 473         if (data > ' ') {
 474                 if ((char *)VGAFilePtr < (VGAFileBuf + sizeof(VGAFileBuf)))
 475                         *VGAFilePtr++ = data;
 476         }
 477 }
 478
 479 static void msg_vga(void)
 480 {
 481         NextCharJump = msg_filename;
 482         VGAFilePtr = (uint16_t *)VGAFileBuf;
 483 }
 484
 485 static void msg_line_wrap(void)
 486 {
 487         if (!(DisplayMask & UsingVGA))
 488                 return;
 489
 490         CursorCol = 0;
 491         if ((CursorRow + 1) <= VidRows)
 492                 CursorRow++;
 493         else {
 494                 com32sys_t ireg, oreg;
 495
 496                 memset(&ireg, 0, sizeof(ireg));
 497
 498                 ireg.ecx.w[0] = 0x0;       /* Upper left hand corner */
 499                 ireg.edx.w[0] = ScreenSize;
 500
 501                 CursorRow = ireg.edx.b[1]; /* New cursor at the bottom */
 502
 503                 ireg.ebx.b[1] = ScrollAttribute;
 504                 ireg.eax.w[0] = 0x0601; /* Scroll up one line */
 505
 506                 __intcall(0x10, &ireg, &oreg);
 507         }
 508
 509         msg_gotoxy();
 510 }
 511
 512 static void msg_normal(char data)
 513 {
 514         com32sys_t ireg, oreg;
 515
 516         /* Write to serial port */
 517         write_serial_displaymask(data);
 518
 519         if (!(DisplayMask & UsingVGA))
 520                 return;         /* Not screen */
 521
 522         if (!(DisplayCon & 0x01))
 523                 return;
 524
 525         memset(&ireg, 0, sizeof(ireg));
 526
 527         ireg.ebx.b[0] = TextAttribute;
 528         ireg.ebx.b[1] = *(uint8_t *)BIOS_page;
 529         ireg.eax.b[0] = data;
 530         ireg.eax.b[1] = 0x09;   /* Write character/attribute */
 531         ireg.ecx.w[0] = 1;      /* One character only */
 532
 533         /* Write to screen */
 534         __intcall(0x10, &ireg, &oreg);
 535
 536         if ((CursorCol + 1) <= VidCols) {
 537                 CursorCol++;
 538                 msg_gotoxy();
 539         } else
 540                 msg_line_wrap(); /* Screen wraparound */
 541 }
 542
 543 static void msg_modectl(char data)
 544 {
 545         data &= 0x07;
 546         DisplayMask = data;
 547         NextCharJump = msg_putchar;
 548 }
 549
 550 static void msg_putchar(char ch)
 551 {
 552         /* 10h to 17h are mode controls */
 553         if (ch >= 0x10 && ch < 0x18) {
 554                 msg_modectl(ch);
 555                 return;
 556         }
 557
 558         switch (ch) {
 559         case 0x0F:              /* ^O = color code follows */
 560                 msg_ctrl_o();
 561                 break;
 562         case 0x0D:              /* Ignore <CR> */
 563                 break;
 564         case 0x0A:              /* <LF> = newline */
 565                 msg_newline();
 566                 break;
 567         case 0x0C:              /* <FF> = clear screen */
 568                 msg_formfeed();
 569                 break;
 570         case 0x07:              /* <BEL> = beep */
 571                 msg_beep();
 572                 break;
 573         case 0x19:              /* <EM> = return to text mode */
 574                 msg_novga();
 575                 break;
 576         case 0x18:              /* <CAN> = VGA filename follows */
 577                 msg_vga();
 578                 break;
 579         default:
 580                 msg_normal(ch);
 581                 break;
 582         }
 583 }
 584
 585 /*
 586  * Subroutine to initialize variables, also needed after loading
 587  * graphics file.
 588  */
 589 void msg_initvars(void)
 590 {
 591         com32sys_t ireg, oreg;
 592
 593         ireg.eax.b[1] = 0x3;    /* Read cursor position */
 594         ireg.ebx.b[1] = *(uint8_t *)BIOS_page;
 595         __intcall(0x10, &ireg, &oreg);
 596
 597         CursorDX = oreg.edx.w[0];
 598
 599         /* Initialize state machine */
 600         NextCharJump = msg_putchar;
 601 }