Add keyboard/lufa macway keyobard with LUFA. Add new program target to rule.mk; flip, dfu and teensy

12 years ago · dd93d2915f
--- a/keyboard/lufa/Descriptors.c
+++ b/keyboard/lufa/Descriptors.c
@@ -0,0 +1,359 @@
 /* 
 LUFA Library 
 Copyright (C) Dean Camera, 2012. 
 
 dean [at] fourwalledcubicle [dot] com 
 www.lufa-lib.org 
 */ 
 
 /* 
 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com) 
 Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com) 
 
 Permission to use, copy, modify, distribute, and sell this 
 software and its documentation for any purpose is hereby granted 
 without fee, provided that the above copyright notice appear in 
 all copies and that both that the copyright notice and this 
 permission notice and warranty disclaimer appear in supporting 
 documentation, and that the name of the author not be used in 
 advertising or publicity pertaining to distribution of the 
 software without specific, written prior permission. 
 
 The author disclaim all warranties with regard to this 
 software, including all implied warranties of merchantability 
 and fitness. In no event shall the author be liable for any 
 special, indirect or consequential damages or any damages 
 whatsoever resulting from loss of use, data or profits, whether 
 in an action of contract, negligence or other tortious action, 
 arising out of or in connection with the use or performance of 
 this software. 
 */ 
 
 /** \file 
 * 
 * USB Device Descriptors, for library use when in USB device mode. Descriptors are special 
 * computer-readable structures which the host requests upon device enumeration, to determine 
 * the device's capabilities and functions. 
 */ 
 
 #include "Descriptors.h" 
 
 /** HID class report descriptor. This is a special descriptor constructed with values from the 
 * USBIF HID class specification to describe the reports and capabilities of the HID device. This 
 * descriptor is parsed by the host and its contents used to determine what data (and in what encoding) 
 * the device will send, and what it may be sent back from the host. Refer to the HID specification for 
 * more details on HID report descriptors. 
 * 
 * This descriptor describes the mouse HID interface's report structure. 
 */ 
 const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] = 
 { 
 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */ 
 HID_RI_USAGE(8, 0x02), /* Mouse */ 
 HID_RI_COLLECTION(8, 0x01), /* Application */ 
 HID_RI_USAGE(8, 0x01), /* Pointer */ 
 HID_RI_COLLECTION(8, 0x00), /* Physical */ 
 HID_RI_USAGE_PAGE(8, 0x09), /* Button */ 
 HID_RI_USAGE_MINIMUM(8, 0x01), 
 HID_RI_USAGE_MAXIMUM(8, 0x03), 
 HID_RI_LOGICAL_MINIMUM(8, 0x00), 
 HID_RI_LOGICAL_MAXIMUM(8, 0x01), 
 HID_RI_REPORT_COUNT(8, 0x03), 
 HID_RI_REPORT_SIZE(8, 0x01), 
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE), 
 HID_RI_REPORT_COUNT(8, 0x01), 
 HID_RI_REPORT_SIZE(8, 0x05), 
 HID_RI_INPUT(8, HID_IOF_CONSTANT), 
 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */ 
 HID_RI_USAGE(8, 0x30), /* Usage X */ 
 HID_RI_USAGE(8, 0x31), /* Usage Y */ 
 HID_RI_LOGICAL_MINIMUM(8, -1), 
 HID_RI_LOGICAL_MAXIMUM(8, 1), 
 HID_RI_PHYSICAL_MINIMUM(8, -1), 
 HID_RI_PHYSICAL_MAXIMUM(8, 1), 
 HID_RI_REPORT_COUNT(8, 0x02), 
 HID_RI_REPORT_SIZE(8, 0x08), 
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE), 
 HID_RI_END_COLLECTION(0), 
 HID_RI_END_COLLECTION(0), 
 }; 
 
 /** Same as the MouseReport structure, but defines the keyboard HID interface's report structure. */ 
 const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] = 
 { 
 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */ 
 HID_RI_USAGE(8, 0x06), /* Keyboard */ 
 HID_RI_COLLECTION(8, 0x01), /* Application */ 
 HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */ 
 HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */ 
 HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */ 
 HID_RI_LOGICAL_MINIMUM(8, 0x00), 
 HID_RI_LOGICAL_MAXIMUM(8, 0x01), 
 HID_RI_REPORT_SIZE(8, 0x01), 
 HID_RI_REPORT_COUNT(8, 0x08), 
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE), 
 HID_RI_REPORT_COUNT(8, 0x01), 
 HID_RI_REPORT_SIZE(8, 0x08), 
 HID_RI_INPUT(8, HID_IOF_CONSTANT), 
 HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */ 
 HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */ 
 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */ 
 HID_RI_REPORT_COUNT(8, 0x05), 
 HID_RI_REPORT_SIZE(8, 0x01), 
 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE), 
 HID_RI_REPORT_COUNT(8, 0x01), 
 HID_RI_REPORT_SIZE(8, 0x03), 
 HID_RI_OUTPUT(8, HID_IOF_CONSTANT), 
 HID_RI_LOGICAL_MINIMUM(8, 0x00), 
 HID_RI_LOGICAL_MAXIMUM(8, 0x65), 
 HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */ 
 HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */ 
 HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */ 
 HID_RI_REPORT_COUNT(8, 0x06), 
 HID_RI_REPORT_SIZE(8, 0x08), 
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE), 
 HID_RI_END_COLLECTION(0), 
 }; 
 
 /** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall 
 * device characteristics, including the supported USB version, control endpoint size and the 
 * number of device configurations. The descriptor is read out by the USB host when the enumeration 
 * process begins. 
 */ 
 const USB_Descriptor_Device_t PROGMEM DeviceDescriptor = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device}, 
 
 .USBSpecification = VERSION_BCD(01.10), 
 .Class = USB_CSCP_NoDeviceClass, 
 .SubClass = USB_CSCP_NoDeviceSubclass, 
 .Protocol = USB_CSCP_NoDeviceProtocol, 
 
 .Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE, 
 
 .VendorID = 0x03EB, 
 .ProductID = 0x204D, 
 .ReleaseNumber = VERSION_BCD(00.01), 
 
 .ManufacturerStrIndex = 0x01, 
 .ProductStrIndex = 0x02, 
 .SerialNumStrIndex = NO_DESCRIPTOR, 
 
 .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS 
 }; 
 
 /** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage 
 * of the device in one of its supported configurations, including information about any device interfaces 
 * and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting 
 * a configuration so that the host may correctly communicate with the USB device. 
 */ 
 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor = 
 { 
 .Config = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration}, 
 
 .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t), 
 .TotalInterfaces = 2, 
 
 .ConfigurationNumber = 1, 
 .ConfigurationStrIndex = NO_DESCRIPTOR, 
 
 .ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_SELFPOWERED), 
 
 .MaxPowerConsumption = USB_CONFIG_POWER_MA(100) 
 }, 
 
 .HID1_KeyboardInterface = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, 
 
 .InterfaceNumber = 0x00, 
 .AlternateSetting = 0x00, 
 
 .TotalEndpoints = 2, 
 
 .Class = HID_CSCP_HIDClass, 
 .SubClass = HID_CSCP_BootSubclass, 
 .Protocol = HID_CSCP_KeyboardBootProtocol, 
 
 .InterfaceStrIndex = NO_DESCRIPTOR 
 }, 
 
 .HID1_KeyboardHID = 
 { 
 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID}, 
 
 .HIDSpec = VERSION_BCD(01.11), 
 .CountryCode = 0x00, 
 .TotalReportDescriptors = 1, 
 .HIDReportType = HID_DTYPE_Report, 
 .HIDReportLength = sizeof(KeyboardReport) 
 }, 
 
 .HID1_ReportINEndpoint = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, 
 
 .EndpointAddress = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM), 
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), 
 .EndpointSize = HID_EPSIZE, 
 .PollingIntervalMS = 0x01 
 }, 
 
 .HID1_ReportOUTEndpoint = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, 
 
 .EndpointAddress = (ENDPOINT_DIR_OUT | KEYBOARD_OUT_EPNUM), 
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), 
 .EndpointSize = HID_EPSIZE, 
 .PollingIntervalMS = 0x01 
 }, 
 
 .HID2_MouseInterface = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, 
 
 .InterfaceNumber = 0x01, 
 .AlternateSetting = 0x00, 
 
 .TotalEndpoints = 1, 
 
 .Class = HID_CSCP_HIDClass, 
 .SubClass = HID_CSCP_BootSubclass, 
 .Protocol = HID_CSCP_MouseBootProtocol, 
 
 .InterfaceStrIndex = NO_DESCRIPTOR 
 }, 
 
 .HID2_MouseHID = 
 { 
 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID}, 
 
 .HIDSpec = VERSION_BCD(01.11), 
 .CountryCode = 0x00, 
 .TotalReportDescriptors = 1, 
 .HIDReportType = HID_DTYPE_Report, 
 .HIDReportLength = sizeof(MouseReport) 
 }, 
 
 .HID2_ReportINEndpoint = 
 { 
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, 
 
 .EndpointAddress = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM), 
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), 
 .EndpointSize = HID_EPSIZE, 
 .PollingIntervalMS = 0x01 
 } 
 }; 
 
 /** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests 
 * the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate 
 * via the language ID table available at USB.org what languages the device supports for its string descriptors. 
 */ 
 const USB_Descriptor_String_t PROGMEM LanguageString = 
 { 
 .Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String}, 
 
 .UnicodeString = {LANGUAGE_ID_ENG} 
 }; 
 
 /** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable 
 * form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device 
 * Descriptor. 
 */ 
 const USB_Descriptor_String_t PROGMEM ManufacturerString = 
 { 
 .Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String}, 
 
 .UnicodeString = L"Dean Camera" 
 }; 
 
 /** Product descriptor string. This is a Unicode string containing the product's details in human readable form, 
 * and is read out upon request by the host when the appropriate string ID is requested, listed in the Device 
 * Descriptor. 
 */ 
 const USB_Descriptor_String_t PROGMEM ProductString = 
 { 
 .Header = {.Size = USB_STRING_LEN(28), .Type = DTYPE_String}, 
 
 .UnicodeString = L"LUFA Mouse and Keyboard Demo" 
 }; 
 
 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors" 
 * documentation) by the application code so that the address and size of a requested descriptor can be given 
 * to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function 
 * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the 
 * USB host. 
 */ 
 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, 
 const uint8_t wIndex, 
 const void** const DescriptorAddress) 
 { 
 const uint8_t DescriptorType = (wValue >> 8); 
 const uint8_t DescriptorNumber = (wValue & 0xFF); 
 
 const void* Address = NULL; 
 uint16_t Size = NO_DESCRIPTOR; 
 
 switch (DescriptorType) 
 { 
 case DTYPE_Device: 
 Address = &DeviceDescriptor; 
 Size = sizeof(USB_Descriptor_Device_t); 
 break; 
 case DTYPE_Configuration: 
 Address = &ConfigurationDescriptor; 
 Size = sizeof(USB_Descriptor_Configuration_t); 
 break; 
 case DTYPE_String: 
 switch (DescriptorNumber) 
 { 
 case 0x00: 
 Address = &LanguageString; 
 Size = pgm_read_byte(&LanguageString.Header.Size); 
 break; 
 case 0x01: 
 Address = &ManufacturerString; 
 Size = pgm_read_byte(&ManufacturerString.Header.Size); 
 break; 
 case 0x02: 
 Address = &ProductString; 
 Size = pgm_read_byte(&ProductString.Header.Size); 
 break; 
 } 
 
 break; 
 case HID_DTYPE_HID: 
 if (!(wIndex)) 
 { 
 Address = &ConfigurationDescriptor.HID1_KeyboardHID; 
 Size = sizeof(USB_HID_Descriptor_HID_t); 
 } 
 else 
 { 
 Address = &ConfigurationDescriptor.HID2_MouseHID; 
 Size = sizeof(USB_HID_Descriptor_HID_t); 
 } 
 break; 
 case HID_DTYPE_Report: 
 if (!(wIndex)) 
 { 
 Address = &KeyboardReport; 
 Size = sizeof(KeyboardReport); 
 } 
 else 
 { 
 Address = &MouseReport; 
 Size = sizeof(MouseReport); 
 } 
 
 break; 
 } 
 
 *DescriptorAddress = Address; 
 return Size; 
 } 
 
