consolestream.cxx

C++ 编写的EROS RTOS

  KEY(0x08, 0x08),		/* 0x0e */
  KEY(0x09, 0x08),		/* 0x0f -- is back tab right? */
  ALPHA('Q'),			/* 0x10 */
  ALPHA('W'),			/* 0x11 */
  ALPHA('E'),			/* 0x12 */
  ALPHA('R'),			/* 0x13 */
  ALPHA('T'),			/* 0x14 */
  ALPHA('Y'),			/* 0x15 */
  ALPHA('U'),			/* 0x16 */
  ALPHA('I'),			/* 0x17 */
  ALPHA('O'),			/* 0x18 */
  ALPHA('P'),			/* 0x19 */
  KEY('[',  '{'),		/* 0x1a */
  KEY(']',  '}'),		/* 0x1b */
  KEY('\r',  '\r'),		/* 0x1c -- enter */
  { { NOP, NOP, NOP, NOP }, KeyMod::Ctrl }, /* 0x1d -- lctrl */
  ALPHA('A'),			/* 0x1e */
  ALPHA('S'),			/* 0x1f */
  ALPHA('D'),			/* 0x20 */
  ALPHA('F'),			/* 0x21 */
  ALPHA('G'),			/* 0x22 */
  ALPHA('H'),			/* 0x23 */
  ALPHA('J'),			/* 0x24 */
  ALPHA('K'),			/* 0x25 */
  ALPHA('L'),			/* 0x26 */
  KEY(';',  ':'),		/* 0x27 */
  KEY('\'', '"'),		/* 0x28 */
  KEY('`',  '~'),		/* 0x29 */
  { { NOP, NOP, NOP, NOP }, KeyMod::Shift }, /* 0x2a -- lshift */
  KEY('\\', '|'),		/* 0x2b */
  ALPHA('Z'),			/* 0x2c */
  ALPHA('X'),			/* 0x2d */
  ALPHA('C'),			/* 0x2e */
  ALPHA('V'),			/* 0x2f */
  ALPHA('B'),			/* 0x30 */
  ALPHA('N'),			/* 0x31 */
  ALPHA('M'),			/* 0x32 */
  KEY(',',  '<'),		/* 0x33 */
  KEY('.',  '>'),		/* 0x34 */
  KEY('/',  '?'),		/* 0x35 */
  { { NOP, NOP, NOP, NOP }, KeyMod::Shift }, /* 0x36 -- rshift */
  KEY('*',  '*'),		/* 0x37 */
  { { NOP, NOP, NOP, NOP }, KeyMod::Alt }, /* 0x38 -- lalt */
  KEY(' ',  ' '),		/* 0x39 -- space */
  { { NOP, NOP, NOP, NOP }, KeyMod::AlphaLock }, /* 0x3a -- alpha lock */
  KEY( F(1), NOP ),		/* 0x3b -- F1 */
  KEY( F(2), NOP ),		/* 0x3c -- F2 */
  KEY( F(3), NOP ),		/* 0x3d -- F3 */
  KEY( F(4), NOP ),		/* 0x3e -- F4 */
  KEY( F(5), NOP ),		/* 0x3f -- F5 */
  KEY( F(6), NOP ),		/* 0x40 -- F6 */
  KEY( F(7), NOP ),		/* 0x41 -- F7 */
  KEY( F(8), NOP ),		/* 0x42 -- F8 */
  KEY( F(9), NOP ),		/* 0x43 -- F9 */
  KEY( F(10), NOP ),		/* 0x44 -- F10 */
  { { NOP, NOP, NOP, NOP }, KeyMod::NumLock }, /* 0x45 -- num lock */
  { { NOP, NOP, NOP, NOP }, KeyMod::ScrlLock }, /* 0x46 -- scroll-lock */

  /* Keypad character mappings -- these assume that num-lock is NOT set! */
  PAD( F(15), '7' ),		/* 0x47 -- keypad 7 */
  PAD( F(16), '8' ),		/* 0x48 -- keypad 8 */
  PAD( F(17), '9' ),		/* 0x49 -- keypad 9 */
  KEY( '-',   NOP ),		/* 0x4a -- keypad - */
  PAD( F(19), '4' ),		/* 0x4b -- keypad 4 */
  PAD( NOP,   '5' ),		/* 0x4c -- keypad 5 */
  PAD( F(20), '6' ),		/* 0x4d -- keypad 6 */
  KEY( '+',   '+' ),		/* 0x4e -- keypad + */
  PAD( F(22), '1' ),		/* 0x4f -- keypad 1 */
  PAD( F(23), '2' ),		/* 0x50 -- keypad 2 */
  PAD( F(24), '3' ),		/* 0x51 -- keypad 3 */
  PAD( F(25), '0' ),		/* 0x52 -- keypad 0 */
  PAD( 0x7f,  '.' ),		/* 0x53 -- keypad ./DEL */
  KEY( NOP, NOP ),		/* 0x54 -- unused! */
  KEY( NOP, NOP ),		/* 0x55 -- unused! */
  KEY( NOP, NOP ),		/* 0x56 -- unused! */
  KEY( F(11), NOP ),		/* 0x57 -- F11 */
  KEY( F(12), NOP ),		/* 0x58 -- F12 */
