Merge pull request #8 from RobertDaleSmith/sgowda/hid-update

updating descriptor

Author: RobertDaleSmith

ncs/app/src/ble_hid.c

@@ -41,6 +41,40 @@ LOG_MODULE_REGISTER(ble_hid, LOG_LEVEL_INF);
 static ble_hid_data_received_cb_t data_received_callback = NULL;
 static ble_hid_ready_cb_t ready_callback = NULL;
 
+/**
+ * Consumer Control usage codes for backwards compatibility.
+ * Maps old 1-byte bitmap format to new 16-bit usage selector format.
+ * Old firmware used 8 individual bit flags, new descriptor uses usage codes.
+ */
+static const uint16_t consumer_bitmap_to_usage[] = {
+	0x00CD,  /* bit 0: Play/Pause */
+	0x0183,  /* bit 1: AL Consumer Control Configuration */
+	0x00B5,  /* bit 2: Scan Next Track */
+	0x00B6,  /* bit 3: Scan Previous Track */
+	0x00EA,  /* bit 4: Volume Decrement */
+	0x00E9,  /* bit 5: Volume Increment */
+	0x0225,  /* bit 6: AC Forward */
+	0x0224,  /* bit 7: AC Back */
+};
+
+/**
+ * Translate old consumer control bitmap to new 16-bit usage format.
+ * Returns the usage code for the first set bit, or 0 if no bits set.
+ */
+static uint16_t translate_consumer_bitmap(uint8_t bitmap)
+{
+	if (bitmap == 0) {
+		return 0;
+	}
+	/* Find first set bit and return corresponding usage */
+	for (int i = 0; i < 8; i++) {
+		if (bitmap & (1 << i)) {
+			return consumer_bitmap_to_usage[i];
+		}
+	}
+	return 0;
+}
+
 /**
  * Switch between boot protocol and report protocol mode.
  */