--- a/keyboard/lufa/Descriptors.h
+++ b/keyboard/lufa/Descriptors.h
@@ -0,0 +1,87 @@
 /* 
 LUFA Library 
 Copyright (C) Dean Camera, 2012. 
 
 dean [at] fourwalledcubicle [dot] com 
 www.lufa-lib.org 
 */ 
 
 /* 
 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com) 
 Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com) 
 
 Permission to use, copy, modify, distribute, and sell this 
 software and its documentation for any purpose is hereby granted 
 without fee, provided that the above copyright notice appear in 
 all copies and that both that the copyright notice and this 
 permission notice and warranty disclaimer appear in supporting 
 documentation, and that the name of the author not be used in 
 advertising or publicity pertaining to distribution of the 
 software without specific, written prior permission. 
 
 The author disclaim all warranties with regard to this 
 software, including all implied warranties of merchantability 
 and fitness. In no event shall the author be liable for any 
 special, indirect or consequential damages or any damages 
 whatsoever resulting from loss of use, data or profits, whether 
 in an action of contract, negligence or other tortious action, 
 arising out of or in connection with the use or performance of 
 this software. 
 */ 
 
 /** \file 
 * 
 * Header file for Descriptors.c. 
 */ 
 
 #ifndef _DESCRIPTORS_H_ 
 #define _DESCRIPTORS_H_ 
 
 /* Includes: */ 
 #include <LUFA/Drivers/USB/USB.h> 
 
 #include <avr/pgmspace.h> 
 
 /* Type Defines: */ 
 /** Type define for the device configuration descriptor structure. This must be defined in the 
 * application code, as the configuration descriptor contains several sub-descriptors which 
 * vary between devices, and which describe the device's usage to the host. 
 */ 
 typedef struct 
 { 
 USB_Descriptor_Configuration_Header_t Config; 
 
 // Keyboard HID Interface 
 USB_Descriptor_Interface_t HID1_KeyboardInterface; 
 USB_HID_Descriptor_HID_t HID1_KeyboardHID; 
 USB_Descriptor_Endpoint_t HID1_ReportINEndpoint; 
 USB_Descriptor_Endpoint_t HID1_ReportOUTEndpoint; 
 
 // Mouse HID Interface 
 USB_Descriptor_Interface_t HID2_MouseInterface; 
 USB_HID_Descriptor_HID_t HID2_MouseHID; 
 USB_Descriptor_Endpoint_t HID2_ReportINEndpoint; 
 USB_Descriptor_Endpoint_t HID2_ReportOUTEndpoint; 
 } USB_Descriptor_Configuration_t; 
 
 /* Macros: */ 
 /** Endpoint number of the Keyboard HID reporting IN endpoint. */ 
 #define KEYBOARD_IN_EPNUM 1 
 
 /** Endpoint number of the Keyboard HID reporting OUT endpoint. */ 
 #define KEYBOARD_OUT_EPNUM 2 
 
 /** Endpoint number of the Mouse HID reporting IN endpoint. */ 
 #define MOUSE_IN_EPNUM 3 
 
 /** Size in bytes of each of the HID reporting IN and OUT endpoints. */ 
 #define HID_EPSIZE 8 
 
 /* Function Prototypes: */ 
 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, 
 const uint8_t wIndex, 
 const void** const DescriptorAddress) 
 ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3); 
 
 #endif 
 
