~ruther/qmk_firmware

3d81d5221eac9ca9620ba9043a250dcb8371b22e — tmk 13 years ago a9a3610
Add consumer/system control feature to LUFA.
M common/keyboard.c => common/keyboard.c +5 -12
@@ 49,6 49,7 @@ void keyboard_proc(void)
    uint8_t fn_bits = 0;
#ifdef EXTRAKEY_ENABLE
    uint16_t consumer_code = 0;
    uint16_t system_code = 0;
#endif

    matrix_scan();


@@ 89,22 90,13 @@ void keyboard_proc(void)
#ifdef HOST_PJRC
                if (suspend && remote_wakeup) {
                    usb_remote_wakeup();
                } else {
                    host_system_send(SYSTEM_POWER_DOWN);
                }
#else
                host_system_send(SYSTEM_POWER_DOWN);
#endif
                host_system_send(0);
                _delay_ms(500);
                system_code = SYSTEM_POWER_DOWN;
            } else if (code == KB_SYSTEM_SLEEP) {
                host_system_send(SYSTEM_SLEEP);
                host_system_send(0);
                _delay_ms(500);
                system_code = SYSTEM_SLEEP;
            } else if (code == KB_SYSTEM_WAKE) {
                host_system_send(SYSTEM_WAKE_UP);
                host_system_send(0);
                _delay_ms(500);
                system_code = SYSTEM_WAKE_UP;
            }
            // Consumer Page
            else if (code == KB_AUDIO_MUTE) {


@@ 173,6 165,7 @@ void keyboard_proc(void)
        host_send_keyboard_report();
#ifdef EXTRAKEY_ENABLE
        host_consumer_send(consumer_code);
        host_system_send(system_code);
#endif
#ifdef DEBUG_LED
        // LED flash for debug

M common/mousekey.c => common/mousekey.c +2 -2
@@ 121,12 121,12 @@ void mousekey_clear_report(void)
static void mousekey_debug(void)
{
    if (!debug_mouse) return;
    print("mousekey[btn|x y v h]: ");
    print("mousekey [btn|x y v h]rep: [");
    phex(report.buttons); print("|");
    phex(report.x); print(" ");
    phex(report.y); print(" ");
    phex(report.v); print(" ");
    phex(report.h);
    phex(report.h); print("]");
    phex(mousekey_repeat);
    print("\n");
}

M keyboard/lufa/Makefile => keyboard/lufa/Makefile +3 -2
@@ 128,7 128,8 @@ LUFA_SRC = $(TARGET).c \
SRC = $(subst $(LUFA_PATH)/LUFA/,,$(LUFA_SRC))
SRC +=	keymap.c \
	matrix.c \
	led.c
	led.c \
	pjrc/bootloader_teensy.c
CONFIG_H = config.h




@@ 137,7 138,7 @@ CONFIG_H = config.h
#
MOUSEKEY_ENABLE = yes	# Mouse keys
#PS2_MOUSE_ENABLE = yes	# PS/2 mouse(TrackPoint) support
#EXTRAKEY_ENABLE = yes	# Audio control and System control
EXTRAKEY_ENABLE = yes	# Audio control and System control
#NKRO_ENABLE = yes	# USB Nkey Rollover



M keyboard/lufa/config.h => keyboard/lufa/config.h +2 -2
@@ 24,8 24,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.

/* USB Device descriptor */
#define VENDOR_ID       0xFEED
#define PRODUCT_ID      0xBEE1
#define DEVICE_VER      0x0101
#define PRODUCT_ID      0xBEE6
#define DEVICE_VER      0x0202
#define MANUFACTURER    t.m.k.
#define PRODUCT         Macway mod(LUFA)


M keyboard/lufa/descriptor.c => keyboard/lufa/descriptor.c +118 -25
@@ 37,6 37,7 @@
*/

#include "util.h"
#include "report.h"
#include "descriptor.h"




@@ 86,27 87,43 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
    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_USAGE_MINIMUM(8, 0x01),  /* Button 1 */
            HID_RI_USAGE_MAXIMUM(8, 0x05),  /* Button 5 */
            HID_RI_LOGICAL_MINIMUM(8, 0x00),
            HID_RI_LOGICAL_MAXIMUM(8, 0x01),
            HID_RI_REPORT_COUNT(8, 0x03),
            HID_RI_REPORT_COUNT(8, 0x05),
            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_REPORT_SIZE(8, 0x03),
            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_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            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_USAGE(8, 0x38), /* Wheel */
            HID_RI_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            HID_RI_REPORT_COUNT(8, 0x01),
            HID_RI_REPORT_SIZE(8, 0x08),
            HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),

            HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
            HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
            HID_RI_LOGICAL_MINIMUM(8, -127),
            HID_RI_LOGICAL_MAXIMUM(8, 127),
            HID_RI_REPORT_COUNT(8, 0x01),
            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),
};