#if 0
  /* CHARACTERS BELOW THIS POINT ARE RECODED!!! */

  { { NOP, NOP, NOP, NOP }, KeyMod::Ctrl }, /* 0x59 rctrl */
  { { NOP, NOP, NOP, NOP }, KeyMod::Alt }, /* 0x5a ralt */

e0,1c	kpd-enter
e0,1d	rctrl		SUPPRESSED
e0,35	kpd-/
e0,37	print-screen
e0,38   ralt		SUPPRESSED
e0,47	home		
e0,48	uparrow
e0,49	PgUp
e0,4b	left-arrow		
e0,4d	right-arrow
e0,4f	end		
e0,50	downarrow
e0,51	PgDn
e0,52	insert		
e0,53	delete		
e0,5b	lwindow
e0,5c	rwindow
e0,5d	menu
e1,1d,68 pause
#endif
};

static uint32_t
FetchInputFromKeyboard()
{
  static uint8_t esc_code = 0;

  uint8_t scanCode = 0;
  
  while ( ReadKbd(scanCode) ) {
    /* printf("<kc = %x>", scanCode); */
    bool shift = ShiftState & KeyMod::Shift;
#if 0
    bool alt = ShiftState & KeyMod::Alt;
#endif
    bool ctrl = ShiftState & KeyMod::Ctrl;
      
    /* If this is a break character, we need to know: */
    bool isBreak = scanCode & 0x80u;

    uint32_t keyCode = scanCode & 0x7fu;
      
    switch (esc_code) {
    case 0x0:
      {
	/* printf("esc_code==0\n"); */
	switch (scanCode) {
	case 0xe0:
	case 0xe1:
	  esc_code = scanCode;
	  continue;
	default:
	  if (keyCode >= num_scan) {
	    printf("<? 0x0 \\x%x>", keyCode);
	    return NOP;
	  }
	}
	break;
      }
    case 0xe0:
      {
	switch (keyCode) {
	case 0x2a:		/* shift hack used by some keyboards */
				/* for extra keys! */
	  shift = ! shift;

	case 0x1c:		/* kpd-enter */
	case 0x1d:		/* rctrl */
	case 0x35:		/* kpd-/ */
	case 0x38:		/* ralt */
	case 0x47:		/* home */
	case 0x48:		/* uparrow */
	case 0x49:		/* pgup */
	case 0x4b:		/* left-arrow */
	case 0x4d:		/* right-arrow */
	case 0x4f:		/* end */
	case 0x50:		/* down-arrow */
	case 0x51:		/* pgdn */
	case 0x52:		/* insert */
	case 0x53:		/* del */
	  esc_code = 0;
	  break;

	case 0x5b:		/* lwindow */
	case 0x5c:		/* rwindow */
	case 0x5d:		/* menu */
	  /* consume these transparently: */
	  esc_code = 0;
	  return NOP;
	default:
	  printf("<? 0xe0 \\x%x>", scanCode);
	  esc_code = 0;
	  return NOP;
	}
	break;
      }

    case 0xe1:
      {
	if (keyCode == 0x1d) {
	  esc_code = scanCode;
	  continue;
	}
	else {
	  esc_code = 0;
	  printf("<? 0xe1 \\x%x>", scanCode);
	  return NOP;
	}
	break;
      }
    case 0x1d:
      {
	if (keyCode == 0x68) {
	  /* consume transparently */
	  esc_code = 0;
	  return NOP;
	}
	else {
	  printf("<? 0x1d \\x%x>", scanCode);
	  esc_code = 0;
	  return NOP;
	}
	break;
      }
    default:
      printf("Unknown escape 0x%x\n", esc_code); 
      break;
    }
      
    /* printf("Key code is %d (0x%x)\n", keyCode, keyCode);  */
    KeyInfo& ki = key_table[keyCode];

    /* printf("<kf=\\x%x,0x%x>", keyCode, ki.flags); */

    if ( (ki.flags & KeyMod::IsAlpha) &&
	 (ShiftState & KeyMod::AlphaLock) )
      shift = !shift;

    if ( (ki.flags & KeyMod::IsPad) &&
	 (ShiftState & KeyMod::NumLock) )
      shift = !shift;

    uint32_t ndx = (shift ? 1 : 0) + (ctrl ? 2 : 0);
    uint32_t ascii = ki.value[ndx];

      /* keep track of shift, ctrl, alt */
    if (isBreak)
      ShiftState &= ~ (ki.flags & 0xf0u);
    else {
      ShiftState |= (ki.flags & 0xf0u);
    }

    /* keep track of the various lock keys on the break, not the
       * keypress - the break doesn't repeat.  These are toggles, thus
       * the XOR:
       */

    if (isBreak && (ki.flags & 0xfu)) {
      ShiftState ^= (ki.flags & 0xfu);
      UpdateKbdLeds();
    }

    if (isBreak || ascii >= NOP)
      return NOP;

#if 0
      /* Check for three-fingered salute: */
    if ( keyCode == 0x53u && ctrl && alt)
      Reboot();
#endif

#if 0
#ifdef OPTION_DDB
    /* Check for kernel debugger: */
    if ( keyCode == 0x20u && ctrl && alt)/* 20u == 'd' */
      Debugger();

    if ( keyCode == 0x2eu && ctrl ) /* 1fu == 'c' */
      Debugger();
#endif
#endif

#ifdef CORNER_HACK
    *((uint16_t *) 0x000b8000) = 0x8f00 | (ascii & 0xffu);
#endif
    return ascii;
  }

  return NOP;
}