--- a/keyboard/lufa/Makefile
+++ b/keyboard/lufa/Makefile
@@ -0,0 +1,161 @@
 # Hey Emacs, this is a -*- makefile -*- 
 #---------------------------------------------------------------------------- 
 # WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al. 
 # >> Modified for use with the LUFA project. << 
 # 
 # Released to the Public Domain 
 # 
 # Additional material for this makefile was written by: 
 # Peter Fleury 
 # Tim Henigan 
 # Colin O'Flynn 
 # Reiner Patommel 
 # Markus Pfaff 
 # Sander Pool 
 # Frederik Rouleau 
 # Carlos Lamas 
 # Dean Camera 
 # Opendous Inc. 
 # Denver Gingerich 
 # 
 #---------------------------------------------------------------------------- 
 # On command line: 
 # 
 # make all = Make software. 
 # 
 # make clean = Clean out built project files. 
 # 
 # make coff = Convert ELF to AVR COFF. 
 # 
 # make extcoff = Convert ELF to AVR Extended COFF. 
 # 
 # make program = Download the hex file to the device, using avrdude. 
 # Please customize the avrdude settings below first! 
 # 
 # make dfu = Download the hex file to the device, using dfu-programmer (must 
 # have dfu-programmer installed). 
 # 
 # make flip = Download the hex file to the device, using Atmel FLIP (must 
 # have Atmel FLIP installed). 
 # 
 # make dfu-ee = Download the eeprom file to the device, using dfu-programmer 
 # (must have dfu-programmer installed). 
 # 
 # make flip-ee = Download the eeprom file to the device, using Atmel FLIP 
 # (must have Atmel FLIP installed). 
 # 
 # make doxygen = Generate DoxyGen documentation for the project (must have 
 # DoxyGen installed) 
 # 
 # make debug = Start either simulavr or avarice as specified for debugging, 
 # with avr-gdb or avr-insight as the front end for debugging. 
 # 
 # make filename.s = Just compile filename.c into the assembler code only. 
 # 
 # make filename.i = Create a preprocessed source file for use in submitting 
 # bug reports to the GCC project. 
 # 
 # To rebuild project do "make clean" then "make all". 
 #---------------------------------------------------------------------------- 
 
 # Directory common source filess exist 
 TOP_DIR = ../.. 
 
 # Directory keyboard dependent files exist 
 TARGET_DIR = . 
 
 # MCU name 
 #MCU = at90usb1287 
 MCU = atmega32u4 
 
 
 # Target architecture (see library "Board Types" documentation). 
 ARCH = AVR8 
 
 
 # Target board (see library "Board Types" documentation, NONE for projects not requiring 
 # LUFA board drivers). If USER is selected, put custom board drivers in a directory called 
 # "Board" inside the application directory. 
 BOARD = USBKEY 
 
 
 # Processor frequency. 
 # This will define a symbol, F_CPU, in all source code files equal to the 
 # processor frequency in Hz. You can then use this symbol in your source code to 
 # calculate timings. Do NOT tack on a 'UL' at the end, this will be done 
 # automatically to create a 32-bit value in your source code. 
 # 
 # This will be an integer division of F_USB below, as it is sourced by 
 # F_USB after it has run through any CPU prescalers. Note that this value 
 # does not *change* the processor frequency - it should merely be updated to 
 # reflect the processor speed set externally so that the code can use accurate 
 # software delays. 
 F_CPU = 16000000 
 
 
 # Input clock frequency. 
 # This will define a symbol, F_USB, in all source code files equal to the 
 # input clock frequency (before any prescaling is performed) in Hz. This value may 
 # differ from F_CPU if prescaling is used on the latter, and is required as the 
 # raw input clock is fed directly to the PLL sections of the AVR for high speed 
 # clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL' 
 # at the end, this will be done automatically to create a 32-bit value in your 
 # source code. 
 # 
 # If no clock division is performed on the input clock inside the AVR (via the 
 # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. 
 F_USB = $(F_CPU) 
 
 
 # Target file name (without extension). 
 TARGET = lufa 
 
 
 # Path to the LUFA library 
 LUFA_PATH = ../../protocol 
 
 # Create the LUFA source path variables by including the LUFA root makefile 
 include $(LUFA_PATH)/LUFA/makefile 
 
 
 
 # List C source files here. (C dependencies are automatically generated.) 
 LSRC = $(TARGET).c \ 
 Descriptors.c \ 
 $(LUFA_SRC_USB) \ 
 $(LUFA_SRC_USBCLASS) 
 
 SRC = $(subst $(LUFA_PATH)/LUFA/,,$(LSRC)) 
 SRC += keymap.c \ 
 matrix.c \ 
 led.c \ 
 sendchar_null.c 
 CONFIG_H = config.h 
 
 
 
 # LUFA library compile-time options and predefined tokens 
 LUFA_OPTS = -D USB_DEVICE_ONLY 
 LUFA_OPTS += -D FIXED_CONTROL_ENDPOINT_SIZE=8 
 LUFA_OPTS += -D FIXED_NUM_CONFIGURATIONS=1 
 LUFA_OPTS += -D USE_FLASH_DESCRIPTORS 
 LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)" 
 
 OPT_DEFS = -DF_CPU=$(F_CPU)UL 
 OPT_DEFS += -DF_USB=$(F_USB)UL 
 OPT_DEFS += -DBOARD=BOARD_$(BOARD) -DARCH=ARCH_$(ARCH) 
 OPT_DEFS += $(LUFA_OPTS) 
 
 
 
 # Search Path 
 VPATH += $(TARGET_DIR) 
 VPATH += $(LUFA_PATH)/LUFA 
 
 
 include $(TOP_DIR)/protocol.mk 
 include $(TOP_DIR)/common.mk 
 include $(TOP_DIR)/rules.mk 
 
 test: 
 echo $(SRC) 
