grub-lakitu/grub-core/term/arm/pl050.c

/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2007,2008,2009  Free Software Foundation, Inc.
 *
 *  GRUB is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  GRUB is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <grub/ps2.h>
#include <grub/fdtbus.h>
#include <grub/err.h>
#include <grub/machine/kernel.h>
#include <grub/at_keyboard.h>
#include <grub/misc.h>
#include <grub/term.h>
#include <grub/time.h>
#include <grub/ps2.h>
#include <grub/fdtbus.h>

static volatile grub_uint32_t *pl050_regs;

struct grub_ps2_state ps2_state;

static void
keyboard_controller_wait_until_ready (void)
{
  while (! (pl050_regs[1] & 0x40));
}

static grub_uint8_t
wait_ack (void)
{
  grub_uint64_t endtime;
  grub_uint8_t ack;

  endtime = grub_get_time_ms () + 20;
  do
    ack = pl050_regs[2];
  while (ack != GRUB_AT_ACK && ack != GRUB_AT_NACK
	 && grub_get_time_ms () < endtime);
  return ack;
}


static int
write_mode (int mode)
{
  unsigned i;
  for (i = 0; i < GRUB_AT_TRIES; i++)
    {
      grub_uint8_t ack;
      keyboard_controller_wait_until_ready ();
      pl050_regs[2] = 0xf0;
      keyboard_controller_wait_until_ready ();
      pl050_regs[2] = mode;
      keyboard_controller_wait_until_ready ();
      ack = wait_ack ();
      if (ack == GRUB_AT_NACK)
	continue;
      if (ack == GRUB_AT_ACK)
	break;
      return 0;
    }

  return (i != GRUB_AT_TRIES);
}

static int
query_mode (void)
{
  grub_uint8_t ret;
  int e;

  e = write_mode (0);
  if (!e)
    return 0;

  keyboard_controller_wait_until_ready ();

  do
    ret = pl050_regs[2];
  while (ret == GRUB_AT_ACK);

  /* QEMU translates the set even in no-translate mode.  */
  if (ret == 0x43 || ret == 1)
    return 1;
  if (ret == 0x41 || ret == 2)
    return 2;
  if (ret == 0x3f || ret == 3)
    return 3;
  return 0;
}

static void
set_scancodes (void)
{
  write_mode (2);
  ps2_state.current_set = query_mode ();
  grub_dprintf ("atkeyb", "returned set %d\n", ps2_state.current_set);
  if (ps2_state.current_set == 2)
    return;

  write_mode (1);
  ps2_state.current_set = query_mode ();
  grub_dprintf ("atkeyb", "returned set %d\n", ps2_state.current_set);
  if (ps2_state.current_set == 1)
    return;
  grub_dprintf ("atkeyb", "no supported scancode set found\n");
}

static void
keyboard_controller_led (grub_uint8_t leds)
{
  keyboard_controller_wait_until_ready ();
  pl050_regs[2] = 0xed;
  keyboard_controller_wait_until_ready ();
  pl050_regs[2] = leds & 0x7;
}

/* If there is a character pending, return it;
   otherwise return GRUB_TERM_NO_KEY.  */
static int
grub_pl050_keyboard_getkey (struct grub_term_input *term __attribute__ ((unused)))
{
  grub_uint8_t at_key;
  int ret;
  grub_uint8_t old_led;

  if (!(pl050_regs[1] & 0x10))
    return -1;
  at_key = pl050_regs[2];
  old_led = ps2_state.led_status;

  ret = grub_ps2_process_incoming_byte (&ps2_state, at_key);
  if (old_led != ps2_state.led_status)
    keyboard_controller_led (ps2_state.led_status);
  return ret;
}

static struct grub_term_input grub_pl050_keyboard_term =
  {
    .name = "pl050_keyboard",
    .getkey = grub_pl050_keyboard_getkey
  };

static grub_err_t
pl050_attach(const struct grub_fdtbus_dev *dev)
{
  const grub_uint32_t *reg;
  reg = grub_fdtbus_get_prop (dev, "reg", 0);

  /* Mouse.  Nothing to do.  */
  if (grub_be_to_cpu32 (*reg) == 0x7000)
    return 0;

  pl050_regs = grub_fdtbus_map_reg (dev, 0, 0);

  if (!grub_fdtbus_is_mapping_valid (pl050_regs))
    return grub_error (GRUB_ERR_IO, "could not map pl050");

  ps2_state.at_keyboard_status = 0;
  set_scancodes ();
  keyboard_controller_led (ps2_state.led_status);

  grub_term_register_input ("pl050_keyboard", &grub_pl050_keyboard_term);
  return GRUB_ERR_NONE;
}

struct grub_fdtbus_driver pl050 =
{
  .compatible = "arm,pl050",
  .attach = pl050_attach
};

void
grub_pl050_init (void)
{
  grub_fdtbus_register (&pl050);
}