static void
KeyboardInterrupt(fixregs_t *sa)
{
  uint32_t c;
  uint32_t irq = IRQ_FROM_EXCEPTION(sa->ExceptNo);

  assert(irq == 1);

  if (KernStream::debuggerIsActive)
    return;

#ifdef CORNER_HACK
  *((uint16_t *) 0x000b8000) = 0x8f00 | 'I';
#endif
  c = FetchInputFromKeyboard();
  if (c == ASCII::ETX)
    Debugger();

  IRQ::Enable(irq);
}

uint8_t
ConsoleStream::Get()
{
  uint32_t c;

#ifdef CORNER_HACK
  *((uint16_t *) 0x000b8000) = 0x8f00 | 'P';
#endif

  do {
    c = FetchInputFromKeyboard();
  } while (c == NOP);

#ifdef CORNER_HACK
  *((uint16_t *) 0x000b8000) = 0x8f00 | 'G';
#endif

  return c;
}

void
ConsoleStream::SetDebugging(bool onOff)
{
  debuggerIsActive = onOff;
  
  if (debuggerIsActive == false)
    IRQ::Enable(IRQ386::Keyboard);
}

void
ConsoleStream::EnableDebuggerInput()
{
  IRQ::SetHandler(IRQ386::Keyboard, KeyboardInterrupt);
  printf("Set up keyboard (console) interrupt handler!\n");

#if 0
  /* Establish initial keyboard state visibly: */
  UpdateKbdLeds();
#endif

  /* FIX: This may prove a problem, as I need to check exactly where
   * the interrupt vectors are set up in the boot sequence... */
  IRQ::Enable(IRQ386::Keyboard);
}

#elif defined(OPTION_DDB)
void
ConsoleStream::EnableDebuggerInput()
{
  fatal("EnableDebuggerInput on console when not DDB_ON_CONSOLE\n");
}

void
ConsoleStream::SetDebugging(bool onOff)
{
  fatal("SetDebugging() on console when not DDB_ON_CONSOLE\n");
}


uint8_t
ConsoleStream::Get()
{
  fatal("Get() on console when not DDB_ON_CONSOLE\n");
  return 0;
}

#endif /* OPTION_DDB_ON_CONSOLE */