--- a/keyboard/lufa/config.h
+++ b/keyboard/lufa/config.h
@@ -0,0 +1,70 @@
 /*
 Copyright 2011 Jun Wako <[email protected]>

 This program 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 2 of the License, or
 (at your option) any later version.

 This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */

 #ifndef CONFIG_H
 #define CONFIG_H

 /* controller configuration */
 #include "controller_teensy.h"

 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0xBEE1
 #define MANUFACTURER t.m.k.
 #define PRODUCT Macway mod(LUFA)
 #define DESCRIPTION t.m.k. keyboard firmware for Macway mod(LUFA)


 /* matrix size */
 #define MATRIX_ROWS 9
 #define MATRIX_COLS 8
 /* define if matrix has ghost */
 #define MATRIX_HAS_GHOST
 /* Set 0 if need no debouncing */
 #define DEBOUNCE 5


 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \
 keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \
 )


 /* layer switching */
 #define LAYER_SWITCH_DELAY 100
 #define LAYER_SEND_FN_TERM 300


 /* mouse keys */
 #ifdef MOUSEKEY_ENABLE
 # define MOUSEKEY_DELAY_TIME 192
 #endif


 /* PS/2 mouse */
 #ifdef PS2_MOUSE_ENABLE
 # define PS2_CLOCK_PORT PORTF
 # define PS2_CLOCK_PIN PINF
 # define PS2_CLOCK_DDR DDRF
 # define PS2_CLOCK_BIT 0
 # define PS2_DATA_PORT PORTF
 # define PS2_DATA_PIN PINF
 # define PS2_DATA_DDR DDRF
 # define PS2_DATA_BIT 1
 #endif

 #endif
