blob: e3b13acbf67d1bffb8fef100f79c24748ab67314 [file] [log] [blame]
/*
* Copyright (c) 2017-2018 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
* not be construed as granting a license to any other intellectual
* property including but not limited to intellectual property relating
* to a hardware implementation of the functionality of the software
* licensed hereunder. You may use the software subject to the license
* terms below provided that you ensure that this notice is replicated
* unmodified and in its entirety in all distributions of the software,
* modified or unmodified, in source code or in binary form.
*
* Copyright (c) 2008 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "dev/ps2/keyboard.hh"
#include <cstdint>
#include <list>
#include "base/logging.hh"
#include "base/trace.hh"
#include "debug/PS2.hh"
#include "dev/ps2/types.hh"
#include "params/PS2Keyboard.hh"
namespace gem5
{
namespace ps2
{
PS2Keyboard::PS2Keyboard(const PS2KeyboardParams &p)
: Device(p),
shiftDown(false),
enabled(false)
{
if (p.vnc)
p.vnc->setKeyboard(this);
}
void
PS2Keyboard::serialize(CheckpointOut &cp) const
{
Device::serialize(cp);
SERIALIZE_SCALAR(shiftDown);
SERIALIZE_SCALAR(enabled);
}
void
PS2Keyboard::unserialize(CheckpointIn &cp)
{
Device::unserialize(cp);
UNSERIALIZE_SCALAR(shiftDown);
UNSERIALIZE_SCALAR(enabled);
}
bool
PS2Keyboard::recv(const std::vector<uint8_t> &data)
{
switch (data[0]) {
case ReadID:
DPRINTF(PS2, "Got keyboard read ID command.\n");
sendAck();
send(keyboard::ID);
return true;
case Enable:
DPRINTF(PS2, "Enabling the keyboard.\n");
enabled = true;
sendAck();
return true;
case Disable:
DPRINTF(PS2, "Disabling the keyboard.\n");
enabled = false;
sendAck();
return true;
case DefaultsAndDisable:
DPRINTF(PS2, "Disabling and resetting the keyboard.\n");
enabled = false;
sendAck();
return true;
case Reset:
DPRINTF(PS2, "Resetting keyboard.\n");
enabled = true;
sendAck();
send(SelfTestPass);
return true;
case Resend:
panic("Keyboard resend unimplemented.\n");
case keyboard::LEDWrite:
if (data.size() == 1) {
DPRINTF(PS2, "Got LED write command.\n");
sendAck();
return false;
} else {
DPRINTF(PS2, "Setting LEDs: "
"caps lock %s, num lock %s, scroll lock %s\n",
bits(data[1], 2) ? "on" : "off",
bits(data[1], 1) ? "on" : "off",
bits(data[1], 0) ? "on" : "off");
sendAck();
return true;
}
case keyboard::DiagnosticEcho:
send(keyboard::DiagnosticEcho);
return true;
case keyboard::AlternateScanCodes:
if (data.size() == 1) {
DPRINTF(PS2, "Got scan code set command.\n");
sendAck();
return false;
} else {
sendAck();
uint8_t scan_code = data[1];
if (scan_code == 0) {
DPRINTF(PS2, "Sending hard coded current scan code set 2.\n");
send(0x2);
} else {
DPRINTF(PS2, "Setting scan code set to %d.\n", scan_code);
panic_if(scan_code != 0x2,
"PS/2 scan code set %d not supported.", scan_code);
}
}
return true;
case keyboard::TypematicInfo:
if (data.size() == 1) {
DPRINTF(PS2, "Setting typematic info.\n");
sendAck();
return false;
} else {
DPRINTF(PS2, "Setting typematic info to %#02x.\n", data[1]);
sendAck();
return true;
}
case keyboard::AllKeysToTypematic:
panic("Setting all keys to typemantic unimplemented.\n");
case keyboard::AllKeysToMakeRelease:
panic("Setting all keys to make/release unimplemented.\n");
case keyboard::AllKeysToMake:
panic("Setting all keys to make unimplemented.\n");
case keyboard::AllKeysToTypematicMakeRelease:
panic("Setting all keys to "
"typematic/make/release unimplemented.\n");
case keyboard::KeyToTypematic:
panic("Setting a key to typematic unimplemented.\n");
case keyboard::KeyToMakeRelease:
panic("Setting a key to make/release unimplemented.\n");
case keyboard::KeyToMakeOnly:
panic("Setting key to make only unimplemented.\n");
default:
panic("Unknown keyboard command %#02x.\n", data[0]);
}
}
void
PS2Keyboard::keyPress(uint32_t key, bool down)
{
std::list<uint8_t> keys;
// convert the X11 keysym into ps2 codes and update the shift
// state (shiftDown)
keySymToPs2(key, down, shiftDown, keys);
// Drop key presses if the keyboard hasn't been enabled by the
// host. We do that after translating the key code to ensure that
// we keep track of the shift state.
if (!enabled)
return;
// Insert into our queue of characters
for (uint8_t c : keys)
send(c);
}
} // namespace ps2
} // namespace gem5