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 __export uint16_t SerialPort = 0;   /* Serial port base (or 0 for no serial port) */
  41 __export uint8_t FlowInput = 0;     /* Input bits for serial flow */
  42 __export uint16_t BaudDivisor = 115200/9600; /* Baud rate divisor */
  43 __export uint8_t FlowIgnore = 0;    /* Ignore input unless these bits set */
  44 __export uint16_t DisplayCon = 0x01;    /* Display console enabled */
  45 __export uint8_t FlowOutput = 0;        /* Output to assert for serial flow */
  46
  47 __export uint8_t DisplayMask = 0x07;    /* Display modes mask */
  48
  49 uint8_t ScrollAttribute = 0x07; /* Grey on white (normal text color) */
  50
  51 /*
  52  * loadkeys:    Load a LILO-style keymap
  53  *
  54  * Returns 0 on success, or -1 on error.
  55  */
  56 __export int loadkeys(char *filename)
  57 {
  58         FILE *f;
  59
  60         f = fopen(filename, "r");
  61         if (!f)
  62                 return -1;
  63
  64         fread(KbdMap, 1, sizeof(KbdMap), f);
  65
  66         fclose(f);
  67         return 0;
  68 }
  69
  70 /*
  71  * write_serial: If serial output is enabled, write character on
  72  * serial port.
  73  */
  74 __export void write_serial(char data)
  75 {
  76         if (!SerialPort)
  77                 return;
  78
  79         if (!(DisplayMask & 0x04))
  80                 return;
  81
  82         while (1) {
  83                 char ch;
  84
  85                 ch = inb(SerialPort + 5); /* LSR */
  86
  87                 /* Wait for space in transmit register */
  88                 if (!(ch & 0x20))
  89                         continue;
  90
  91                 /* Wait for input flow control */
  92                 ch = inb(SerialPort + 6);
  93                 ch &= FlowInput;
  94                 if (ch != FlowInput)
  95                         continue;
  96
  97                 break;
  98         }
  99
 100         outb(data, SerialPort); /* Send data */
 101         io_delay();
 102 }
 103
 104 void pm_write_serial(com32sys_t *regs)
 105 {
 106         write_serial(regs->eax.b[0]);
 107 }
 108
 109 void pm_serialcfg(com32sys_t *regs)
 110 {
 111         uint8_t al, ah;
 112
 113         regs->eax.w[0] = SerialPort;
 114         regs->ecx.w[0] = BaudDivisor;
 115
 116         al = FlowOutput;
 117         ah = FlowInput;
 118
 119         al |= ah;
 120         ah = FlowIgnore;
 121         ah >>= 4;
 122
 123         if (!DisplayCon)
 124                 ah |= 0x80;
 125
 126         regs->ebx.w[0] = al | (ah << 8);
 127 }
 128
 129 /*
 130  * write_serial_str: write_serial for strings
 131  */
 132 __export void write_serial_str(char *data)
 133 {
 134         char ch;
 135
 136         while ((ch = *data++))
 137                 write_serial(ch);
 138 }
 139
 140 /*
 141  * pollchar: check if we have an input character pending
 142  *
 143  * Returns 1 if character pending.
 144  */
 145 __export int pollchar(void)
 146 {
 147         com32sys_t ireg, oreg;
 148         uint8_t data = 0;
 149
 150         memset(&ireg, 0, sizeof(ireg));
 151
 152         ireg.eax.b[1] = 0x11;   /* Poll keyboard */
 153         __intcall(0x16, &ireg, &oreg);
 154
 155         if (!(oreg.eflags.l & EFLAGS_ZF))
 156                 return 1;
 157
 158         if (SerialPort) {
 159                 cli();
 160
 161                 /* Already-queued input? */
 162                 if (SerialTail == SerialHead) {
 163                         /* LSR */
 164                         data = !(inb(SerialPort + 5) & 1);
 165                         if (!data) {
 166                                 /* MSR */
 167                                 data = inb(SerialPort + 6);
 168
 169                                 /* Required status bits */
 170                                 data &= FlowIgnore;
 171
 172                                 if (data == FlowIgnore)
 173                                         data = 1;
 174                                 else
 175                                         data = 0;
 176                         } else
 177                                 data = 1;
 178                 } else
 179                         data = 1;
 180                 sti();
 181         }
 182
 183         return data;
 184 }
 185
 186 void pm_pollchar(com32sys_t *regs)
 187 {
 188         if (pollchar())
 189                 regs->eflags.l &= ~EFLAGS_ZF;
 190         else
 191                 regs->eflags.l |= EFLAGS_ZF;
 192 }
 193
 194 extern void do_idle(void);
 195
 196 /*
 197  * getchar: Read a character from keyboard or serial port
 198  */
 199 __export char getchar(char *hi)
 200 {
 201         com32sys_t ireg, oreg;
 202         unsigned char data;
 203
 204         memset(&ireg, 0, sizeof(ireg));
 205         memset(&oreg, 0, sizeof(oreg));
 206         while (1) {
 207                 call16(do_idle, &zero_regs, NULL);
 208
 209                 ireg.eax.b[1] = 0x11;   /* Poll keyboard */
 210                 __intcall(0x16, &ireg, &oreg);
 211
 212                 if (oreg.eflags.l & EFLAGS_ZF) {
 213                         if (!SerialPort)
 214                                 continue;
 215
 216                         cli();
 217                         if (SerialTail != SerialHead) {
 218                                 /* serial queued */
 219                                 sti(); /* We already know we'll consume data */
 220                                 data = *SerialTail++;
 221
 222                                 if (SerialTail > SerialHead + serial_buf_size)
 223                                         SerialTail = SerialHead;
 224                         } else {
 225                                 /* LSR */
 226                                 data = inb(SerialPort + 5) & 1;
 227                                 if (!data) {
 228                                         sti();
 229                                         continue;
 230                                 }
 231                                 data = inb(SerialPort + 6);
 232                                 data &= FlowIgnore;
 233                                 if (data != FlowIgnore) {
 234                                         sti();
 235                                         continue;
 236                                 }
 237
 238                                 data = inb(SerialPort);
 239                                 sti();
 240                                 break;
 241                         }
 242                 } else {
 243                         /* Keyboard input? */
 244                         ireg.eax.b[1] = 0x10; /* Get keyboard input */
 245                         __intcall(0x16, &ireg, &oreg);
 246
 247                         data = oreg.eax.b[0];
 248                         *hi = oreg.eax.b[1];
 249
 250                         if (data == 0xE0)
 251                                 data = 0;
 252
 253                         if (data) {
 254                                 /* Convert character sets */
 255                                 data = KbdMap[data];
 256                         }
 257                 }
 258
 259                 break;
 260         }
 261
 262         reset_idle();           /* Character received */
 263         return data;
 264 }
 265
 266 void pm_getchar(com32sys_t *regs)
 267 {
 268         regs->eax.b[0] = getchar((char *)&regs->eax.b[1]);
 269 }