--- a/keyboard/lufa/keymap.c
+++ b/keyboard/lufa/keymap.c
@@ -0,0 +1,195 @@
 /*
 Copyright 2011 Jun Wako <[email protected]>

 This program 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 2 of the License, or
 (at your option) any later version.

 This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */

 /* 
 * Keymap for Macway mod
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/pgmspace.h>
 #include "usb_keycodes.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "keymap.h"


 // Convert physical keyboard layout to matrix array.
 // This is a macro to define keymap easily in keyboard layout form.
 #define KEYMAP( \
 K11, K10, K20, K30, K40, K41, K51, K50, K60, K70, K80, K81, K61, K02, \
 K12, K13, K23, K33, K43, K42, K52, K53, K63, K73, K83, K82, K62, K01, \
 K15, K14, K24, K34, K44, K45, K55, K54, K64, K74, K84, K85, K06, \
 K67, K16, K26, K36, K46, K47, K57, K56, K66, K76, K87, K32, K35, \
 K75, K22, K00, K07, K21, K04, K37, K27, K17 \
 ) { \
 { KB_##K00, KB_##K01, KB_##K02, KB_NO, KB_##K04, KB_NO, KB_##K06, KB_##K07 }, \
 { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \
 { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_NO, KB_##K26, KB_##K27 }, \
 { KB_##K30, KB_NO, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \
 { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \
 { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \
 { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \
 { KB_##K70, KB_NO, KB_NO, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO }, \
 { KB_##K80, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_NO, KB_##K87 } \
 }

 #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))


 // Assign Fn key(0-7) to a layer to which switch with the Fn key pressed.
 static const uint8_t PROGMEM fn_layer[] = {
 0, // Fn0
 1, // Fn1
 2, // Fn2
 3, // Fn3
 4, // Fn4
 0, // Fn5
 3, // Fn6
 3 // 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_NO, // Fn0
 KB_NO, // Fn1
 KB_SLSH, // Fn2
 KB_SCLN, // Fn3
 KB_SPC, // Fn4
 KB_NO, // Fn5
 KB_NO, // Fn6
 KB_NO // Fn7
 };

 static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Layer 0: Default Layer
 * ,-----------------------------------------------------------.
 * |Esc| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|Backsp |
 * |-----------------------------------------------------------|
 * |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| |
 * |-----------------------------------------------------' |
 * |Contro| A| S| D| F| G| H| J| K| L|Fn3| '|Return |
 * |-----------------------------------------------------------|
 * |Shift | Z| X| C| V| B| N| M| ,| .| /|Shift |Fn1|
 * |-----------------------------------------------------------|
 * |Fn7|Gui |Alt |Fn4 |Alt |Gui|Fn6|Fn6|Ctr|
 * `-----------------------------------------------------------'
 */
 KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \
 LCTL,A, S, D, F, G, H, J, K, L, FN3, QUOT,ENT, \
 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \
 FN7, LGUI,LALT,FN4, RALT,BSLS,FN6, FN6, RCTL),


 /* Layer 1: HHKB mode (HHKB Fn)
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delete |
 * |-----------------------------------------------------------|
 * |Caps | | | | | | | |Psc|Slk|Pus|Up | | |
 * |-----------------------------------------------------' |
 * |Contro|VoD|VoU|Mut| | | *| /|Hom|PgU|Lef|Rig|Enter |
 * |-----------------------------------------------------------|
 * |Shift | | | | | | +| -|End|PgD|Dow|Shift |xxx|
 * |-----------------------------------------------------------|
 * | |Gui |Alt | |Alt |Gui| | |Ctr|
 * `-----------------------------------------------------------'
 */ 
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, \
 CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,BRK, UP, NO, NO, \
 LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \
 LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,FN1, \
 NO, LGUI,LALT,SPC, RALT,NO, NO, NO, RCTL),


 /* Layer 2: Vi mode (Quote/Rmeta)
 * ,-----------------------------------------------------------.
 * | `| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12| ` |
 * |-----------------------------------------------------------|
 * | \ |Hom|PgD|Up |PgU|End|Hom|PgD|PgU|End| | | | |
 * |-----------------------------------------------------' |
 * |Contro| |Lef|Dow|Rig| |Lef|Dow|Up |Rig| | | \ |
 * |-----------------------------------------------------------|
 * |Shift | | | | | |Hom|PgD|PgU|End|xxx|Shift | |
 * |-----------------------------------------------------------|
 * | |Gui |Alt |Space |Alt |Gui|Fn6|Fn6|Ctr|
 * `-----------------------------------------------------------'
 */
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, GRV, \
 BSLS,HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, NO, NO, NO, NO, \
 LCTL,NO, LEFT,DOWN,RGHT,NO, LEFT,DOWN,UP, RGHT,NO, NO, BSLS, \
 LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, FN2, RSFT,NO, \
 NO, LGUI,LALT,SPC, RALT,RGUI,FN6, FN6, RCTL),


 /* Layer 3: Mouse mode (Semicolon)
 * ,-----------------------------------------------------------.
 * | `| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12| ` |
 * |-----------------------------------------------------------|
 * | \ |MwL|MwD|McU|MwU|MwR|MwL|MwD|MwU|MwR| | | | |
 * |-----------------------------------------------------' |
 * |Contro| |McL|McD|McR| |McL|McD|McU|McR|xxx| | \ |
 * |-----------------------------------------------------------|
 * |Shift | | |Mb1|Mb2|Mb3|Mb2|Mb1| | | |Shift | |
 * |-----------------------------------------------------------|
 * |xxx|Gui |Alt |Mb1 |Alt | | | | |
 * `-----------------------------------------------------------'
 * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel 
 */
 KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, GRV, \
 BSLS,WH_L,WH_D,MS_U,WH_U,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, NO, \
 LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, BSLS, \
 LSFT,NO, NO, BTN1,BTN2,BTN3,BTN2,BTN1,NO, NO, NO, RSFT,NO, \
 FN7, LGUI,LALT,BTN1,RALT,NO, FN6, FN6, NO),


 /* Layer 4: Matias half keyboard style (Space)
 * ,-----------------------------------------------------------.
 * |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delete |
 * |-----------------------------------------------------------|
 * |Backs| P| O| I| U| Y| T| R| E| W| Q|Tab|Tab| |
 * |-----------------------------------------------------' |
 * |Contro| ;| L| K| J| H| G| F| D| S| A|Con|Control |
 * |-----------------------------------------------------------|
 * |Shift | /| .| ,| M| N| B| V| C| X| Z|Shift | |
 * |-----------------------------------------------------------|
 * | |Gui |Alt |xxxxxxxxxxxxxxxxxxxxxx|Alt |Gui| | |Ctr|
 * `-----------------------------------------------------------'
 */
 KEYMAP(MINS,0, 9, 8, 7, 6, 5, 4, 3, 2, 1, NO, NO, ESC, \
 BSPC,P, O, I, U, Y, T, R, E, W, Q, TAB, TAB, TAB, \
 LCTL,SCLN,L, K, J, H, G, F, D, S, A, RCTL,RCTL, \
 LSFT,SLSH,DOT, COMM,M, N, B, V, C, X, Z, RSFT,NO, \
 NO, LGUI,LALT,FN4, RALT,RGUI,NO, NO, RCTL),
 };


 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))]);
 }
--- a/keyboard/lufa/led.c
+++ b/keyboard/lufa/led.c
@@ -0,0 +1,24 @@
 /*
 Copyright 2011 Jun Wako <[email protected]>

 This program 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 2 of the License, or
 (at your option) any later version.

 This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */

 #include "stdint.h"
 #include "led.h"


 void led_set(uint8_t usb_led)
 {
 }