@@ 115,22 132,50 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
{
    HID_RI_USAGE_PAGE(16, 0xFF00), /* Vendor Page 0 */
    HID_RI_USAGE(8, 0x01), /* Vendor Usage 1 */
    HID_RI_COLLECTION(8, 0x01), /* Vendor Usage 1 */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_USAGE(8, 0x02), /* Vendor Usage 2 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_REPORT_COUNT(8, GENERIC_REPORT_SIZE),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
        HID_RI_USAGE(8, 0x03), /* Vendor Usage 3 */
        HID_RI_LOGICAL_MINIMUM(8, 0x00),
        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_REPORT_COUNT(8, GENERIC_REPORT_SIZE),
        HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
        HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
    HID_RI_END_COLLECTION(0),
};

const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtraReport[] =
{
    HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
    HID_RI_USAGE(8, 0x80), /* System Control */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
        HID_RI_LOGICAL_MINIMUM(16, 0x0081),
        HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
        HID_RI_USAGE_MINIMUM(16, 0x0081), /* System Power Down */
        HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
        HID_RI_REPORT_SIZE(8, 16),
        HID_RI_REPORT_COUNT(8, 1),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
    HID_RI_END_COLLECTION(0),

    HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
    HID_RI_USAGE(8, 0x01), /* Consumer Control */
    HID_RI_COLLECTION(8, 0x01), /* Application */
        HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
        HID_RI_LOGICAL_MINIMUM(16, 0x0010),
        HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
        HID_RI_USAGE_MINIMUM(16, 0x0010), /* +10 */
        HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
        HID_RI_REPORT_SIZE(8, 16),
        HID_RI_REPORT_COUNT(8, 1),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
    HID_RI_END_COLLECTION(0),
};

/*******************************************************************************
 * Device Descriptors


@@ 167,7 212,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
            .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},

            .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
            .TotalInterfaces        = 3,
            .TotalInterfaces        = TOTAL_INTERFACES,

            .ConfigurationNumber    = 1,
            .ConfigurationStrIndex  = NO_DESCRIPTOR,


@@ 177,9 222,9 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
            .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
        },

        /*
         * Keyboard
         */
    /*
     * Keyboard
     */
    .Keyboard_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},


@@ 213,7 258,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =

            .EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = HID_EPSIZE,
            .EndpointSize           = KEYBOARD_EPSIZE,
            .PollingIntervalMS      = 0x01
        },



@@ 253,7 298,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =

            .EndpointAddress        = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = HID_EPSIZE,
            .EndpointSize           = MOUSE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },



@@ 264,7 309,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = GENERIC_INTERFACE,
            .InterfaceNumber        = CONSOLE_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 2,


@@ 291,9 336,9 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | GENERIC_IN_EPNUM),
            .EndpointAddress        = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = GENERIC_EPSIZE,
            .EndpointSize           = CONSOLE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },



@@ 301,11 346,51 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_OUT | GENERIC_OUT_EPNUM),
            .EndpointAddress        = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = CONSOLE_EPSIZE,
            .PollingIntervalMS      = 0x01
        },

    /*
     * Extra
     */
    .Extra_Interface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = EXTRA_INTERFACE,
            .AlternateSetting       = 0x00,

            .TotalEndpoints         = 1,

            .Class                  = HID_CSCP_HIDClass,
            .SubClass               = HID_CSCP_NonBootSubclass,
            .Protocol               = HID_CSCP_NonBootProtocol,

            .InterfaceStrIndex      = NO_DESCRIPTOR
        },

    .Extra_HID =
        {
            .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(ExtraReport)
        },

    .Extra_INEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DIR_IN | EXTRA_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = GENERIC_EPSIZE,
            .EndpointSize           = EXTRA_EPSIZE,
            .PollingIntervalMS      = 0x01
        }
        },
};




@@ 387,10 472,14 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                Address = &ConfigurationDescriptor.Mouse_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            case GENERIC_INTERFACE:
            case CONSOLE_INTERFACE:
                Address = &ConfigurationDescriptor.Console_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            case EXTRA_INTERFACE:
                Address = &ConfigurationDescriptor.Extra_HID;
                Size    = sizeof(USB_HID_Descriptor_HID_t);
                break;
            }
            break;
        case HID_DTYPE_Report:


