From 4f5f1a53d449172263e83c5769c92976e0d3332e Mon Sep 17 00:00:00 2001 From: tmk Date: Sat, 29 Jan 2011 00:44:05 +0900 Subject: added PS/2 to USB converter use V-USB as protocol stack --- ps2_vusb/Makefile | 50 +++++ ps2_vusb/Makefile.orig | 165 ++++++++++++++++ ps2_vusb/config.h | 36 ++++ ps2_vusb/keyboard.h | 27 +++ ps2_vusb/keyboard_vusb.c | 156 +++++++++++++++ ps2_vusb/keymap.c | 189 ++++++++++++++++++ ps2_vusb/layer.c | 183 ++++++++++++++++++ ps2_vusb/main.c | 126 ++++++++++++ ps2_vusb/matrix.c | 492 +++++++++++++++++++++++++++++++++++++++++++++++ ps2_vusb/usart_print.c | 53 +++++ ps2_vusb/usart_print.h | 121 ++++++++++++ ps2_vusb/usbconfig.h | 373 +++++++++++++++++++++++++++++++++++ 12 files changed, 1971 insertions(+) create mode 100644 ps2_vusb/Makefile create mode 100644 ps2_vusb/Makefile.orig create mode 100644 ps2_vusb/config.h create mode 100644 ps2_vusb/keyboard.h create mode 100644 ps2_vusb/keyboard_vusb.c create mode 100644 ps2_vusb/keymap.c create mode 100644 ps2_vusb/layer.c create mode 100644 ps2_vusb/main.c create mode 100644 ps2_vusb/matrix.c create mode 100644 ps2_vusb/usart_print.c create mode 100644 ps2_vusb/usart_print.h create mode 100644 ps2_vusb/usbconfig.h (limited to 'ps2_vusb') diff --git a/ps2_vusb/Makefile b/ps2_vusb/Makefile new file mode 100644 index 0000000000..48748a7492 --- /dev/null +++ b/ps2_vusb/Makefile @@ -0,0 +1,50 @@ +# Target file name (without extension). +TARGET = ps2_vusb + +# Directory common source filess exist +COMMON_DIR = .. + +# Directory keyboard dependent files exist +TARGET_DIR = . + +# keyboard dependent files +TARGET_SRC = main.c \ + keyboard_vusb.c \ + layer.c \ + keymap.c \ + matrix.c \ + ps2.c \ + print.c \ + util.c \ + timer.c \ + usart_print.c + +OPT_DEFS = -DDEBUG_LEVEL=0 + + +# MCU name, you MUST set this to match the board you are using +# type "make clean" after changing this, so all files will be rebuilt +#MCU = at90usb162 # Teensy 1.0 +#MCU = atmega32u4 # Teensy 2.0 +#MCU = at90usb646 # Teensy++ 1.0 +#MCU = at90usb1286 # Teensy++ 2.0 +MCU = atmega168 + + +# Processor frequency. +# Normally the first thing your program should do is set the clock prescaler, +# so your program will run at the correct speed. You should also set this +# variable to same clock speed. The _delay_ms() macro uses this, and many +# examples use this variable to calculate timings. Do not add a "UL" here. +F_CPU = 16000000 + + +# Build Options +# comment out to disable the options. +# +#MOUSEKEY_ENABLE = yes # Mouse keys +#USB_EXTRA_ENABLE = yes # Enhanced feature for Windows(Audio control and System control) +#USB_NKRO_ENABLE = yes # USB Nkey Rollover + + +include $(COMMON_DIR)/Makefile.vusb diff --git a/ps2_vusb/Makefile.orig b/ps2_vusb/Makefile.orig new file mode 100644 index 0000000000..2bd1ed584e --- /dev/null +++ b/ps2_vusb/Makefile.orig @@ -0,0 +1,165 @@ +# Name: Makefile +# Project: hid-mouse example +# Author: Christian Starkjohann +# Creation Date: 2008-04-07 +# Tabsize: 4 +# Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH +# License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) +# This Revision: $Id: Makefile 692 2008-11-07 15:07:40Z cs $ + +DEVICE = atmega168 +F_CPU = 16000000 # in Hz +FUSE_L = # see below for fuse values for particular devices +FUSE_H = +#AVRDUDE = avrdude -c usbasp -p $(DEVICE) # edit this line for your programmer +AVRDUDE = avrdude -P COM1 -b 19200 -c arduino -p $(DEVICE) + +CFLAGS = -Iusbdrv -I. -DDEBUG_LEVEL=1 +OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o main.o + +COMPILE = avr-gcc -Wall -Os -DF_CPU=$(F_CPU) $(CFLAGS) -mmcu=$(DEVICE) + +############################################################################## +# Fuse values for particular devices +############################################################################## +# If your device is not listed here, go to +# http://palmavr.sourceforge.net/cgi-bin/fc.cgi +# and choose options for external crystal clock and no clock divider +# +################################## ATMega8 ################################## +# ATMega8 FUSE_L (Fuse low byte): +# 0x9f = 1 0 0 1 1 1 1 1 +# ^ ^ \ / \--+--/ +# | | | +------- CKSEL 3..0 (external >8M crystal) +# | | +--------------- SUT 1..0 (crystal osc, BOD enabled) +# | +------------------ BODEN (BrownOut Detector enabled) +# +-------------------- BODLEVEL (2.7V) +# ATMega8 FUSE_H (Fuse high byte): +# 0xc9 = 1 1 0 0 1 0 0 1 <-- BOOTRST (boot reset vector at 0x0000) +# ^ ^ ^ ^ ^ ^ ^------ BOOTSZ0 +# | | | | | +-------- BOOTSZ1 +# | | | | + --------- EESAVE (don't preserve EEPROM over chip erase) +# | | | +-------------- CKOPT (full output swing) +# | | +---------------- SPIEN (allow serial programming) +# | +------------------ WDTON (WDT not always on) +# +-------------------- RSTDISBL (reset pin is enabled) +# +############################## ATMega48/88/168 ############################## +# ATMega*8 FUSE_L (Fuse low byte): +# 0xdf = 1 1 0 1 1 1 1 1 +# ^ ^ \ / \--+--/ +# | | | +------- CKSEL 3..0 (external >8M crystal) +# | | +--------------- SUT 1..0 (crystal osc, BOD enabled) +# | +------------------ CKOUT (if 0: Clock output enabled) +# +-------------------- CKDIV8 (if 0: divide by 8) +# ATMega*8 FUSE_H (Fuse high byte): +# 0xde = 1 1 0 1 1 1 1 0 +# ^ ^ ^ ^ ^ \-+-/ +# | | | | | +------ BODLEVEL 0..2 (110 = 1.8 V) +# | | | | + --------- EESAVE (preserve EEPROM over chip erase) +# | | | +-------------- WDTON (if 0: watchdog always on) +# | | +---------------- SPIEN (allow serial programming) +# | +------------------ DWEN (debug wire enable) +# +-------------------- RSTDISBL (reset pin is enabled) +# +############################## ATTiny25/45/85 ############################### +# ATMega*5 FUSE_L (Fuse low byte): +# 0xef = 1 1 1 0 1 1 1 1 +# ^ ^ \+/ \--+--/ +# | | | +------- CKSEL 3..0 (clock selection -> crystal @ 12 MHz) +# | | +--------------- SUT 1..0 (BOD enabled, fast rising power) +# | +------------------ CKOUT (clock output on CKOUT pin -> disabled) +# +-------------------- CKDIV8 (divide clock by 8 -> don't divide) +# ATMega*5 FUSE_H (Fuse high byte): +# 0xdd = 1 1 0 1 1 1 0 1 +# ^ ^ ^ ^ ^ \-+-/ +# | | | | | +------ BODLEVEL 2..0 (brownout trigger level -> 2.7V) +# | | | | +---------- EESAVE (preserve EEPROM on Chip Erase -> not preserved) +# | | | +-------------- WDTON (watchdog timer always on -> disable) +# | | +---------------- SPIEN (enable serial programming -> enabled) +# | +------------------ DWEN (debug wire enable) +# +-------------------- RSTDISBL (disable external reset -> enabled) +# +################################ ATTiny2313 ################################# +# ATTiny2313 FUSE_L (Fuse low byte): +# 0xef = 1 1 1 0 1 1 1 1 +# ^ ^ \+/ \--+--/ +# | | | +------- CKSEL 3..0 (clock selection -> crystal @ 12 MHz) +# | | +--------------- SUT 1..0 (BOD enabled, fast rising power) +# | +------------------ CKOUT (clock output on CKOUT pin -> disabled) +# +-------------------- CKDIV8 (divide clock by 8 -> don't divide) +# ATTiny2313 FUSE_H (Fuse high byte): +# 0xdb = 1 1 0 1 1 0 1 1 +# ^ ^ ^ ^ \-+-/ ^ +# | | | | | +---- RSTDISBL (disable external reset -> enabled) +# | | | | +-------- BODLEVEL 2..0 (brownout trigger level -> 2.7V) +# | | | +-------------- WDTON (watchdog timer always on -> disable) +# | | +---------------- SPIEN (enable serial programming -> enabled) +# | +------------------ EESAVE (preserve EEPROM on Chip Erase -> not preserved) +# +-------------------- DWEN (debug wire enable) + + +# symbolic targets: +help: + @echo "This Makefile has no default rule. Use one of the following:" + @echo "make hex ....... to build main.hex" + @echo "make program ... to flash fuses and firmware" + @echo "make fuse ...... to flash the fuses" + @echo "make flash ..... to flash the firmware (use this on metaboard)" + @echo "make clean ..... to delete objects and hex file" + +hex: main.hex + +program: flash fuse + +# rule for programming fuse bits: +fuse: + @[ "$(FUSE_H)" != "" -a "$(FUSE_L)" != "" ] || \ + { echo "*** Edit Makefile and choose values for FUSE_L and FUSE_H!"; exit 1; } + $(AVRDUDE) -U hfuse:w:$(FUSE_H):m -U lfuse:w:$(FUSE_L):m + +# rule for uploading firmware: +flash: main.hex + $(AVRDUDE) -U flash:w:main.hex:i + +# rule for deleting dependent files (those which can be built by Make): +clean: + rm -f main.hex main.lst main.obj main.cof main.list main.map main.eep.hex main.elf *.o usbdrv/*.o main.s usbdrv/oddebug.s usbdrv/usbdrv.s + +# Generic rule for compiling C files: +.c.o: + $(COMPILE) -c $< -o $@ + +# Generic rule for assembling Assembler source files: +.S.o: + $(COMPILE) -x assembler-with-cpp -c $< -o $@ +# "-x assembler-with-cpp" should not be necessary since this is the default +# file type for the .S (with capital S) extension. However, upper case +# characters are not always preserved on Windows. To ensure WinAVR +# compatibility define the file type manually. + +# Generic rule for compiling C to assembler, used for debugging only. +.c.s: + $(COMPILE) -S $< -o $@ + +# file targets: + +# Since we don't want to ship the driver multipe times, we copy it into this project: +usbdrv: + cp -r ../usbdrv . + +main.elf: usbdrv $(OBJECTS) # usbdrv dependency only needed because we copy it + $(COMPILE) -o main.elf $(OBJECTS) + +main.hex: main.elf + rm -f main.hex main.eep.hex + avr-objcopy -j .text -j .data -O ihex main.elf main.hex + avr-size main.hex + +# debugging targets: + +disasm: main.elf + avr-objdump -d main.elf + +cpp: + $(COMPILE) -E main.c diff --git a/ps2_vusb/config.h b/ps2_vusb/config.h new file mode 100644 index 0000000000..1d2a283071 --- /dev/null +++ b/ps2_vusb/config.h @@ -0,0 +1,36 @@ +#ifndef CONFIG_H +#define CONFIG_H + + +#define VENDOR_ID 0xFEED +#define PRODUCT_ID 0x6512 +#define MANUFACTURER t.m.k. +#define PRODUCT PS/2 keyboard converter +#define DESCRIPTION convert PS/2 keyboard to USB + +/* matrix size */ +#define MATRIX_ROWS 32 // keycode bit: 3-0 +#define MATRIX_COLS 8 // keycode bit: 6-4 +/* define if matrix has ghost */ +//#define MATRIX_HAS_GHOST + +/* USB NKey Rollover */ +#ifdef USB_NKRO_ENABLE +#endif + +/* mouse keys */ +#ifdef MOUSEKEY_ENABLE +# define MOUSEKEY_DELAY_TIME 255 +#endif + +/* PS/2 mouse */ +#define PS2_CLOCK_PORT PORTD +#define PS2_CLOCK_PIN PIND +#define PS2_CLOCK_DDR DDRD +#define PS2_CLOCK_BIT 6 +#define PS2_DATA_PORT PORTD +#define PS2_DATA_PIN PIND +#define PS2_DATA_DDR DDRD +#define PS2_DATA_BIT 7 + +#endif diff --git a/ps2_vusb/keyboard.h b/ps2_vusb/keyboard.h new file mode 100644 index 0000000000..87c61139b9 --- /dev/null +++ b/ps2_vusb/keyboard.h @@ -0,0 +1,27 @@ +#ifndef KEYBOARD_H +#define KEYBOARD_H + +#include "stdbool.h" + + +#define REPORT_KEYS 6 +typedef struct{ + uint8_t mods; + uint8_t rserved; // not used + uint8_t keys[REPORT_KEYS]; +}report_t; + + +//extern report_t *report; +//extern report_t *report_prev; + +report_t *report_get(void); +bool report_has_key(void); +void report_send(void); +void report_add_mod(uint8_t mod); +void report_add_key(uint8_t key); +void report_add_code(uint8_t code); +void report_swap(void); +void report_clear(void); + +#endif diff --git a/ps2_vusb/keyboard_vusb.c b/ps2_vusb/keyboard_vusb.c new file mode 100644 index 0000000000..6ea1957590 --- /dev/null +++ b/ps2_vusb/keyboard_vusb.c @@ -0,0 +1,156 @@ +#include "usbdrv.h" +#include "usb_keycodes.h" +#include "keyboard.h" +#include "print.h" + +static report_t report0; +static report_t report1; +static report_t *report = &report0; +static report_t *report_prev = &report1; + +void report_send(void) +{ + if (usbInterruptIsReady()){ + usbSetInterrupt((void *)report, sizeof(*report)); + } +} + +report_t *report_get(void) +{ + return report; +} + +uint8_t report_mods(void) +{ + return report->mods; +} + +uint8_t *report_keys(void) +{ + return report->keys; +} + +bool report_has_key(void) +{ + for (int i = 0; i < REPORT_KEYS; i++) { + if (report->keys[i]) + return true; + } + return false; +} + +void report_add_mod(uint8_t mod) +{ + report->mods |= mod; +} + +void report_add_key(uint8_t code) +{ + int8_t i = 0; + int8_t empty = -1; + for (; i < REPORT_KEYS; i++) { + if (report_prev->keys[i] == code) { + report->keys[i] = code; + break; + } + if (empty == -1 && report_prev->keys[i] == KB_NO && report->keys[i] == KB_NO) { + empty = i; + } + } + if (i == REPORT_KEYS && empty != -1) { + report->keys[empty] = code; + } +} + +void report_add_code(uint8_t code) +{ + if (IS_MOD(code)) { + report_add_mod(code); + } else { + report_add_key(code); + } +} + +void report_swap(void) +{ + report_t *tmp = report_prev; + report_prev = report; + report = tmp; +} + +void report_clear(void) +{ + report->mods = 0; + for (int8_t i = 0; i < REPORT_KEYS; i++) { + report->keys[i] = 0; + } +} + + +static uchar idleRate; /* repeat rate for keyboards, never used for mice */ +usbMsgLen_t usbFunctionSetup(uchar data[8]) +{ +usbRequest_t *rq = (void *)data; + + print("Setup: "); + if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ /* class request type */ + print("CLASS: "); + phex(rq->bRequest); + if(rq->bRequest == USBRQ_HID_GET_REPORT){ + print("GET_REPORT"); + /* we only have one report type, so don't look at wValue */ + usbMsgPtr = (void *)report; + return sizeof(*report); + }else if(rq->bRequest == USBRQ_HID_GET_IDLE){ + print("GET_IDLE: "); + phex(idleRate); + usbMsgPtr = &idleRate; + return 1; + }else if(rq->bRequest == USBRQ_HID_SET_IDLE){ + idleRate = rq->wValue.bytes[1]; + print("SET_IDLE: "); + phex(idleRate); + } + print("\n"); + }else{ + print("VENDOR\n"); + /* no vendor specific requests implemented */ + } + return 0; /* default for not implemented requests: return no data back to host */ +} + + +PROGMEM char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = { + 0x05, 0x01, // Usage Page (Generic Desktop), + 0x09, 0x06, // Usage (Keyboard), + 0xA1, 0x01, // Collection (Application), + 0x75, 0x01, // Report Size (1), + 0x95, 0x08, // Report Count (8), + 0x05, 0x07, // Usage Page (Key Codes), + 0x19, 0xE0, // Usage Minimum (224), + 0x29, 0xE7, // Usage Maximum (231), + 0x15, 0x00, // Logical Minimum (0), + 0x25, 0x01, // Logical Maximum (1), + 0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte + 0x95, 0x01, // Report Count (1), + 0x75, 0x08, // Report Size (8), + 0x81, 0x03, // Input (Constant), ;Reserved byte + 0x95, 0x05, // Report Count (5), + 0x75, 0x01, // Report Size (1), + 0x05, 0x08, // Usage Page (LEDs), + 0x19, 0x01, // Usage Minimum (1), + 0x29, 0x05, // Usage Maximum (5), + 0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report + 0x95, 0x01, // Report Count (1), + 0x75, 0x03, // Report Size (3), + 0x91, 0x03, // Output (Constant), ;LED report padding + 0x95, 0x06, // Report Count (6), + 0x75, 0x08, // Report Size (8), + 0x15, 0x00, // Logical Minimum (0), + 0x25, 0xFF, // Logical Maximum(255), + 0x05, 0x07, // Usage Page (Key Codes), + 0x19, 0x00, // Usage Minimum (0), + 0x29, 0xFF, // Usage Maximum (255), + 0x81, 0x00, // Input (Data, Array), + 0xc0 // End Collection +}; diff --git a/ps2_vusb/keymap.c b/ps2_vusb/keymap.c new file mode 100644 index 0000000000..47db18bfa1 --- /dev/null +++ b/ps2_vusb/keymap.c @@ -0,0 +1,189 @@ +/* + * Keymap for PS/2 keyboard + */ +#include +#include +#include +#include "usb_keyboard.h" +#include "usb_keycodes.h" +#include "print.h" +#include "debug.h" +#include "util.h" +#include "keymap_skel.h" + + +#define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) + +// Convert physical keyboard layout to matrix array. +// This is a macro to define keymap easily in keyboard layout form. +#define KEYMAP( \ + K76, K05,K06,K04,K0C, K03,K0B,K83,K0A, K01,K09,K78,K07, KFC,K7E,KFE, KB7,KBF,KDE, \ + K0E,K16,K1E,K26,K25,K2E,K36,K3D,K3E,K46,K45,K4E,K55,K66, KF0,KEC,KFD, K77,KCA,K7C,K7B, \ + K0D,K15,K1D,K24,K2D,K2C,K35,K3C,K43,K44,K4D,K54,K5B,K5D, KF1,KE9,KFA, K6C,K75,K7D, \ + K58,K1C,K1B,K23,K2B,K34,K33,K3B,K42,K4B,K4C,K52, K5A, K6B,K73,K74,K79, \ + K12,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K59, KF5, K69,K72,K7A, \ + K14,K9F,K11, K29, K91,KA7,KAF,K94, KEB,KF2,KF4, K70, K71,KDA \ +) { \ + { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ + { KB_NO, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \ + { KB_NO, KB_##K11, KB_##K12, KB_NO, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \ + { KB_NO, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \ + { KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ + { KB_NO, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \ + { KB_NO, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ + { KB_NO, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ + { KB_NO, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ + { KB_NO, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ + { KB_NO, KB_NO, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_NO }, \ + { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K66, KB_NO }, \ + { KB_NO, KB_##K69, KB_NO, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ + { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ + { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KAF }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KB7 }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KBF }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \ + { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ + { KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \ + { KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \ + { KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \ +} + + +// Assign Fn key(0-7) to a layer to which switch with the Fn key pressed. +static const uint8_t PROGMEM fn_layer[] = { + 5, // Fn0 + 6, // Fn1 + 5, // Fn2 + 0, // Fn3 + 0, // Fn4 + 0, // Fn5 + 0, // Fn6 + 0 // Fn7 +}; + +// Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. +// See layer.c for details. +static const uint8_t PROGMEM fn_keycode[] = { + KB_SCLN, // Fn0 + KB_SLSH, // Fn1 + KB_A, // Fn2 + KB_NO, // Fn3 + KB_NO, // Fn4 + KB_NO, // Fn5 + KB_NO, // Fn6 + KB_NO // Fn7 +}; + +static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + /* keymap + * ,---. ,---------------. ,---------------. ,---------------. ,-----------. ,-----------. + * |Esc| |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| |Pwr|Slp|Wak| + * `---' `---------------' `---------------' `---------------' `-----------' `-----------' + * ,-----------------------------------------------------------. ,-----------. ,---------------. + * | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backspa| |Ins|Hom|PgU| |NmL| /| *| -| + * |-----------------------------------------------------------| |-----------| |---------------| + * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \| |Del|End|PgD| | 7| 8| 9| | + * |-----------------------------------------------------------| `-----------' |-----------| +| + * |CapsLo| A| S| D| F| G| H| J| K| L| ;| '|Return | | 4| 5| 6| | + * |-----------------------------------------------------------| ,---. |---------------| + * |Shift | Z| X| C| V| B| N| M| ,| ,| /|Shift | |Up | | 1| 2| 3| | + * |-----------------------------------------------------------| ,-----------. |-----------|Ent| + * |Ctrl |Gui |Alt | Space |Alt |Gui |Menu|Ctrl| |Lef|Dow|Rig| | 0| .| | + * `-----------------------------------------------------------' `-----------' `---------------' + */ + /* 0: default */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, + CAPS,FN2, S, D, F, G, H, J, K, L, FN0, QUOT, ENT, P4, P5, P6, PPLS, + LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 1: plain Qwerty without layer switching */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, + CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS, + LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 2: Colemak http://colemak.com */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, Q, W, F, P, G, J, L, U, Y, SCLN,LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, + BSPC,A, R, S, T, D, H, N, E, I, O, QUOT, ENT, P4, P5, P6, PPLS, + LSFT,Z, X, C, V, B, K, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 3: Dvorak http://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, DEL, END, PGDN, P7, P8, P9, + CAPS,A, O, E, U, I, D, H, T, N, S, MINS, ENT, P4, P5, P6, PPLS, + LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 4: Workman http://viralintrospection.wordpress.com/2010/09/06/a-different-philosophy-in-designing-keyboard-layouts/ */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, Q, D, R, W, B, J, F, U, P, SCLN,LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, + BSPC,A, S, H, T, G, Y, N, E, O, I, QUOT, ENT, P4, P5, P6, PPLS, + LSFT,Z, X, M, C, V, K, L, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 5: Mouse keys */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F8, F10, F11, F12, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, WH_L,WH_D,MS_U,WH_U,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSLS, DEL, END, PGDN, P7, P8, P9, + CAPS,FN2, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN0, NO, ENT, P4, P5, P6, PPLS, + LSFT,VOLD,VOLU,MUTE,BTN2,BTN3,BTN2,BTN1,VOLD,VOLU,MUTE, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, BTN1, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), + /* 6: Cursor keys */ + KEYMAP( + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, PWR, F13, F14, + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F8, F10, F11, F12, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, + TAB, NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, NO, NO, NO, BSLS, DEL, END, PGDN, P7, P8, P9, + CAPS,NO, NO, NO, NO, NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, P4, P5, P6, PPLS, + LSFT,VOLD,VOLU,MUTE,NO, NO, HOME,PGDN,PGUP,END, FN1, RSFT, UP, P1, P2, P3, + LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + ), +}; + + +uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col) +{ + return KEYCODE(layer, row, col); +} + +uint8_t keymap_fn_layer(uint8_t fn_bits) +{ + return pgm_read_byte(&fn_layer[biton(fn_bits)]); +} + +uint8_t keymap_fn_keycode(uint8_t fn_bits) +{ + return pgm_read_byte(&fn_keycode[(biton(fn_bits))]); +} + +// define a condition to enter special function mode +bool keymap_is_special_mode(uint8_t fn_bits) +{ + return usb_keyboard_mods == (BIT_LSHIFT | BIT_RSHIFT) || usb_keyboard_mods == (BIT_LCTRL | BIT_RSHIFT); +} diff --git a/ps2_vusb/layer.c b/ps2_vusb/layer.c new file mode 100644 index 0000000000..e4132badec --- /dev/null +++ b/ps2_vusb/layer.c @@ -0,0 +1,183 @@ +#include "keymap_skel.h" +#include "keyboard.h" +#include "debug.h" +#include "timer.h" +#include "layer.h" + +/* + * Parameters: + * ENTER_DELAY |=======| + * SEND_FN_TERM |================| + * + * Fn key processing cases: + * 1. release Fn after SEND_FN_TERM. + * Layer sw ___________|~~~~~~~~~~~|___ + * Fn press ___|~~~~~~~~~~~~~~~~~~~|___ + * Fn send ___________________________ + * + * 2. release Fn during SEND_FN_TERM.(not layer used) + * Layer sw ___________|~~~~~~|________ + * Fn press ___|~~~~~~~~~~~~~~|________ + * Fn key send __________________|~|______ + * other key press ___________________________ + * other key send ___________________________ + * + * 3. release Fn during SEND_FN_TERM.(layer used) + * Layer sw ___________|~~~~~~|________ + * Fn press ___|~~~~~~~~~~~~~~|________ + * Fn key send ___________________________ + * Fn send ___________________________ + * other key press _____________|~~|__________ + * other key send _____________|~~|__________ + * + * 4. press other key during ENTER_DELAY. + * Layer sw ___________________________ + * Fn key press ___|~~~~~~~~~|_____________ + * Fn key send ______|~~~~~~|_____________ + * other key press ______|~~~|________________ + * other key send _______|~~|________________ + * + * 5. press Fn while press other key. + * Layer sw ___________________________ + * Fn key press ___|~~~~~~~~~|_____________ + * Fn key send ___|~~~~~~~~~|_____________ + * other key press ~~~~~~~|___________________ + * other key send ~~~~~~~|___________________ + * + * 6. press Fn twice quickly and keep holding down.(repeat) + * Layer sw ___________________________ + * Fn key press ___|~|____|~~~~~~~~~~~~~~~~ + * Fn key send _____|~|__|~~~~~~~~~~~~~~~~ + */ + +// LAYER_ENTER_DELAY: prevent from moving new layer +#define LAYER_ENTER_DELAY 10 + +// LAYER_SEND_FN_TERM: send keycode if release key in this term +#define LAYER_SEND_FN_TERM 40 + + +uint8_t default_layer = 0; +uint8_t current_layer = 0; + +static bool layer_used = false; +static uint8_t new_layer(uint8_t fn_bits); + + +uint8_t layer_get_keycode(uint8_t row, uint8_t col) +{ + uint8_t code = keymap_get_keycode(current_layer, row, col); + // normal key or mouse key + if ((IS_KEY(code) || IS_MOUSEKEY(code))) { + layer_used = true; + } + return code; +} + +// bit substract b from a +#define BIT_SUBT(a, b) (a&(a^b)) +void layer_switching(uint8_t fn_bits) +{ + // layer switching + static uint8_t last_fn = 0; + static uint8_t last_mods = 0; + static uint16_t last_timer = 0; + static uint8_t sent_fn = 0; + + if (fn_bits == last_fn) { // Fn state is not changed + if (fn_bits == 0) { + // do nothing + } else { + if (timer_elapsed(last_timer) > LAYER_ENTER_DELAY) { + uint8_t _layer_to_switch = new_layer(BIT_SUBT(fn_bits, sent_fn)); + if (current_layer != _layer_to_switch) { // not switch layer yet + debug("Fn case: 1,2,3(LAYER_ENTER_DELAY passed)\n"); + debug("Switch Layer: "); debug_hex(current_layer); + current_layer = _layer_to_switch; + layer_used = false; + debug(" -> "); debug_hex(current_layer); debug("\n"); + } + } else { + if (report_has_key()) { // other keys is pressed + uint8_t _fn_to_send = BIT_SUBT(fn_bits, sent_fn); + if (_fn_to_send) { + debug("Fn case: 4(send Fn before other key pressed)\n"); + // send only Fn key first + report_swap(); + report_clear(); + report_add_code(keymap_fn_keycode(_fn_to_send)); // TODO: do all Fn keys + report_add_mod(last_mods); + report_send(); + report_swap(); + sent_fn |= _fn_to_send; + } + } + } + // add Fn keys to send + //report_add_code(keymap_fn_keycode(fn_bits&sent_fn)); // TODO: do all Fn keys + } + } else { // Fn state is changed(edge) + uint8_t fn_changed = 0; + + debug("fn_bits: "); debug_bin(fn_bits); debug("\n"); + debug("sent_fn: "); debug_bin(sent_fn); debug("\n"); + debug("last_fn: "); debug_bin(last_fn); debug("\n"); + debug("last_mods: "); debug_hex(last_mods); debug("\n"); + debug("last_timer: "); debug_hex16(last_timer); debug("\n"); + + // pressed Fn + if ((fn_changed = BIT_SUBT(fn_bits, last_fn))) { + debug("fn_changed: "); debug_bin(fn_changed); debug("\n"); + if (report_has_key()) { + debug("Fn case: 5(pressed Fn with other key)\n"); + sent_fn |= fn_changed; + } else if (fn_changed & sent_fn) { // pressed same Fn in a row + if (timer_elapsed(last_timer) > LAYER_ENTER_DELAY) { + debug("Fn case: 6(repate2)\n"); + // time passed: not repeate + sent_fn &= ~fn_changed; + } else { + debug("Fn case: 6(repate)\n"); + } + } + } + // released Fn + if ((fn_changed = BIT_SUBT(last_fn, fn_bits))) { + debug("fn_changed: "); debug_bin(fn_changed); debug("\n"); + if (timer_elapsed(last_timer) < LAYER_SEND_FN_TERM) { + //if (!layer_used && BIT_SUBT(fn_changed, sent_fn)) { // layer not used && Fn not sent + if (BIT_SUBT(fn_changed, sent_fn)) { // layer not used && Fn not sent + debug("Fn case: 2(send Fn one shot: released Fn during LAYER_SEND_FN_TERM)\n"); + // send only Fn key first + report_swap(); + report_clear(); + report_add_code(keymap_fn_keycode(fn_changed)); // TODO: do all Fn keys + report_add_mod(last_mods); + report_send(); + report_swap(); + sent_fn |= fn_changed; + } + } + debug("Switch Layer(released Fn): "); debug_hex(current_layer); + current_layer = new_layer(BIT_SUBT(fn_bits, sent_fn)); + layer_used = false; + debug(" -> "); debug_hex(current_layer); debug("\n"); + } + + last_fn = fn_bits; + last_mods = report_get()->mods; + last_timer = timer_read(); + } + // send Fn keys + for (uint8_t i = 0; i < 8; i++) { + if ((sent_fn & fn_bits) & (1< +#include +#include +#include /* for sei() */ +#include /* for _delay_ms() */ + +#include /* required by usbdrv.h */ +#include "usbdrv.h" +#include "usart_print.h" /* This is also an example for using debug macros */ +#include "ps2.h" +#include "usb_keycodes.h" +#include "matrix_skel.h" +#include "keymap_skel.h" +#include "layer.h" +#include "print.h" +#include "debug.h" +#include "sendchar.h" +#include "keyboard.h" +#include "timer.h" + +/* ------------------------------------------------------------------------- */ +/* ----------------------------- USB interface ----------------------------- */ +/* ------------------------------------------------------------------------- */ + + + + + + +int main(void) +{ +uchar i; + +print_enable = true; +debug_enable = true; +timer_init(); +matrix_init(); + + wdt_enable(WDTO_1S); + /* Even if you don't use the watchdog, turn it off here. On newer devices, + * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! + */ + /* RESET status: all port bits are inputs without pull-up. + * That's the way we need D+ and D-. Therefore we don't need any + * additional hardware initialization. + */ + odDebugInit(); + DBG1(0x00, 0, 0); /* debug output: main starts */ + usbInit(); + usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ + i = 0; + while(--i){ /* fake USB disconnect for > 250 ms */ + wdt_reset(); + _delay_ms(1); + } + usbDeviceConnect(); + sei(); + + uint8_t fn_bits = 0; + while (1) { /* main event loop */ + DBG1(0x02, 0, 0); /* debug output: main loop iterates */ + wdt_reset(); + usbPoll(); + +/* +static uint8_t code = 0; +code = ps2_host_recv(); +if (code) { + odDebug(0x05, &code, 1); +} +*/ + matrix_scan(); + if (matrix_is_modified()) { + //matrix_print(); // too heavy on USART + fn_bits = 0; + report_swap(); + report_clear(); + for (int row = 0; row < matrix_rows(); row++) { + for (int col = 0; col < matrix_cols(); col++) { + if (!matrix_is_on(row, col)) continue; + + uint8_t code = layer_get_keycode(row, col); + if (code == KB_NO) { + // do nothing + } + else if (IS_MOD(code)) { + report_add_mod(MOD_BIT(code)); + } + else if (IS_KEY(code)) { + report_add_key(code); + } + else if (IS_FN(code)) { + fn_bits |= FN_BIT(code); + } + else { + debug("ignore keycode: "); debug_hex(code); debug("\n"); + } + } + } + } + layer_switching(fn_bits); + if (matrix_is_modified()) { + report_send(); + } + } +} diff --git a/ps2_vusb/matrix.c b/ps2_vusb/matrix.c new file mode 100644 index 0000000000..c464733929 --- /dev/null +++ b/ps2_vusb/matrix.c @@ -0,0 +1,492 @@ +/* + * scan matrix + */ +#include +#include +#include +#include +#include "print.h" +#include "util.h" +#include "debug.h" +#include "ps2.h" +#include "usb_keyboard.h" +#include "matrix_skel.h" + + +#if (MATRIX_COLS > 16) +# error "MATRIX_COLS must not exceed 16" +#endif +#if (MATRIX_ROWS > 255) +# error "MATRIX_ROWS must not exceed 255" +#endif + + +/* + * Matrix usage: + * "PS/2 Scan Codes Set 2" is assigned to 256(32x8)cells matrix. + * Hmm, It is very sparse and not efficient :( + * + * 8bit + * --------- + * 0| | + * :| XX | 00-7F for normal codes(without E0-prefix) + * f|_________| + * 10| | + * :| E0 XX | 80-FF for E0-prefix codes(use (XX|0x80) as code) + * 1f| | + * --------- + * exceptions: + * 83: F8[0x83](normal codes but > 0x7F) + * FC: PrintScreen[E0 7C or 84] + * FE: Puause + */ +#define F8 (0x83) +#define PRINT_SCREEN (0xFC) +#define PAUSE (0xFE) +#define ROW(code) (code>>3) +#define COL(code) (code&0x07) + +static bool is_modified = false; + +// matrix state buffer(1:on, 0:off) +#if (MATRIX_COLS <= 8) +static uint8_t matrix[MATRIX_ROWS]; +#else +static uint16_t matrix[MATRIX_ROWS]; +#endif + +#ifdef MATRIX_HAS_GHOST +static bool matrix_has_ghost_in_row(uint8_t row); +#endif +static void matrix_make(uint8_t code); +static void matrix_break(uint8_t code); +static void ps2_reset(void); +static void ps2_set_leds(uint8_t leds); + + +inline +uint8_t matrix_rows(void) +{ + return MATRIX_ROWS; +} + +inline +uint8_t matrix_cols(void) +{ + return MATRIX_COLS; +} + +void matrix_init(void) +{ + ps2_host_init(); + _delay_ms(1000); + + // flush LEDs +/* + ps2_set_leds(1< | + * LShift | E0 F0 12 | E0 12 + * RShift | E0 F0 59 | E0 59 + * L+RShift | E0 F0 12 E0 F0 59 | E0 59 E0 12 + * + * Num Lock: on + * modifiers | make | break + * ----------+---------------------------+---------------------- + * Other | E0 12 | E0 F0 12 + * Shift'd | | + * + * Handling: ignore these prefix/postfix codes + * + * + * Keypad-/: + * modifiers | make | break + * ----------+---------------------------+---------------------- + * Ohter | | + * LShift | E0 F0 12 | E0 12 + * RShift | E0 F0 59 | E0 59 + * L+RShift | E0 F0 12 E0 F0 59 | E0 59 E0 12 + * + * Handling: ignore these prefix/postfix codes + * + * + * PrintScreen: + * With hoding down modifiers, the scan code is sent as following: + * + * modifiers | make | break + * ----------+--------------+----------------------------------- + * Other | E0 12 E0 7C | E0 F0 7C E0 F0 12 + * Shift'd | E0 7C | E0 F0 7C + * Control'd | E0 7C | E0 F0 7C + * Alt'd | 84 | F0 84 + * + * Handling: ignore prefix/postfix codes and treat both scan code + * E0 7C and 84 as PrintScreen. + * + * Pause: + * With hoding down modifiers, the scan code is sent as following: + * + * modifiers | make(no break code) + * ----------+-------------------------------------------------- + * no mods | E1 14 77 E1 F0 14 F0 77 + * Control'd | E0 7E E0 F0 7E + * + * Handling: treat these two code sequence as Pause + * + */ +uint8_t matrix_scan(void) +{ + + static enum { + INIT, + F0, + E0, + E0_F0, + // states for Pause/Break + E1, + E1_14, + E1_14_77, + E1_14_77_E1, + E1_14_77_E1_F0, + E1_14_77_E1_F0_14, + E1_14_77_E1_F0_14_F0, + } state = INIT; + + + is_modified = false; + + // Pause/Break off(PS/2 has no break for this key) + if (matrix_is_on(ROW(PAUSE), COL(PAUSE))) { + matrix_break(PAUSE); + } + + uint8_t code; + while ((code = ps2_host_recv())) { +//debug_hex(code); debug(" "); + switch (state) { + case INIT: + switch (code) { + case 0xE0: // 2byte make + state = E0; + break; + case 0xF0: // break code + state = F0; + break; + case 0xE1: // Pause/Break + state = E1; + break; + case 0x83: // F8 + matrix_make(F8); + state = INIT; + break; + case 0x84: // PrintScreen + matrix_make(PRINT_SCREEN); + state = INIT; + break; + default: // normal key make + if (code < 0x80) { + matrix_make(code); + } else { + debug("unexpected scan code at INIT: "); debug_hex(code); debug("\n"); + } + state = INIT; + } + break; + case E0: + switch (code) { + case 0x12: // postfix/postfix code for exceptional keys + case 0x59: // postfix/postfix code for exceptional keys + // ignore + state = INIT; + break; + case 0x7E: // former part of Control-Pause[E0 7E E0 F0 7E] + matrix_make(PAUSE); + state = INIT; + break; + case 0xF0: // E0 break + state = E0_F0; + break; + default: // E0 make + if (code < 0x80) { + matrix_make(code|0x80); + } else { + debug("unexpected scan code at E0: "); debug_hex(code); debug("\n"); + } + state = INIT; + } + break; + case F0: + switch (code) { + case 0x83: + matrix_break(F8); + state = INIT; + break; + case 0x84: + matrix_break(PRINT_SCREEN); + state = INIT; + break; + default: + if (code < 0x80) { + matrix_break(code); + } else { + debug("unexpected scan code at F0: "); debug_hex(code); debug("\n"); + } + state = INIT; + } + break; + case E0_F0: // E0 break + switch (code) { + case 0x12: // postfix/postfix code for exceptional keys + case 0x59: // postfix/postfix code for exceptional keys + case 0x7E: // latter part of Control-Pause[E0 7E E0 F0 7E] + // ignore + state = INIT; + break; + default: + if (code < 0x80) { + matrix_break(code|0x80); + } else { + debug("unexpected scan code at E0_F0: "); debug_hex(code); debug("\n"); + } + state = INIT; + } + break; + /* Pause */ + case E1: + switch (code) { + case 0x14: + state = E1_14; + break; + default: + state = INIT; + } + break; + case E1_14: + switch (code) { + case 0x77: + state = E1_14_77; + break; + default: + state = INIT; + } + break; + case E1_14_77: + switch (code) { + case 0xE1: + state = E1_14_77_E1; + break; + default: + state = INIT; + } + break; + case E1_14_77_E1: + switch (code) { + case 0xF0: + state = E1_14_77_E1_F0; + break; + default: + state = INIT; + } + break; + case E1_14_77_E1_F0: + switch (code) { + case 0x14: + state = E1_14_77_E1_F0_14; + break; + default: + state = INIT; + } + break; + case E1_14_77_E1_F0_14: + switch (code) { + case 0xF0: + state = E1_14_77_E1_F0_14_F0; + break; + default: + state = INIT; + } + break; + case E1_14_77_E1_F0_14_F0: + switch (code) { + case 0x77: + matrix_make(PAUSE); + state = INIT; + break; + default: + state = INIT; + } + break; + default: + state = INIT; + } + } + + // handle LED indicators +/* + static uint8_t prev_leds = 0; + if (prev_leds != usb_keyboard_leds) { + uint8_t leds = 0; + if (usb_keyboard_leds&(1<= 10) + h += 'a' - (uchar)10 - '0'; + h += '0'; + return h; +} + +void printHex(uchar c) +{ + uartPutc(hexAscii(c >> 4)); + uartPutc(hexAscii(c)); +} + +void odDebug(uchar prefix, uchar *data, uchar len) +{ + printHex(prefix); + uartPutc(':'); + while(len--){ + uartPutc(' '); + printHex(*data++); + } + uartPutc('\r'); + uartPutc('\n'); +} diff --git a/ps2_vusb/usart_print.h b/ps2_vusb/usart_print.h new file mode 100644 index 0000000000..e6e83a0814 --- /dev/null +++ b/ps2_vusb/usart_print.h @@ -0,0 +1,121 @@ +/* Name: oddebug.h + * Project: AVR library + * Author: Christian Starkjohann + * Creation Date: 2005-01-16 + * Tabsize: 4 + * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH + * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) + * This Revision: $Id: oddebug.h 692 2008-11-07 15:07:40Z cs $ + */ + +#ifndef __oddebug_h_included__ +#define __oddebug_h_included__ + +/* +General Description: +This module implements a function for debug logs on the serial line of the +AVR microcontroller. Debugging can be configured with the define +'DEBUG_LEVEL'. If this macro is not defined or defined to 0, all debugging +calls are no-ops. If it is 1, DBG1 logs will appear, but not DBG2. If it is +2, DBG1 and DBG2 logs will be printed. + +A debug log consists of a label ('prefix') to indicate which debug log created +the output and a memory block to dump in hex ('data' and 'len'). +*/ + + +#ifndef F_CPU +# define F_CPU 12000000 /* 12 MHz */ +#endif + +/* make sure we have the UART defines: */ +#include "usbportability.h" + +#ifndef uchar +# define uchar unsigned char +#endif + +#if DEBUG_LEVEL > 0 && !(defined TXEN || defined TXEN0) /* no UART in device */ +# warning "Debugging disabled because device has no UART" +# undef DEBUG_LEVEL +#endif + +#ifndef DEBUG_LEVEL +# define DEBUG_LEVEL 0 +#endif + +/* ------------------------------------------------------------------------- */ + +#if DEBUG_LEVEL > 0 +# define DBG1(prefix, data, len) odDebug(prefix, data, len) +#else +# define DBG1(prefix, data, len) +#endif + +#if DEBUG_LEVEL > 1 +# define DBG2(prefix, data, len) odDebug(prefix, data, len) +#else +# define DBG2(prefix, data, len) +#endif + +/* ------------------------------------------------------------------------- */ + +extern void odDebug(uchar prefix, uchar *data, uchar len); +void uartPutc(char c); +void printHex(uchar c); + +/* Try to find our control registers; ATMEL likes to rename these */ + +#if defined UBRR +# define ODDBG_UBRR UBRR +#elif defined UBRRL +# define ODDBG_UBRR UBRRL +#elif defined UBRR0 +# define ODDBG_UBRR UBRR0 +#elif defined UBRR0L +# define ODDBG_UBRR UBRR0L +#endif + +#if defined UCR +# define ODDBG_UCR UCR +#elif defined UCSRB +# define ODDBG_UCR UCSRB +#elif defined UCSR0B +# define ODDBG_UCR UCSR0B +#endif + +#if defined TXEN +# define ODDBG_TXEN TXEN +#else +# define ODDBG_TXEN TXEN0 +#endif + +#if defined USR +# define ODDBG_USR USR +#elif defined UCSRA +# define ODDBG_USR UCSRA +#elif defined UCSR0A +# define ODDBG_USR UCSR0A +#endif + +#if defined UDRE +# define ODDBG_UDRE UDRE +#else +# define ODDBG_UDRE UDRE0 +#endif + +#if defined UDR +# define ODDBG_UDR UDR +#elif defined UDR0 +# define ODDBG_UDR UDR0 +#endif + +static inline void odDebugInit(void) +{ + ODDBG_UCR |= (1<