Make NKRO deafult when it is available
authortmk <nobody@nowhere>
Fri, 25 Apr 2014 06:32:21 +0000 (15:32 +0900)
committertmk <nobody@nowhere>
Sat, 26 Apr 2014 19:16:49 +0000 (04:16 +0900)
- NKRO is used only when keyboard_protocol = 1(report)

common/action_util.c
common/command.c
common/host.c
common/host.h
protocol/lufa/lufa.c
protocol/pjrc/usb.c
protocol/pjrc/usb_keyboard.c
protocol/pjrc/usb_keyboard.h

index 99a3adaab63fc2cf8f61fc17c49557d742932622..ebe7150dcc13eadef09a651b9f6b1f79b6171e83 100644 (file)
@@ -67,7 +67,7 @@ void send_keyboard_report(void) {
 void add_key(uint8_t key)
 {
 #ifdef NKRO_ENABLE
-    if (keyboard_nkro) {
+    if (keyboard_nkro && keyboard_protocol) {
         add_key_bit(key);
         return;
     }
@@ -78,7 +78,7 @@ void add_key(uint8_t key)
 void del_key(uint8_t key)
 {
 #ifdef NKRO_ENABLE
-    if (keyboard_nkro) {
+    if (keyboard_nkro && keyboard_protocol) {
         del_key_bit(key);
         return;
     }
@@ -151,7 +151,7 @@ uint8_t has_anymod(void)
 uint8_t get_first_key(void)
 {
 #ifdef NKRO_ENABLE
-    if (keyboard_nkro) {
+    if (keyboard_nkro && keyboard_protocol) {
         uint8_t i = 0;
         for (; i < REPORT_BITS && !keyboard_report->nkro.bits[i]; i++)
             ;
index f6f2769513ed9eff1c1cfe88134b52276f4b061c..d2f8eb8320f0f07642201ac10de58cfb31208c07 100644 (file)
@@ -301,13 +301,13 @@ static bool command_common(uint8_t code)
         case KC_S:
             print("\n\n----- Status -----\n");
             print_val_hex8(host_keyboard_leds());
+            print_val_hex8(keyboard_protocol);
+            print_val_hex8(keyboard_idle);
 #ifdef PROTOCOL_PJRC
             print_val_hex8(UDCON);
             print_val_hex8(UDIEN);
             print_val_hex8(UDINT);
             print_val_hex8(usb_keyboard_leds);
-            print_val_hex8(usb_keyboard_protocol);
-            print_val_hex8(usb_keyboard_idle_config);
             print_val_hex8(usb_keyboard_idle_count);
 #endif
 
index 1eafef75cc3c2d6c5e13346fb250be1c9225a769..2e56971bddb6a9abca480f3d7764a0b0585dc136 100644 (file)
@@ -24,7 +24,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 #ifdef NKRO_ENABLE
-bool keyboard_nkro = false;
+bool keyboard_nkro = true;
 #endif
 
 static host_driver_t *driver;
index 8ff26298527587f50347e5ef6160c7a54991eb70..a56e6c3b04f05d115eb8d408213c7fbc86f6b445 100644 (file)
@@ -32,6 +32,9 @@ extern "C" {
 extern bool keyboard_nkro;
 #endif
 
+uint8_t keyboard_idle;
+uint8_t keyboard_protocol;
+
 
 /* host driver */
 void host_set_driver(host_driver_t *driver);
index 86e9f23d1775c35b058a6df09a147c6592d69405..a43a552a81b06a80d6421f19c9ece69ca029ee3d 100644 (file)
@@ -52,8 +52,8 @@
 #include "descriptor.h"
 #include "lufa.h"
 
-static uint8_t idle_duration = 0;
-static uint8_t protocol_report = 1;
+uint8_t keyboard_idle = 0;
+uint8_t keyboard_protocol = 1;
 static uint8_t keyboard_led_stats = 0;
 
 static report_keyboard_t keyboard_report_sent;
@@ -290,21 +290,26 @@ void EVENT_USB_Device_ControlRequest(void)
         case HID_REQ_GetProtocol:
             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
             {
-                Endpoint_ClearSETUP();
-                while (!(Endpoint_IsINReady()));
-                Endpoint_Write_8(protocol_report);
-                Endpoint_ClearIN();
-                Endpoint_ClearStatusStage();
+                if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
+                    Endpoint_ClearSETUP();
+                    while (!(Endpoint_IsINReady()));
+                    Endpoint_Write_8(keyboard_protocol);
+                    Endpoint_ClearIN();
+                    Endpoint_ClearStatusStage();
+                }
             }
 
             break;
         case HID_REQ_SetProtocol:
             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
             {
-                Endpoint_ClearSETUP();
-                Endpoint_ClearStatusStage();
+                if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
+                    Endpoint_ClearSETUP();
+                    Endpoint_ClearStatusStage();
 
-                protocol_report = ((USB_ControlRequest.wValue & 0xFF) != 0x00);
+                    keyboard_protocol = ((USB_ControlRequest.wValue & 0xFF) != 0x00);
+                    clear_keyboard();
+                }
             }
 
             break;
@@ -314,7 +319,7 @@ void EVENT_USB_Device_ControlRequest(void)
                 Endpoint_ClearSETUP();
                 Endpoint_ClearStatusStage();
 
-                idle_duration = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
+                keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
             }
 
             break;
@@ -323,7 +328,7 @@ void EVENT_USB_Device_ControlRequest(void)
             {
                 Endpoint_ClearSETUP();
                 while (!(Endpoint_IsINReady()));
-                Endpoint_Write_8(idle_duration);
+                Endpoint_Write_8(keyboard_idle);
                 Endpoint_ClearIN();
                 Endpoint_ClearStatusStage();
             }
@@ -349,32 +354,28 @@ static void send_keyboard(report_keyboard_t *report)
 
     /* Select the Keyboard Report Endpoint */
 #ifdef NKRO_ENABLE
-    if (keyboard_nkro) {
+    if (keyboard_nkro && keyboard_protocol) {
+        /* Report protocol - NKRO */
         Endpoint_SelectEndpoint(NKRO_IN_EPNUM);
 
         /* Check if write ready for a polling interval around 1ms */
         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(4);
         if (!Endpoint_IsReadWriteAllowed()) return;
+
+        /* Write Keyboard Report Data */
+        Endpoint_Write_Stream_LE(report, NKRO_EPSIZE, NULL);
     }
     else
 #endif
     {
+        /* Boot protocol */
         Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
 
         /* Check if write ready for a polling interval around 10ms */
         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
         if (!Endpoint_IsReadWriteAllowed()) return;
-    }
 
-    /* Write Keyboard Report Data */
-#ifdef NKRO_ENABLE
-    if (keyboard_nkro) {
-        Endpoint_Write_Stream_LE(report, NKRO_EPSIZE, NULL);
-    }
-    else
-#endif
-    {
-        /* boot mode */
+        /* Write Keyboard Report Data */
         Endpoint_Write_Stream_LE(report, KEYBOARD_EPSIZE, NULL);
     }
 
index 393b36f78e04048a87ec1a6c49e92e1927c03a5f..b09ad3f233ffa82b5c80108bb2509db02540197b 100644 (file)
@@ -38,6 +38,7 @@
 #include "sleep_led.h"
 #endif
 #include "suspend.h"
+#include "action.h"
 #include "action_util.h"
 
 
@@ -692,20 +693,20 @@ ISR(USB_GEN_vect)
                }
                 /* TODO: should keep IDLE rate on each keyboard interface */
 #ifdef NKRO_ENABLE
-               if (!keyboard_nkro && usb_keyboard_idle_config && (++div4 & 3) == 0) {
+               if (!keyboard_nkro && keyboard_idle && (++div4 & 3) == 0) {
 #else
-               if (usb_keyboard_idle_config && (++div4 & 3) == 0) {
+               if (keyboard_idle && (++div4 & 3) == 0) {
 #endif
                        UENUM = KBD_ENDPOINT;
                        if (UEINTX & (1<<RWAL)) {
                                usb_keyboard_idle_count++;
-                               if (usb_keyboard_idle_count == usb_keyboard_idle_config) {
+                               if (usb_keyboard_idle_count == keyboard_idle) {
                                        usb_keyboard_idle_count = 0;
                                         /* TODO: fix keyboard_report inconsistency */
 /* To avoid Mac SET_IDLE behaviour.
                                        UEDATX = keyboard_report_prev->mods;
                                        UEDATX = 0;
-                                        uint8_t keys = usb_keyboard_protocol ? KBD_REPORT_KEYS : 6;
+                                        uint8_t keys = keyboard_protocol ? KBD_REPORT_KEYS : 6;
                                        for (uint8_t i=0; i<keys; i++) {
                                                UEDATX = keyboard_report_prev->keys[i];
                                        }
@@ -901,13 +902,13 @@ ISR(USB_COM_vect)
                                }
                                if (bRequest == HID_GET_IDLE) {
                                        usb_wait_in_ready();
-                                       UEDATX = usb_keyboard_idle_config;
+                                       UEDATX = keyboard_idle;
                                        usb_send_in();
                                        return;
                                }
                                if (bRequest == HID_GET_PROTOCOL) {
                                        usb_wait_in_ready();
-                                       UEDATX = usb_keyboard_protocol;
+                                       UEDATX = keyboard_protocol;
                                        usb_send_in();
                                        return;
                                }
@@ -921,14 +922,15 @@ ISR(USB_COM_vect)
                                        return;
                                }
                                if (bRequest == HID_SET_IDLE) {
-                                       usb_keyboard_idle_config = (wValue >> 8);
+                                       keyboard_idle = (wValue >> 8);
                                        usb_keyboard_idle_count = 0;
                                        //usb_wait_in_ready();
                                        usb_send_in();
                                        return;
                                }
                                if (bRequest == HID_SET_PROTOCOL) {
-                                       usb_keyboard_protocol = wValue;
+                                       keyboard_protocol = wValue;
+                                        clear_keyboard();
                                        //usb_wait_in_ready();
                                        usb_send_in();
                                        return;
index de798fcc229a72ad47ef9e7f7a5a7e51f4c4dadb..c11995db6f7a7adf80e9d3a6ceef23d00c38fede 100644 (file)
 // protocol setting from the host.  We use exactly the same report
 // either way, so this variable only stores the setting since we
 // are required to be able to report which setting is in use.
-uint8_t usb_keyboard_protocol=1;
+uint8_t keyboard_protocol=1;
 
 // the idle configuration, how often we send the report to the
 // host (ms * 4) even when it hasn't changed
 // Windows and Linux set 0 while OS X sets 6(24ms) by SET_IDLE request.
-uint8_t usb_keyboard_idle_config=125;
+uint8_t keyobard_idle=125;
 
 // count until idle timeout
 uint8_t usb_keyboard_idle_count=0;
@@ -56,15 +56,12 @@ int8_t usb_keyboard_send_report(report_keyboard_t *report)
     int8_t result = 0;
 
 #ifdef NKRO_ENABLE
-    if (keyboard_nkro)
+    if (keyboard_nkro && keyboard_protocol)
         result = send_report(report, KBD2_ENDPOINT, 0, KBD2_SIZE);
     else
 #endif
     {
-        if (usb_keyboard_protocol)
-            result = send_report(report, KBD_ENDPOINT, 0, KBD_SIZE);
-        else
-            result = send_report(report, KBD_ENDPOINT, 0, 6);
+        result = send_report(report, KBD_ENDPOINT, 0, KBD_SIZE);
     }
 
     if (result) return result;
index c362ca3b8621f442a85fec7f7a90a5043534189c..9b798e9a864eee6df01ac5a4e325453857dc015a 100644 (file)
@@ -30,8 +30,6 @@
 #include "host.h"
 
 
-extern uint8_t usb_keyboard_protocol;
-extern uint8_t usb_keyboard_idle_config;
 extern uint8_t usb_keyboard_idle_count;
 extern volatile uint8_t usb_keyboard_leds;
 
Imprint / Impressum