@@ 403,10 492,14 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                Address = &MouseReport;
                Size    = sizeof(MouseReport);
                break;
            case GENERIC_INTERFACE:
            case CONSOLE_INTERFACE:
                Address = &ConsoleReport;
                Size    = sizeof(ConsoleReport);
                break;
            case EXTRA_INTERFACE:
                Address = &ExtraReport;
                Size    = sizeof(ExtraReport);
                break;
            }
            break;
    }

M keyboard/lufa/descriptor.h => keyboard/lufa/descriptor.h +20 -8
@@ 60,22 60,34 @@ typedef struct
    USB_HID_Descriptor_HID_t              Console_HID;
    USB_Descriptor_Endpoint_t             Console_INEndpoint;
    USB_Descriptor_Endpoint_t             Console_OUTEndpoint;

    // Extra HID Interface
    USB_Descriptor_Interface_t            Extra_Interface;
    USB_HID_Descriptor_HID_t              Extra_HID;
    USB_Descriptor_Endpoint_t             Extra_INEndpoint;
} USB_Descriptor_Configuration_t;


/* nubmer of interfaces */
#define TOTAL_INTERFACES            4

/* index of interface */
#define KEYBOARD_INTERFACE          0
#define MOUSE_INTERFACE             1
#define GENERIC_INTERFACE           2
#define CONSOLE_INTERFACE           2
#define EXTRA_INTERFACE             3

// Endopoint number/size
// Endopoint number and size
#define KEYBOARD_IN_EPNUM           1
#define MOUSE_IN_EPNUM              2
#define GENERIC_IN_EPNUM            3
#define GENERIC_OUT_EPNUM           4

#define HID_EPSIZE                  8
#define GENERIC_EPSIZE              8
#define GENERIC_REPORT_SIZE         8
#define CONSOLE_IN_EPNUM            3
#define CONSOLE_OUT_EPNUM           4
#define EXTRA_IN_EPNUM              5

#define KEYBOARD_EPSIZE             8
#define MOUSE_EPSIZE                8
#define CONSOLE_EPSIZE              8
#define EXTRA_EPSIZE                8


uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,