@@ -172,14 +206,29 @@ static uint8_t hogp_notify_cb(struct bt_hogp *hogp,
 
 	// Parse and forward each report ID independently
 	if (size >= 1) {
-		/* Send directly to USB for zero latency */
-		uint8_t report_with_id[size + 1];
-		report_with_id[0] = report_id;
-		for (uint8_t i = 0; i < size; i++) {
-			report_with_id[i + 1] = data[i];
+		int ret;
+
+		/* Handle Report ID 3 (Consumer Control) backwards compatibility */
+		if (report_id == 3 && size == 1) {
+			/* Old firmware sends 1-byte bitmap, translate to 16-bit usage */
+			uint16_t usage = translate_consumer_bitmap(data[0]);
+			uint8_t consumer_report[3] = {
+				0x03,              /* Report ID 3 */
+				usage & 0xFF,     /* Usage low byte */
+				(usage >> 8) & 0xFF  /* Usage high byte */
+			};
+			LOG_DBG("Consumer control: bitmap 0x%02x -> usage 0x%04x", data[0], usage);
+			ret = hid_device_submit_report(hid_dev, sizeof(consumer_report), consumer_report);
+		} else {
+			/* Send directly to USB for zero latency */
+			uint8_t report_with_id[size + 1];
+			report_with_id[0] = report_id;
+			for (uint8_t i = 0; i < size; i++) {
+				report_with_id[i + 1] = data[i];
+			}
+			ret = hid_device_submit_report(hid_dev, size + 1, report_with_id);
 		}
 
-		int ret = hid_device_submit_report(hid_dev, size + 1, report_with_id);
 		if (ret) {
 			LOG_ERR("HID write error, %d", ret);
 		} else {

ncs/app/src/usb_hid.c

@@ -59,18 +59,18 @@ static bool usb_enumerated = false;
  * This descriptor matches the MouthPad BLE device exactly to eliminate scaling
  */
 static const uint8_t hid_report_desc[] = {
-    0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x85, 0x01, 0x09, 0x01, 0xA1, 0x00,
-    0x95, 0x05, 0x75, 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x05, 0x15, 0x00,
-    0x25, 0x01, 0x81, 0x02, 0x95, 0x01, 0x75, 0x03, 0x81, 0x01, 0x75, 0x08,
-    0x95, 0x01, 0x05, 0x01, 0x09, 0x38, 0x15, 0x81, 0x25, 0x7F, 0x81, 0x06,
-    0x05, 0x0C, 0x0A, 0x38, 0x02, 0x95, 0x01, 0x81, 0x06, 0xC0, 0x85, 0x02,
-    0x09, 0x01, 0xA1, 0x00, 0x75, 0x0C, 0x95, 0x02, 0x05, 0x01, 0x09, 0x30,
-    0x09, 0x31, 0x16, 0x01, 0xF8, 0x26, 0xFF, 0x07, 0x81, 0x06, 0xC0, 0xC0,
-    0x05, 0x0C, 0x09, 0x01, 0xA1, 0x01, 0x85, 0x03, 0x15, 0x00, 0x25, 0x01,
-    0x75, 0x01, 0x95, 0x01, 0x09, 0xCD, 0x81, 0x06, 0x0A, 0x83, 0x01, 0x81,
-    0x06, 0x09, 0xB5, 0x81, 0x06, 0x09, 0xB6, 0x81, 0x06, 0x09, 0xEA, 0x81,
-    0x06, 0x09, 0xE9, 0x81, 0x06, 0x0A, 0x25, 0x02, 0x81, 0x06, 0x0A, 0x24,
-    0x02, 0x81, 0x06, 0xC0
+	0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x85, 0x01, 0x09, 0x01, 0xA1, 0x00, 0x95, 
+	0x05, 0x75, 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x05, 0x15, 0x00, 0x25, 0x01, 
+	0x81, 0x02, 0x95, 0x01, 0x75, 0x03, 0x81, 0x01, 0x75, 0x08, 0x95, 0x01, 0x05, 
+	0x01, 0x09, 0x38, 0x15, 0x81, 0x25, 0x7F, 0x81, 0x06, 0x05, 0x0C, 0x0A, 0x38, 
+	0x02, 0x95, 0x01, 0x81, 0x06, 0xC0, 0x85, 0x02, 0x09, 0x01, 0xA1, 0x00, 0x75, 
+	0x0C, 0x95, 0x02, 0x05, 0x01, 0x09, 0x30, 0x09, 0x31, 0x16, 0x01, 0xF8, 0x26, 
+	0xFF, 0x07, 0x81, 0x06, 0xC0, 0x85, 0x03, 0x05, 0x0C, 0x19, 0x00, 0x2A, 0x3C, 
+	0x02, 0x15, 0x00, 0x26, 0x3C, 0x02, 0x75, 0x10, 0x95, 0x01, 0x81, 0x00, 0xC0, 
+	0x05, 0x01, 0x09, 0x06, 0xA1, 0x01, 0x85, 0x04, 0x05, 0x07, 0x19, 0xE0, 0x29, 
+	0xE7, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02, 0x95, 0x01, 
+	0x75, 0x08, 0x81, 0x01, 0x95, 0x06, 0x75, 0x08, 0x15, 0x00, 0x25, 0x65, 0x05, 
+	0x07, 0x19, 0x00, 0x29, 0x65, 0x81, 0x00, 0xC0
 };
 
 /* ============================================================================
@@ -453,10 +453,24 @@ int usb_hid_send_release_all(void)
 		0x00   /* Y high byte = 0 */
 	};
 
-	/* Report ID 3: Release all consumer controls */
+	/* Report ID 3: Release all consumer controls (16-bit usage selector) */
 	uint8_t report3[] = {
 		0x03,  /* Report ID 3 */
-		0x00   /* No consumer controls pressed */
+		0x00,  /* Consumer control usage low byte */
+		0x00   /* Consumer control usage high byte */
+	};
+
+	/* Report ID 4: Release all keyboard keys */
+	uint8_t report4[] = {
+		0x04,  /* Report ID 4 */
+		0x00,  /* Modifier keys */
+		0x00,  /* Reserved */
+		0x00,  /* Key 1 */
+		0x00,  /* Key 2 */
+		0x00,  /* Key 3 */
+		0x00,  /* Key 4 */
+		0x00,  /* Key 5 */
+		0x00   /* Key 6 */
 	};
 
 	/* Send clear reports 3 times to ensure USB host processes them */
@@ -491,6 +505,16 @@ int usb_hid_send_release_all(void)
 		} else {
 			LOG_INF("Release report 3 sent round %d (consumer controls cleared)", round + 1);
 		}
+		k_msleep(10);  /* 10ms delay between reports */
+
+		/* Send Report 4 - Release keyboard keys */
+		ret = usb_hid_send_report(report4, sizeof(report4));
+		if (ret != 0) {
+			LOG_ERR("Failed to send release report 4 round %d (err %d)", round + 1, ret);
+			failed_count++;
+		} else {
+			LOG_INF("Release report 4 sent round %d (keyboard cleared)", round + 1);
+		}
 
 		if (round < 2) {
 			k_msleep(20);  /* Longer delay between rounds */