i8042.cc revision 12514:09556145b380 
1/*
2 * Copyright (c) 2008 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Gabe Black
29 */
30
31#include "dev/x86/i8042.hh"
32
33#include "base/bitunion.hh"
34#include "debug/I8042.hh"
35#include "mem/packet.hh"
36#include "mem/packet_access.hh"
37
38/**
39 * Note: For details on the implementation see
40 * https://wiki.osdev.org/%228042%22_PS/2_Controller
41 */
42
43// The 8042 has a whopping 32 bytes of internal RAM.
44const uint8_t RamSize = 32;
45const uint8_t NumOutputBits = 14;
46const uint8_t X86ISA::PS2Keyboard::ID[] = {0xab, 0x83};
47const uint8_t X86ISA::PS2Mouse::ID[] = {0x00};
48const uint8_t CommandAck = 0xfa;
49const uint8_t CommandNack = 0xfe;
50const uint8_t BatSuccessful = 0xaa;
51
52
53X86ISA::I8042::I8042(Params *p)
54    : BasicPioDevice(p, 0), // pioSize arg is dummy value... not used
55      latency(p->pio_latency),
56      dataPort(p->data_port), commandPort(p->command_port),
57      statusReg(0), commandByte(0), dataReg(0), lastCommand(NoCommand),
58      mouseIntPin(p->mouse_int_pin), keyboardIntPin(p->keyboard_int_pin)
59{
60    statusReg.passedSelfTest = 1;
61    statusReg.commandLast = 1;
62    statusReg.keyboardUnlocked = 1;
63
64    commandByte.convertScanCodes = 1;
65    commandByte.passedSelfTest = 1;
66    commandByte.keyboardFullInt = 1;
67}
68
69
70AddrRangeList
71X86ISA::I8042::getAddrRanges() const
72{
73    AddrRangeList ranges;
74    // TODO: Are these really supposed to be a single byte and not 4?
75    ranges.push_back(RangeSize(dataPort, 1));
76    ranges.push_back(RangeSize(commandPort, 1));
77    return ranges;
78}
79
80void
81X86ISA::I8042::writeData(uint8_t newData, bool mouse)
82{
83    DPRINTF(I8042, "Set data %#02x.\n", newData);
84    dataReg = newData;
85    statusReg.outputFull = 1;
86    statusReg.mouseOutputFull = (mouse ? 1 : 0);
87    if (!mouse && commandByte.keyboardFullInt) {
88        DPRINTF(I8042, "Sending keyboard interrupt.\n");
89        keyboardIntPin->raise();
90        //This is a hack
91        keyboardIntPin->lower();
92    } else if (mouse && commandByte.mouseFullInt) {
93        DPRINTF(I8042, "Sending mouse interrupt.\n");
94        mouseIntPin->raise();
95        //This is a hack
96        mouseIntPin->lower();
97    }
98}
99
100void
101X86ISA::PS2Device::serialize(const std::string &base, CheckpointOut &cp) const
102{
103    paramOut(cp, base + ".lastCommand", lastCommand);
104
105    std::vector<uint8_t> buffer(outBuffer.size());
106    std::copy(outBuffer.begin(), outBuffer.end(), buffer.begin());
107    arrayParamOut(cp, base + ".outBuffer.elts", buffer);
108}
109
110void
111X86ISA::PS2Device::unserialize(const std::string &base, CheckpointIn &cp)
112{
113    paramIn(cp, base + ".lastCommand", lastCommand);
114
115    std::vector<uint8_t> buffer;
116    arrayParamIn(cp, base + ".outBuffer.elts", buffer);
117    assert(outBuffer.empty());
118    for (auto c : buffer)
119        outBuffer.push_back(c);
120}
121
122
123void
124X86ISA::PS2Device::ack()
125{
126    bufferData(&CommandAck, sizeof(CommandAck));
127}
128
129void
130X86ISA::PS2Device::nack()
131{
132    bufferData(&CommandNack, sizeof(CommandNack));
133}
134
135void
136X86ISA::PS2Device::bufferData(const uint8_t *data, int size)
137{
138    assert(data || size == 0);
139    while (size) {
140        outBuffer.push_back(*(data++));
141        size--;
142    }
143}
144
145uint8_t
146X86ISA::I8042::readDataOut()
147{
148    uint8_t data = dataReg;
149    statusReg.outputFull = 0;
150    statusReg.mouseOutputFull = 0;
151    if (keyboard.hasData()) {
152        writeData(keyboard.getData(), false);
153    } else if (mouse.hasData()) {
154        writeData(mouse.getData(), true);
155    }
156    return data;
157}
158
159bool
160X86ISA::PS2Keyboard::processData(uint8_t data)
161{
162    if (lastCommand != NoCommand) {
163        switch (lastCommand) {
164          case LEDWrite:
165            DPRINTF(I8042, "Setting LEDs: "
166                    "caps lock %s, num lock %s, scroll lock %s\n",
167                    bits(data, 2) ? "on" : "off",
168                    bits(data, 1) ? "on" : "off",
169                    bits(data, 0) ? "on" : "off");
170            ack();
171            lastCommand = NoCommand;
172            break;
173          case TypematicInfo:
174            DPRINTF(I8042, "Setting typematic info to %#02x.\n", data);
175            ack();
176            lastCommand = NoCommand;
177            break;
178        }
179        return hasData();
180    }
181    switch (data) {
182      case LEDWrite:
183        DPRINTF(I8042, "Got LED write command.\n");
184        ack();
185        lastCommand = LEDWrite;
186        break;
187      case DiagnosticEcho:
188        panic("Keyboard diagnostic echo unimplemented.\n");
189      case AlternateScanCodes:
190        panic("Accessing alternate scan codes unimplemented.\n");
191      case ReadID:
192        DPRINTF(I8042, "Got keyboard read ID command.\n");
193        ack();
194        bufferData((uint8_t *)&ID, sizeof(ID));
195        break;
196      case TypematicInfo:
197        DPRINTF(I8042, "Setting typematic info.\n");
198        ack();
199        lastCommand = TypematicInfo;
200        break;
201      case Enable:
202        DPRINTF(I8042, "Enabling the keyboard.\n");
203        ack();
204        break;
205      case Disable:
206        DPRINTF(I8042, "Disabling the keyboard.\n");
207        ack();
208        break;
209      case DefaultsAndDisable:
210        DPRINTF(I8042, "Disabling and resetting the keyboard.\n");
211        ack();
212        break;
213      case AllKeysToTypematic:
214        panic("Setting all keys to typemantic unimplemented.\n");
215      case AllKeysToMakeRelease:
216        panic("Setting all keys to make/release unimplemented.\n");
217      case AllKeysToMake:
218        panic("Setting all keys to make unimplemented.\n");
219      case AllKeysToTypematicMakeRelease:
220        panic("Setting all keys to "
221                "typematic/make/release unimplemented.\n");
222      case KeyToTypematic:
223        panic("Setting a key to typematic unimplemented.\n");
224      case KeyToMakeRelease:
225        panic("Setting a key to make/release unimplemented.\n");
226      case KeyToMakeOnly:
227        panic("Setting key to make only unimplemented.\n");
228      case Resend:
229        panic("Keyboard resend unimplemented.\n");
230      case Reset:
231        panic("Keyboard reset unimplemented.\n");
232      default:
233        panic("Unknown keyboard command %#02x.\n", data);
234    }
235    return hasData();
236}
237
238bool
239X86ISA::PS2Mouse::processData(uint8_t data)
240{
241    if (lastCommand != NoCommand) {
242        switch(lastCommand) {
243          case SetResolution:
244            DPRINTF(I8042, "Mouse resolution set to %d.\n", data);
245            resolution = data;
246            ack();
247            lastCommand = NoCommand;
248            break;
249          case SampleRate:
250            DPRINTF(I8042, "Mouse sample rate %d samples "
251                    "per second.\n", data);
252            sampleRate = data;
253            ack();
254            lastCommand = NoCommand;
255            break;
256          default:
257            panic("Not expecting data for a mouse command.\n");
258        }
259        return hasData();
260    }
261    switch (data) {
262      case Scale1to1:
263        DPRINTF(I8042, "Setting mouse scale to 1:1.\n");
264        status.twoToOne = 0;
265        ack();
266        break;
267      case Scale2to1:
268        DPRINTF(I8042, "Setting mouse scale to 2:1.\n");
269        status.twoToOne = 1;
270        ack();
271        break;
272      case SetResolution:
273        DPRINTF(I8042, "Setting mouse resolution.\n");
274        lastCommand = SetResolution;
275        ack();
276        break;
277      case GetStatus:
278        DPRINTF(I8042, "Getting mouse status.\n");
279        ack();
280        bufferData((uint8_t *)&(status), 1);
281        bufferData(&resolution, sizeof(resolution));
282        bufferData(&sampleRate, sizeof(sampleRate));
283        break;
284      case ReadData:
285        panic("Reading mouse data unimplemented.\n");
286      case ResetWrapMode:
287        panic("Resetting mouse wrap mode unimplemented.\n");
288      case WrapMode:
289        panic("Setting mouse wrap mode unimplemented.\n");
290      case RemoteMode:
291        panic("Setting mouse remote mode unimplemented.\n");
292      case ReadID:
293        DPRINTF(I8042, "Mouse ID requested.\n");
294        ack();
295        bufferData(ID, sizeof(ID));
296        break;
297      case SampleRate:
298        DPRINTF(I8042, "Setting mouse sample rate.\n");
299        lastCommand = SampleRate;
300        ack();
301        break;
302      case DisableReporting:
303        DPRINTF(I8042, "Disabling data reporting.\n");
304        status.enabled = 0;
305        ack();
306        break;
307      case EnableReporting:
308        DPRINTF(I8042, "Enabling data reporting.\n");
309        status.enabled = 1;
310        ack();
311        break;
312      case DefaultsAndDisable:
313        DPRINTF(I8042, "Disabling and resetting mouse.\n");
314        sampleRate = 100;
315        resolution = 4;
316        status.twoToOne = 0;
317        status.enabled = 0;
318        ack();
319        break;
320      case Resend:
321        panic("Mouse resend unimplemented.\n");
322      case Reset:
323        DPRINTF(I8042, "Resetting the mouse.\n");
324        sampleRate = 100;
325        resolution = 4;
326        status.twoToOne = 0;
327        status.enabled = 0;
328        ack();
329        bufferData(&BatSuccessful, sizeof(BatSuccessful));
330        bufferData(ID, sizeof(ID));
331        break;
332      default:
333        warn("Unknown mouse command %#02x.\n", data);
334        nack();
335        break;
336    }
337    return hasData();
338}
339
340
341Tick
342X86ISA::I8042::read(PacketPtr pkt)
343{
344    assert(pkt->getSize() == 1);
345    Addr addr = pkt->getAddr();
346    if (addr == dataPort) {
347        uint8_t data = readDataOut();
348        //DPRINTF(I8042, "Read from data port got %#02x.\n", data);
349        pkt->set<uint8_t>(data);
350    } else if (addr == commandPort) {
351        //DPRINTF(I8042, "Read status as %#02x.\n", (uint8_t)statusReg);
352        pkt->set<uint8_t>((uint8_t)statusReg);
353    } else {
354        panic("Read from unrecognized port %#x.\n", addr);
355    }
356    pkt->makeAtomicResponse();
357    return latency;
358}
359
360Tick
361X86ISA::I8042::write(PacketPtr pkt)
362{
363    assert(pkt->getSize() == 1);
364    Addr addr = pkt->getAddr();
365    uint8_t data = pkt->get<uint8_t>();
366    if (addr == dataPort) {
367        statusReg.commandLast = 0;
368        switch (lastCommand) {
369          case NoCommand:
370            if (keyboard.processData(data)) {
371                writeData(keyboard.getData(), false);
372            }
373            break;
374          case WriteToMouse:
375            if (mouse.processData(data)) {
376                writeData(mouse.getData(), true);
377            }
378            break;
379          case WriteCommandByte:
380            commandByte = data;
381            DPRINTF(I8042, "Got data %#02x for \"Write "
382                    "command byte\" command.\n", data);
383            statusReg.passedSelfTest = (uint8_t)commandByte.passedSelfTest;
384            break;
385          case WriteMouseOutputBuff:
386            DPRINTF(I8042, "Got data %#02x for \"Write "
387                    "mouse output buffer\" command.\n", data);
388            writeData(data, true);
389            break;
390          case WriteKeyboardOutputBuff:
391            DPRINTF(I8042, "Got data %#02x for \"Write "
392                    "keyboad output buffer\" command.\n", data);
393            writeData(data, false);
394            break;
395          case WriteOutputPort:
396            DPRINTF(I8042, "Got data %#02x for \"Write "
397                    "output port\" command.\n", data);
398            panic_if(bits(data, 0) != 1, "Reset bit should be 1");
399            // Safe to ignore otherwise
400            break;
401          default:
402            panic("Data written for unrecognized "
403                    "command %#02x\n", lastCommand);
404        }
405        lastCommand = NoCommand;
406    } else if (addr == commandPort) {
407        DPRINTF(I8042, "Got command %#02x.\n", data);
408        statusReg.commandLast = 1;
409        // These purposefully leave off the first byte of the controller RAM
410        // so it can be handled specially.
411        if (data > ReadControllerRamBase &&
412                data < ReadControllerRamBase + RamSize) {
413            panic("Attempted to use i8042 read controller RAM command to "
414                    "get byte %d.\n", data - ReadControllerRamBase);
415        } else if (data > WriteControllerRamBase &&
416                data < WriteControllerRamBase + RamSize) {
417            panic("Attempted to use i8042 read controller RAM command to "
418                    "get byte %d.\n", data - ReadControllerRamBase);
419        } else if (data >= PulseOutputBitBase &&
420                data < PulseOutputBitBase + NumOutputBits) {
421            panic("Attempted to use i8042 pulse output bit command to "
422                    "to pulse bit %d.\n", data - PulseOutputBitBase);
423        }
424        switch (data) {
425          case GetCommandByte:
426            DPRINTF(I8042, "Getting command byte.\n");
427            writeData(commandByte);
428            break;
429          case WriteCommandByte:
430            DPRINTF(I8042, "Setting command byte.\n");
431            lastCommand = WriteCommandByte;
432            break;
433          case CheckForPassword:
434            panic("i8042 \"Check for password\" command not implemented.\n");
435          case LoadPassword:
436            panic("i8042 \"Load password\" command not implemented.\n");
437          case CheckPassword:
438            panic("i8042 \"Check password\" command not implemented.\n");
439          case DisableMouse:
440            DPRINTF(I8042, "Disabling mouse at controller.\n");
441            commandByte.disableMouse = 1;
442            break;
443          case EnableMouse:
444            DPRINTF(I8042, "Enabling mouse at controller.\n");
445            commandByte.disableMouse = 0;
446            break;
447          case TestMouse:
448            panic("i8042 \"Test mouse\" command not implemented.\n");
449          case SelfTest:
450            panic("i8042 \"Self test\" command not implemented.\n");
451          case InterfaceTest:
452            panic("i8042 \"Interface test\" command not implemented.\n");
453          case DiagnosticDump:
454            panic("i8042 \"Diagnostic dump\" command not implemented.\n");
455          case DisableKeyboard:
456            DPRINTF(I8042, "Disabling keyboard at controller.\n");
457            commandByte.disableKeyboard = 1;
458            break;
459          case EnableKeyboard:
460            DPRINTF(I8042, "Enabling keyboard at controller.\n");
461            commandByte.disableKeyboard = 0;
462            break;
463          case ReadInputPort:
464            panic("i8042 \"Read input port\" command not implemented.\n");
465          case ContinuousPollLow:
466            panic("i8042 \"Continuous poll low\" command not implemented.\n");
467          case ContinuousPollHigh:
468            panic("i8042 \"Continuous poll high\" command not implemented.\n");
469          case ReadOutputPort:
470            panic("i8042 \"Read output port\" command not implemented.\n");
471          case WriteOutputPort:
472            lastCommand = WriteOutputPort;
473            break;
474          case WriteKeyboardOutputBuff:
475            lastCommand = WriteKeyboardOutputBuff;
476            break;
477          case WriteMouseOutputBuff:
478            DPRINTF(I8042, "Got command to write to mouse output buffer.\n");
479            lastCommand = WriteMouseOutputBuff;
480            break;
481          case WriteToMouse:
482            DPRINTF(I8042, "Expecting mouse command.\n");
483            lastCommand = WriteToMouse;
484            break;
485          case DisableA20:
486            panic("i8042 \"Disable A20\" command not implemented.\n");
487          case EnableA20:
488            panic("i8042 \"Enable A20\" command not implemented.\n");
489          case ReadTestInputs:
490            panic("i8042 \"Read test inputs\" command not implemented.\n");
491          case SystemReset:
492            panic("i8042 \"System reset\" command not implemented.\n");
493          default:
494            warn("Write to unknown i8042 "
495                    "(keyboard controller) command port.\n");
496        }
497    } else {
498        panic("Write to unrecognized port %#x.\n", addr);
499    }
500    pkt->makeAtomicResponse();
501    return latency;
502}
503
504void
505X86ISA::I8042::serialize(CheckpointOut &cp) const
506{
507    SERIALIZE_SCALAR(dataPort);
508    SERIALIZE_SCALAR(commandPort);
509    SERIALIZE_SCALAR(statusReg);
510    SERIALIZE_SCALAR(commandByte);
511    SERIALIZE_SCALAR(dataReg);
512    SERIALIZE_SCALAR(lastCommand);
513    mouse.serialize("mouse", cp);
514    keyboard.serialize("keyboard", cp);
515}
516
517void
518X86ISA::I8042::unserialize(CheckpointIn &cp)
519{
520    UNSERIALIZE_SCALAR(dataPort);
521    UNSERIALIZE_SCALAR(commandPort);
522    UNSERIALIZE_SCALAR(statusReg);
523    UNSERIALIZE_SCALAR(commandByte);
524    UNSERIALIZE_SCALAR(dataReg);
525    UNSERIALIZE_SCALAR(lastCommand);
526    mouse.unserialize("mouse", cp);
527    keyboard.unserialize("keyboard", cp);
528}
529
530void
531X86ISA::PS2Mouse::serialize(const std::string &base, CheckpointOut &cp) const
532{
533    PS2Device::serialize(base, cp);
534
535    paramOut(cp, base + ".status", status);
536    paramOut(cp, base + ".resolution", resolution);
537    paramOut(cp, base + ".sampleRate", sampleRate);
538}
539
540void
541X86ISA::PS2Mouse::unserialize(const std::string &base, CheckpointIn &cp)
542{
543    PS2Device::unserialize(base, cp);
544
545    paramIn(cp, base + ".status", status);
546    paramIn(cp, base + ".resolution", resolution);
547    paramIn(cp, base + ".sampleRate", sampleRate);
548}
549
550X86ISA::I8042 *
551I8042Params::create()
552{
553    return new X86ISA::I8042(this);
554}
555