/*
 * Kernel Debugger Architecture Dependent Console I/O handler
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.
 *
 * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
 */

#include <linux/kdb.h>
#include <linux/keyboard.h>
#include <linux/ctype.h>
#include <linux/module.h>
#include <linux/io.h>

/* Keyboard Controller Registers on normal PCs. */

#define KBD_STATUS_REG          0x64    /* Status register (R) */
#define KBD_DATA_REG            0x60    /* Keyboard data register (R/W) */

/* Status Register Bits */

#define KBD_STAT_OBF            0x01    /* Keyboard output buffer full */
#define KBD_STAT_MOUSE_OBF      0x20    /* Mouse output buffer full */

static int kbd_exists;
static int kbd_last_ret;

/*
 * Check if the keyboard controller has a keypress for us.
 * Some parts (Enter Release, LED change) are still blocking polled here,
 * but hopefully they are all short.
 */
int kdb_get_kbd_char(void)
{
        int scancode, scanstatus;
        static int shift_lock;  /* CAPS LOCK state (0-off, 1-on) */
        static int shift_key;   /* Shift next keypress */
        static int ctrl_key;
        u_short keychar;

        if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) ||
            (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
                kbd_exists = 0;
                return -1;
        }
        kbd_exists = 1;

        if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
                return -1;

        /*
         * Fetch the scancode
         */
        scancode = inb(KBD_DATA_REG);
        scanstatus = inb(KBD_STATUS_REG);

        /*
         * Ignore mouse events.
         */
        if (scanstatus & KBD_STAT_MOUSE_OBF)
                return -1;

        /*
         * Ignore release, trigger on make
         * (except for shift keys, where we want to
         *  keep the shift state so long as the key is
         *  held down).
         */

        if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) {
                /*
                 * Next key may use shift table
                 */
                if ((scancode & 0x80) == 0)
                        shift_key = 1;
                else
                        shift_key = 0;
                return -1;
        }

        if ((scancode&0x7f) == 0x1d) {
                /*
                 * Left ctrl key
                 */
                if ((scancode & 0x80) == 0)
                        ctrl_key = 1;
                else
                        ctrl_key = 0;
                return -1;
        }

        if ((scancode & 0x80) != 0) {
                if (scancode == 0x9c)
                        kbd_last_ret = 0;
                return -1;
        }

        scancode &= 0x7f;

        /*
         * Translate scancode
         */

        if (scancode == 0x3a) {
                /*
                 * Toggle caps lock
                 */
                shift_lock ^= 1;

#ifdef  KDB_BLINK_LED
                kdb_toggleled(0x4);
#endif
                return -1;
        }

        if (scancode == 0x0e) {
                /*
                 * Backspace
                 */
                return 8;
        }

        /* Special Key */
        switch (scancode) {
        case 0xF: /* Tab */
                return 9;
        case 0x53: /* Del */
                return 4;
        case 0x47: /* Home */
                return 1;
        case 0x4F: /* End */
                return 5;
        case 0x4B: /* Left */
                return 2;
        case 0x48: /* Up */
                return 16;
        case 0x50: /* Down */
                return 14;
        case 0x4D: /* Right */
                return 6;
        }

        if (scancode == 0xe0)
                return -1;

        /*
         * For Japanese 86/106 keyboards
         *      See comment in drivers/char/pc_keyb.c.
         *      - Masahiro Adegawa
         */
        if (scancode == 0x73)
                scancode = 0x59;
        else if (scancode == 0x7d)
                scancode = 0x7c;

        if (!shift_lock && !shift_key && !ctrl_key) {
                keychar = plain_map[scancode];
        } else if ((shift_lock || shift_key) && key_maps[1]) {
                keychar = key_maps[1][scancode];
        } else if (ctrl_key && key_maps[4]) {
                keychar = key_maps[4][scancode];
        } else {
                keychar = 0x0020;
                kdb_printf("Unknown state/scancode (%d)\n", scancode);
        }
        keychar &= 0x0fff;
        if (keychar == '\t')
                keychar = ' ';
        switch (KTYP(keychar)) {
        case KT_LETTER:
        case KT_LATIN:
                if (isprint(keychar))
                        break;          /* printable characters */
                fallthrough;
        case KT_SPEC:
                if (keychar == K_ENTER)
                        break;
                fallthrough;
        default:
                return -1;      /* ignore unprintables */
        }

        if (scancode == 0x1c) {
                kbd_last_ret = 1;
                return 13;
        }

        return keychar & 0xff;
}
EXPORT_SYMBOL_GPL(kdb_get_kbd_char);

/*
 * Best effort cleanup of ENTER break codes on leaving KDB. Called on
 * exiting KDB, when we know we processed an ENTER or KP ENTER scan
 * code.
 */
void kdb_kbd_cleanup_state(void)
{
        int scancode, scanstatus;

        /*
         * Nothing to clean up, since either
         * ENTER was never pressed, or has already
         * gotten cleaned up.
         */
        if (!kbd_last_ret)
                return;

        kbd_last_ret = 0;
        /*
         * Enter key. Need to absorb the break code here, lest it gets
         * leaked out if we exit KDB as the result of processing 'g'.
         *
         * This has several interesting implications:
         * + Need to handle KP ENTER, which has break code 0xe0 0x9c.
         * + Need to handle repeat ENTER and repeat KP ENTER. Repeats
         *   only get a break code at the end of the repeated
         *   sequence. This means we can't propagate the repeated key
         *   press, and must swallow it away.
         * + Need to handle possible PS/2 mouse input.
         * + Need to handle mashed keys.
         */

        while (1) {
                while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
                        cpu_relax();

                /*
                 * Fetch the scancode.
                 */
                scancode = inb(KBD_DATA_REG);
                scanstatus = inb(KBD_STATUS_REG);

                /*
                 * Skip mouse input.
                 */
                if (scanstatus & KBD_STAT_MOUSE_OBF)
                        continue;

                /*
                 * If we see 0xe0, this is either a break code for KP
                 * ENTER, or a repeat make for KP ENTER. Either way,
                 * since the second byte is equivalent to an ENTER,
                 * skip the 0xe0 and try again.
                 *
                 * If we see 0x1c, this must be a repeat ENTER or KP
                 * ENTER (and we swallowed 0xe0 before). Try again.
                 *
                 * We can also see make and break codes for other keys
                 * mashed before or after pressing ENTER. Thus, if we
                 * see anything other than 0x9c, we have to try again.
                 *
                 * Note, if you held some key as ENTER was depressed,
                 * that break code would get leaked out.
                 */
                if (scancode != 0x9c)
                        continue;

                return;
        }
}