--- a/keyboard/lufa/lufa.c
+++ b/keyboard/lufa/lufa.c
@@ -0,0 +1,243 @@
 /* 
 * Copyright 2012 Jun Wako <[email protected]>
 * This file is based on LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse.
 */

 /*
 LUFA Library
 Copyright (C) Dean Camera, 2012.

 dean [at] fourwalledcubicle [dot] com
 www.lufa-lib.org
 */

 /*
 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com)
 Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com)

 Permission to use, copy, modify, distribute, and sell this
 software and its documentation for any purpose is hereby granted
 without fee, provided that the above copyright notice appear in
 all copies and that both that the copyright notice and this
 permission notice and warranty disclaimer appear in supporting
 documentation, and that the name of the author not be used in
 advertising or publicity pertaining to distribution of the
 software without specific, written prior permission.

 The author disclaim all warranties with regard to this
 software, including all implied warranties of merchantability
 and fitness. In no event shall the author be liable for any
 special, indirect or consequential damages or any damages
 whatsoever resulting from loss of use, data or profits, whether
 in an action of contract, negligence or other tortious action,
 arising out of or in connection with the use or performance of
 this software.
 */

 #include "report.h"
 #include "host.h"
 #include "host_driver.h"
 #include "keyboard.h"
 #include "lufa.h"

 static uint8_t keyboard_led_stats = 0;
 report_keyboard_t keyboard_report_sent;
 report_mouse_t mouse_report_sent;

 /* Host driver */
 static uint8_t keyboard_leds(void);
 static void send_keyboard(report_keyboard_t *report);
 static void send_mouse(report_mouse_t *report);
 static void send_system(uint16_t data);
 static void send_consumer(uint16_t data);
 static host_driver_t lufa_driver = {
 keyboard_leds,
 send_keyboard,
 send_mouse,
 send_system,
 send_consumer
 };


 int main(void)
 {
 SetupHardware();
 sei();

 keyboard_init();
 host_set_driver(&lufa_driver);
 while (1) {
 keyboard_proc();
 Keyboard_HID_Task();
 USB_USBTask();
 }
 }

 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 void SetupHardware(void)
 {
 /* Disable watchdog if enabled by bootloader/fuses */
 MCUSR &= ~(1 << WDRF);
 wdt_disable();

 /* Disable clock division */
 clock_prescale_set(clock_div_1);

 USB_Init();
 }

 /** Event handler for the USB_Connect event. */
 void EVENT_USB_Device_Connect(void)
 {
 }

 /** Event handler for the USB_Disconnect event. */
 void EVENT_USB_Device_Disconnect(void)
 {
 }

 /** Event handler for the USB_ConfigurationChanged event.
 * This is fired when the host sets the current configuration of the USB device after enumeration.
 */
 void EVENT_USB_Device_ConfigurationChanged(void)
 {
 bool ConfigSuccess = true;

 /* Setup Keyboard HID Report Endpoints */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 HID_EPSIZE, ENDPOINT_BANK_SINGLE);
 ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 HID_EPSIZE, ENDPOINT_BANK_SINGLE);

 /* Setup Mouse HID Report Endpoint */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 HID_EPSIZE, ENDPOINT_BANK_SINGLE);
 }

 /** Event handler for the USB_ControlRequest event.
 * This is fired before passing along unhandled control requests to the library for processing internally.
 */
 void EVENT_USB_Device_ControlRequest(void)
 {
 uint8_t* ReportData;
 uint8_t ReportSize;

 /* Handle HID Class specific requests */
 switch (USB_ControlRequest.bRequest)
 {
 case HID_REQ_GetReport:
 if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 {
 Endpoint_ClearSETUP();

 /* Determine if it is the mouse or the keyboard data that is being requested */
 if (!(USB_ControlRequest.wIndex))
 {
 ReportData = (uint8_t*)&keyboard_report_sent;
 ReportSize = sizeof(keyboard_report_sent);
 }
 else
 {
 ReportData = (uint8_t*)&mouse_report_sent;
 ReportSize = sizeof(mouse_report_sent);
 }

 /* Write the report data to the control endpoint */
 Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
 Endpoint_ClearOUT();
 }

 break;
 case HID_REQ_SetReport:
 if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 {
 Endpoint_ClearSETUP();

 /* Wait until the LED report has been sent by the host */
 while (!(Endpoint_IsOUTReceived()))
 {
 if (USB_DeviceState == DEVICE_STATE_Unattached)
 return;
 }

 /* Read in the LED report from the host */
 keyboard_led_stats = Endpoint_Read_8();

 Endpoint_ClearOUT();
 Endpoint_ClearStatusStage();
 }

 break;
 }
 }

 /** Keyboard task.
 * This processes host LED status reports sent to the device via the keyboard OUT reporting endpoint.
 */
 void Keyboard_HID_Task(void)
 {
 /* Select the Keyboard LED Report Endpoint */
 Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);

 /* Check if Keyboard LED Endpoint Ready for Read/Write */
 if (Endpoint_IsReadWriteAllowed())
 {
 /* Read in the LED report from the host */
 keyboard_led_stats = Endpoint_Read_8();

 /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
 Endpoint_ClearOUT();
 }
 }


 /*******************************************************************************
 * Host driver 
 ******************************************************************************/
 static uint8_t keyboard_leds(void)
 {
 return keyboard_led_stats;
 }

 static void send_keyboard(report_keyboard_t *report)
 {
 // TODO: handle NKRO report
 /* Select the Keyboard Report Endpoint */
 Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);

 /* Check if Keyboard Endpoint Ready for Read/Write */
 if (Endpoint_IsReadWriteAllowed())
 {
 /* Write Keyboard Report Data */
 Endpoint_Write_Stream_LE(report, sizeof(report_keyboard_t), NULL);

 /* Finalize the stream transfer to send the last packet */
 Endpoint_ClearIN();
 }
 keyboard_report_sent = *report;
 }

 static void send_mouse(report_mouse_t *report)
 {
 /* Select the Mouse Report Endpoint */
 Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);

 /* Check if Mouse Endpoint Ready for Read/Write */
 if (Endpoint_IsReadWriteAllowed())
 {
 /* Write Mouse Report Data */
 Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);

 /* Finalize the stream transfer to send the last packet */
 Endpoint_ClearIN();
 }
 mouse_report_sent = *report;
 }

 static void send_system(uint16_t data)
 {
 }

 static void send_consumer(uint16_t data)
 {
 }
