Make NKRO deafult when it is available

- NKRO is used only when keyboard_protocol = 1(report)

8 files changed, 47 insertions, 46 deletions

diff --git a/common/action_util.c b/common/action_util.c
index 99a3adaab6..ebe7150dcc 100644
--- a/common/action_util.c
+++ b/common/action_util.c
@@ -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++)
             ;
diff --git a/common/command.c b/common/command.c
index f6f2769513..d2f8eb8320 100644
--- a/common/command.c
+++ b/common/command.c
@@ -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
 
diff --git a/common/host.c b/common/host.c
index 1eafef75cc..2e56971bdd 100644
--- a/common/host.c
+++ b/common/host.c
@@ -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;
diff --git a/common/host.h b/common/host.h
index 8ff2629852..a56e6c3b04 100644
--- a/common/host.h
+++ b/common/host.h
@@ -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);
diff --git a/protocol/lufa/lufa.c b/protocol/lufa/lufa.c
index 86e9f23d17..a43a552a81 100644
--- a/protocol/lufa/lufa.c
+++ b/protocol/lufa/lufa.c
@@ -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);
     }
 
diff --git a/protocol/pjrc/usb.c b/protocol/pjrc/usb.c
index 393b36f78e..b09ad3f233 100644
--- a/protocol/pjrc/usb.c
+++ b/protocol/pjrc/usb.c
@@ -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;
diff --git a/protocol/pjrc/usb_keyboard.c b/protocol/pjrc/usb_keyboard.c
index de798fcc22..c11995db6f 100644
--- a/protocol/pjrc/usb_keyboard.c
+++ b/protocol/pjrc/usb_keyboard.c
@@ -34,12 +34,12 @@
 // 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;
diff --git a/protocol/pjrc/usb_keyboard.h b/protocol/pjrc/usb_keyboard.h
index c362ca3b86..9b798e9a86 100644
--- a/protocol/pjrc/usb_keyboard.h
+++ b/protocol/pjrc/usb_keyboard.h
@@ -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;