M keyboard/lufa/keymap.c => keyboard/lufa/keymap.c +1 -1
@@ 110,7 110,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     * |   |Gui |Alt  |                      |Alt  |Gui|   |   |Ctr|
     * `-----------------------------------------------------------'
     */ 
    KEYMAP(ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, DEL, \
    KEYMAP(PWR, 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, \

M keyboard/lufa/lufa.c => keyboard/lufa/lufa.c +44 -18
@@ 117,7 117,7 @@ static void Console_HID_Task(void)
	  return;

        // TODO: impl receivechar()/recvchar()
	Endpoint_SelectEndpoint(GENERIC_OUT_EPNUM);
	Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);

	/* Check to see if a packet has been sent from the host */
	if (Endpoint_IsOUTReceived())


@@ 126,7 126,7 @@ static void Console_HID_Task(void)
		if (Endpoint_IsReadWriteAllowed())
		{
			/* Create a temporary buffer to hold the read in report from the host */
			uint8_t ConsoleData[GENERIC_REPORT_SIZE];
			uint8_t ConsoleData[CONSOLE_EPSIZE];

			/* Read Console Report Data */
			Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);


@@ 140,7 140,7 @@ static void Console_HID_Task(void)
	}

        /* IN packet */
	Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
	Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
        // send IN packet
	if (Endpoint_IsINReady())
            Endpoint_ClearIN();


@@ 169,17 169,21 @@ void EVENT_USB_Device_ConfigurationChanged(void)

    /* Setup Keyboard HID Report Endpoints */
    ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
                                                HID_EPSIZE, ENDPOINT_BANK_SINGLE);
                                                KEYBOARD_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);
                                                MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);

    /* Setup Console HID Report Endpoints */
    ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
                                                GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
    ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
                                                GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
    ConfigSuccess &= Endpoint_ConfigureEndpoint(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
                                                CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
    ConfigSuccess &= Endpoint_ConfigureEndpoint(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
                                                CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);

    /* Setup Extra HID Report Endpoint */
    ConfigSuccess &= Endpoint_ConfigureEndpoint(EXTRA_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
                                                EXTRA_EPSIZE, ENDPOINT_BANK_SINGLE);
}

/*


@@ 223,7 227,9 @@ void EVENT_USB_Device_ControlRequest(void)
                    ReportData = (uint8_t*)&mouse_report_sent;
                    ReportSize = sizeof(mouse_report_sent);
                    break;
                case GENERIC_INTERFACE:
                case CONSOLE_INTERFACE:
                    break;
                case EXTRA_INTERFACE:
                    break;
                }



@@ 254,7 260,9 @@ void EVENT_USB_Device_ControlRequest(void)
                    break;
                case MOUSE_INTERFACE:
                    break;
                case GENERIC_INTERFACE:
                case CONSOLE_INTERFACE:
                    break;
                case EXTRA_INTERFACE:
                    break;
                }



@@ 301,12 309,7 @@ static void send_mouse(report_mouse_t *report)
    if (Endpoint_IsReadWriteAllowed())
    {
        /* Write Mouse Report Data */
        /* Mouse report data structure
         * LUFA: { buttons, x, y }
         * tmk:  { buttons, x, y, v, h }
         */
        //Endpoint_Write_Stream_LE((uint8_t *)report+1, 3, NULL);
        Endpoint_Write_Stream_LE(report, 3, NULL);
        Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);

        /* Finalize the stream transfer to send the last packet */
        Endpoint_ClearIN();


@@ 314,12 317,35 @@ static void send_mouse(report_mouse_t *report)
    mouse_report_sent = *report;
}

typedef struct {
    uint8_t  report_id;
    uint16_t usage;
} __attribute__ ((packed)) report_extra_t;

static void send_system(uint16_t data)
{
    Endpoint_SelectEndpoint(EXTRA_IN_EPNUM);
    if (Endpoint_IsReadWriteAllowed()) {
        report_extra_t r = {
            .report_id = REPORT_ID_SYSTEM,
            .usage = data
        };
        Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
        Endpoint_ClearIN();
    }
}

static void send_consumer(uint16_t data)
{
    Endpoint_SelectEndpoint(EXTRA_IN_EPNUM);
    if (Endpoint_IsReadWriteAllowed()) {
        report_extra_t r = {
            .report_id = REPORT_ID_CONSUMER,
            .usage = data
        };
        Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
        Endpoint_ClearIN();
    }
}




@@ 331,7 357,7 @@ int8_t sendchar(uint8_t c)
    if (USB_DeviceState != DEVICE_STATE_Configured)
      return -1;

    Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
    Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);

    uint8_t timeout = 10;
    uint16_t prevFN = USB_Device_GetFrameNumber();

M protocol/vusb/main.c => protocol/vusb/main.c +0 -5
@@ 62,11 62,6 @@ int main(void)

    debug("initForUsbConnectivity()\n");
    initForUsbConnectivity();
    int i;
    while(--i){         /* To configured */
        usbPoll();
        _delay_ms(1);
    }

    debug("main loop\n");
    while (1) {

M protocol/vusb/vusb.c => protocol/vusb/vusb.c +15 -22
@@ 107,32 107,25 @@ static void send_mouse(report_mouse_t *report)
    }
}

/*

typedef struct {
    uint8_t report_id;
    uint8_t data0;
    uint8_t data1;
} __attribute__ ((packed)) vusb_system_report_t;
*/
    uint8_t  report_id;
    uint16_t usage;
} __attribute__ ((packed)) report_extra_t;

static void send_system(uint16_t data)
{
/*
    // Not need static?
    static uint8_t report[] = { REPORT_ID_SYSTEM, 0, 0 };
    report[1] = data&0xFF;
    report[2] = (data>>8)&0xFF;
*/
/*
    vusb_system_report_t r = {
    static uint16_t last_data = 0;
    if (data == last_data) return;
    last_data = data;

    report_extra_t report = {
        .report_id = REPORT_ID_SYSTEM,
        .data0 = data&0xFF,
        .data1 = (data>>8)&0xFF
        .usage = data
    };
    if (usbInterruptIsReady3()) {
        usbSetInterrupt3((void *)&r, sizeof(vusb_system_report_t));
        usbSetInterrupt3((void *)&report, sizeof(report));
    }
*/
}

static void send_consumer(uint16_t data)


@@ 141,10 134,10 @@ static void send_consumer(uint16_t data)
    if (data == last_data) return;
    last_data = data;

    // Not need static?
    static uint8_t report[] = { REPORT_ID_CONSUMER, 0, 0 };
    report[1] = data&0xFF;
    report[2] = (data>>8)&0xFF;
    report_extra_t report = {
        .report_id = REPORT_ID_CONSUMER,
        .usage = data
    };
    if (usbInterruptIsReady3()) {
        usbSetInterrupt3((void *)&report, sizeof(report));
    }