--- a/keyboard/lufa/lufa.h
+++ b/keyboard/lufa/lufa.h
@@ -0,0 +1,78 @@
 /* 
 LUFA Library 
 Copyright (C) Dean Camera, 2012. 
 
 dean [at] fourwalledcubicle [dot] com 
 www.lufa-lib.org 
 */ 
 
 /* 
 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com) 
 Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com) 
 
 Permission to use, copy, modify, distribute, and sell this 
 software and its documentation for any purpose is hereby granted 
 without fee, provided that the above copyright notice appear in 
 all copies and that both that the copyright notice and this 
 permission notice and warranty disclaimer appear in supporting 
 documentation, and that the name of the author not be used in 
 advertising or publicity pertaining to distribution of the 
 software without specific, written prior permission. 
 
 The author disclaim all warranties with regard to this 
 software, including all implied warranties of merchantability 
 and fitness. In no event shall the author be liable for any 
 special, indirect or consequential damages or any damages 
 whatsoever resulting from loss of use, data or profits, whether 
 in an action of contract, negligence or other tortious action, 
 arising out of or in connection with the use or performance of 
 this software. 
 */ 
 
 #ifndef _LUFA_H_ 
 #define _LUFA_H_ 
 
 /* Includes: */ 
 #include <avr/io.h> 
 #include <avr/wdt.h> 
 #include <avr/power.h> 
 #include <avr/interrupt.h> 
 #include <stdbool.h> 
 #include <string.h> 
 
 #include "Descriptors.h" 
 
 #include <LUFA/Version.h> 
 #include <LUFA/Drivers/USB/USB.h> 
 #include <LUFA/Drivers/Board/Joystick.h> 
 #include <LUFA/Drivers/Board/LEDs.h> 
 #include <LUFA/Drivers/Board/Buttons.h> 
 
 /* Macros: */ 
 /** LED mask for the library LED driver, to indicate that the USB interface is not ready. */ 
 #define LEDMASK_USB_NOTREADY LEDS_LED1 
 
 /** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */ 
 #define LEDMASK_USB_ENUMERATING (LEDS_LED2 | LEDS_LED3) 
 
 /** LED mask for the library LED driver, to indicate that the USB interface is ready. */ 
 #define LEDMASK_USB_READY (LEDS_LED2 | LEDS_LED4) 
 
 /** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */ 
 #define LEDMASK_USB_ERROR (LEDS_LED1 | LEDS_LED3) 
 
 /* Function Prototypes: */ 
 void SetupHardware(void); 
 void Keyboard_ProcessLEDReport(const uint8_t LEDStatus); 
 void Keyboard_HID_Task(void); 
 void Mouse_HID_Task(void); 
 
 void EVENT_USB_Device_Connect(void); 
 void EVENT_USB_Device_Disconnect(void); 
 void EVENT_USB_Device_ConfigurationChanged(void); 
 void EVENT_USB_Device_ControlRequest(void); 
 void EVENT_USB_Device_StartOfFrame(void); 
 
 void Keyboard_send(USB_KeyboardReport_Data_t report); 
 #endif 
 
--- a/keyboard/lufa/matrix.c
+++ b/keyboard/lufa/matrix.c
@@ -0,0 +1,271 @@
 /*
 Copyright 2011 Jun Wako <[email protected]>

 This program 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 2 of the License, or
 (at your option) any later version.

 This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */

 /*
 * scan matrix
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <util/delay.h>
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.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


 #ifndef DEBOUNCE
 # define DEBOUNCE 0
 #endif
 static uint8_t debouncing = DEBOUNCE;

 // matrix state buffer(1:on, 0:off)
 #if (MATRIX_COLS <= 8)
 static uint8_t *matrix;
 static uint8_t *matrix_prev;
 static uint8_t _matrix0[MATRIX_ROWS];
 static uint8_t _matrix1[MATRIX_ROWS];
 #else
 static uint16_t *matrix;
 static uint16_t *matrix_prev;
 static uint16_t _matrix0[MATRIX_ROWS];
 static uint16_t _matrix1[MATRIX_ROWS];
 #endif

 #ifdef MATRIX_HAS_GHOST
 static bool matrix_has_ghost_in_row(uint8_t row);
 #endif
 static uint8_t read_col(void);
 static void unselect_rows(void);
 static void select_row(uint8_t row);


 inline
 uint8_t matrix_rows(void)
 {
 return MATRIX_ROWS;
 }

 inline
 uint8_t matrix_cols(void)
 {
 return MATRIX_COLS;
 }

 void matrix_init(void)
 {
 // initialize row and col
 unselect_rows();
 // Input with pull-up(DDR:0, PORT:1)
 DDRB = 0x00;
 PORTB = 0xFF;

 // initialize matrix state: all keys off
 for (uint8_t i=0; i < MATRIX_ROWS; i++) _matrix0[i] = 0x00;
 for (uint8_t i=0; i < MATRIX_ROWS; i++) _matrix1[i] = 0x00;
 matrix = _matrix0;
 matrix_prev = _matrix1;
 }

 uint8_t matrix_scan(void)
 {
 if (!debouncing) {
 uint8_t *tmp = matrix_prev;
 matrix_prev = matrix;
 matrix = tmp;
 }

 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 unselect_rows();
 select_row(i);
 _delay_us(30); // without this wait read unstable value.
 if (matrix[i] != (uint8_t)~read_col()) {
 matrix[i] = (uint8_t)~read_col();
 if (debouncing) {
 debug("bounce!: "); debug_hex(debouncing); print("\n");
 }
 debouncing = DEBOUNCE;
 }
 }
 unselect_rows();

 if (debouncing) {
 debouncing--;
 }

 return 1;
 }

 bool matrix_is_modified(void)
 {
 if (debouncing) return false;
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 if (matrix[i] != matrix_prev[i]) {
 return true;
 }
 }
 return false;
 }

 inline
 bool matrix_has_ghost(void)
 {
 #ifdef MATRIX_HAS_GHOST
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 if (matrix_has_ghost_in_row(i))
 return true;
 }
 #endif
 return false;
 }

 inline
 bool matrix_is_on(uint8_t row, uint8_t col)
 {
 return (matrix[row] & (1<<col));
 }

 inline
 #if (MATRIX_COLS <= 8)
 uint8_t matrix_get_row(uint8_t row)
 #else
 uint16_t matrix_get_row(uint8_t row)
 #endif
 {
 return matrix[row];
 }

 void matrix_print(void)
 {
 print("\nr/c 01234567\n");
 for (uint8_t row = 0; row < matrix_rows(); row++) {
 phex(row); print(": ");
 #if (MATRIX_COLS <= 8)
 pbin_reverse(matrix_get_row(row));
 #else
 pbin_reverse16(matrix_get_row(row));
 #endif
 #ifdef MATRIX_HAS_GHOST
 if (matrix_has_ghost_in_row(row)) {
 print(" <ghost");
 }
 #endif
 print("\n");
 }
 }

 uint8_t matrix_key_count(void)
 {
 uint8_t count = 0;
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 #if (MATRIX_COLS <= 8)
 count += bitpop(matrix[i]);
 #else
 count += bitpop16(matrix[i]);
 #endif
 }
 return count;
 }

 #ifdef MATRIX_HAS_GHOST
 inline
 static bool matrix_has_ghost_in_row(uint8_t row)
 {
 // no ghost exists in case less than 2 keys on
 if (((matrix[row] - 1) & matrix[row]) == 0)
 return false;

 // ghost exists in case same state as other row
 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 if (i != row && (matrix[i] & matrix[row]) == matrix[row])
 return true;
 }
 return false;
 }
 #endif

 inline
 static uint8_t read_col(void)
 {
 return PINB;
 }

 inline
 static void unselect_rows(void)
 {
 // Hi-Z(DDR:0, PORT:0) to unselect
 DDRC &= ~0b01000000; // PC: 6
 PORTC &= ~0b11000000;
 DDRD &= ~0b11100111; // PD: 7,6,5,2,1,0
 PORTD &= ~0b11000111;
 DDRF &= ~0b11000000; // PF: 7,6
 PORTF &= ~0b11000000;
 }

 inline
 static void select_row(uint8_t row)
 {
 // Output low(DDR:1, PORT:0) to select
 // row: 0 1 2 3 4 5 6 7 8
 // pin: PD0, PD5, PD7, PF6, PD6, PD1, PD2, PC6, PF7
 switch (row) {
 case 0:
 DDRD |= (1<<0);
 PORTD &= ~(1<<0);
 break;
 case 1:
 DDRD |= (1<<5);
 PORTD &= ~(1<<5);
 break;
 case 2:
 DDRD |= (1<<7);
 PORTD &= ~(1<<7);
 break;
 case 3:
 DDRF |= (1<<6);
 PORTF &= ~(1<<6);
 break;
 case 4:
 DDRD |= (1<<6);
 PORTD &= ~(1<<6);
 break;
 case 5:
 DDRD |= (1<<1);
 PORTD &= ~(1<<1);
 break;
 case 6:
 DDRD |= (1<<2);
 PORTD &= ~(1<<2);
 break;
 case 7:
 DDRC |= (1<<6);
 PORTC &= ~(1<<6);
 break;
 case 8:
 DDRF |= (1<<7);
 PORTF &= ~(1<<7);
 break;
 }
 }
--- a/rules.mk
+++ b/rules.mk
@@ -109,8 +109,10 @@ CFLAGS += -O$(OPT)
 CFLAGS += -funsigned-char
 CFLAGS += -funsigned-bitfields
 CFLAGS += -ffunction-sections
 CFLAGS += -fno-inline-small-functions
 CFLAGS += -fpack-struct
 CFLAGS += -fshort-enums
 CFLAGS += -fno-strict-aliasing
 CFLAGS += -Wall
 CFLAGS += -Wstrict-prototypes
 #CFLAGS += -mshort-calls
@@ -230,7 +232,7 @@ EXTMEMOPTS =
 # (.vectors+0x30): relocation truncated to fit: R_AVR_13_PCREL against symbol `__vector_12'
 #
 LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
 #LDFLAGS += -Wl,--relax
 LDFLAGS += -Wl,--relax
 LDFLAGS += -Wl,--gc-sections
 LDFLAGS += $(EXTMEMOPTS)
 LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
@@ -387,6 +389,30 @@ gccversion :
 program: $(TARGET).hex $(TARGET).eep
 $(PROGRAM_CMD)

 teensy: $(TARGET).hex
 teensy_loader_cli -mmcu=$(MCU) -w -v $(TARGET).hex

 flip: $(TARGET).hex
 batchisp -hardware usb -device $(MCU) -operation erase f
 batchisp -hardware usb -device $(MCU) -operation loadbuffer $(TARGET).hex program
 batchisp -hardware usb -device $(MCU) -operation start reset 0

 dfu: $(TARGET).hex
 dfu-programmer $(MCU) erase
 dfu-programmer $(MCU) flash $(TARGET).hex
 dfu-programmer $(MCU) reset

 flip-ee: $(TARGET).hex $(TARGET).eep
 $(COPY) $(TARGET).eep $(TARGET)eep.hex
 batchisp -hardware usb -device $(MCU) -operation memory EEPROM erase
 batchisp -hardware usb -device $(MCU) -operation memory EEPROM loadbuffer $(TARGET)eep.hex program
 batchisp -hardware usb -device $(MCU) -operation start reset 0
 $(REMOVE) $(TARGET)eep.hex

 dfu-ee: $(TARGET).hex $(TARGET).eep
 dfu-programmer $(MCU) eeprom-flash $(TARGET).eep
 dfu-programmer $(MCU) reset


 # Generate avr-gdb config/init file which does the following:
 # define the reset signal, load the target file, connect to target, and set 
@@ -488,6 +514,7 @@ extcoff: $(TARGET).elf
 # Compile: create object files from C source files.
 $(OBJDIR)/%.o : %.c
 @echo
 mkdir -p $(@D)
 @echo $(MSG_COMPILING) $<
 $(CC) -c $(ALL_CFLAGS) $< -o $@ 

@@ -538,7 +565,7 @@ clean_list :
 $(REMOVE) $(OBJ:.o=.s)
 $(REMOVE) $(OBJ:.o=.i)
 $(REMOVE) -r .dep
 $(REMOVEDIR) $(OBJDIR)
 $(REMOVE) -r $(OBJDIR)


 # Create object files directory