LPC54605J256BD100 - USB1 HSH - TinyUSB connects device, req/rcv 8 byte descriptor - nothing more

[ghost]

Attaching to USB1, high speed host. From the log, you can see all the requirements are present for PHY attach. (I also tested this keypad successfully with pure nxp stack, it's working)
Try as I might, I remain as yet unsuccessful to attach the keypad and enumerate it.
If the keypad is removed when running, execution is broken. Often stepping with resume is the only way to run the code. I have tried to look at the IRQ, but it seems it's running. I don't know what else to try - any ideas welcome - thanks, R. (I want to use the tinyUSB for midiUSB rx + keypad entry)

I'm sure I'm probably doing something very wrong in config or code! I'm new to embedded.

log -

Process: JLinkGDBServerCLExe
RTT init done
Clock Init done
Init Perip. called
power up usb1 done
board init hardware done
USBH init on controller 1, speed = High
sizeof(usbh_data_t) = 40
sizeof(usbh_device_t) = 77
sizeof(hcd_event_t) = 12
sizeof(tuh_xfer_t) = 24
sizeof(tu_fifo_t) = 20
sizeof(tu_edpt_stream_t) = 36
HID init
sizeof(hidh_interface_t) = 14
MIDI init
HUB init
tusb_init SUCCESS - TinyUSB Host started
usb host task created...
Free heap: 104752 bytes (min ever: 104752)
[1:] USBH Device Attach
USBH schedule function after 150 ms
USBH invoke scheduled function
USBH schedule function after 50 ms
USBH invoke scheduled function
USBH schedule function after 2 ms
USBH invoke scheduled function
Low Speed
USBH schedule function after 10 ms
USBH invoke scheduled function
[1:0] Open EP0 with Size = 8
Get 8 byte of Device Descriptor
[1:0] Get Descriptor: 80 06 00 01 00 00 08 00
(stays here)

USB portion of code -

#include <stdio.h>
#include <string.h>
#include "board.h"
#include "peripherals.h"
#include "pin_mux.h"
#include "clock_config.h"
#include "fsl_spi_dma.h"
#include "SEGGER_RTT.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "radio_config_Si4461.h"
#include "fsl_power.h"
#include "fsl_device_registers.h"

#define PRINTF(...) SEGGER_RTT_printf(0, VA_ARGS)

extern "C" int my_printf(const char format, ...)
{
va_list args;
va_start(args, format);
int r = SEGGER_RTT_vprintf(0, format, &args);
va_end(args);
return r;
}
/ ====================== TinyUSB ====================== */
#ifdef __cplusplus
extern "C" {
#endif
#include "tusb.h"
#include "hid_host.h"
#include "midi_host.h"
#ifdef __cplusplus
}
#endif

uint32_t tusb_time_millis_api(void)
{
return xTaskGetTickCount() * portTICK_PERIOD_MS;
}
static const char* keycode_to_ascii(uint8_t keycode, uint8_t modifiers)
{
static char buf[20];
switch (keycode)
{
case 98: return "0"; case 89: return "1"; case 90: return "2"; case 91: return "3";
case 92: return "4"; case 93: return "5"; case 94: return "6"; case 95: return "7";
case 96: return "8"; case 97: return "9"; case 99: return "."; case 85: return "";
case 86: return "-"; case 87: return "+"; case 88: return "[ENTER]"; case 76: return "/";
case 83: return "[NUMLOCK]"; case 42: return "[BACKSPACE]";
case 79: return "[RIGHT]"; case 80: return "[LEFT]"; case 81: return "[DOWN]"; case 82: return "[UP]";
case 75: return "[HOME]"; case 78: return "[PGUP]"; case 77: return "[END]";
case 74: return "[INS]"; case 73: return "[DEL]";
default:
snprintf(buf, sizeof(buf), "[0x%02X]", keycode);
return buf;
}
}
/ ====================== HID Keyboard Callback ====================== /
static void keyboard_report_callback(uint8_t dev_addr, uint8_t instance, uint8_t const report, uint16_t len)
{
if (len == 0 || report == NULL) return;

PRINTF("Keypad Report (%u bytes): ", len);
for (uint32_t i = 0; i < len; i++) {
    PRINTF("%02X ", report[i]);
}
PRINTF("\r\n");

uint8_t modifiers = report[0];
uint8_t key = 0;

for (int i = 2; i < 8 && i < len; i++) {
    if (report[i] != 0) {
        key = report[i];
        break;
    }
}
if (key != 0) {
    PRINTF("⌨️ Key: 0x%02X → %s", key, keycode_to_ascii(key, modifiers));
    if (modifiers) PRINTF(" (Mod:0x%02X)", modifiers);
    PRINTF("\r\n");
} else {
    PRINTF("Key released\r\n");
}

}
/* TinyUSB HID Callbacks /
void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const desc_report, uint16_t desc_len)
{
PRINTF("=== HID Device Mounted! ===\r\n");
PRINTF(" Addr: %d, Instance: %d\r\n", dev_addr, instance);

uint8_t protocol = tuh_hid_get_protocol(dev_addr, instance);
PRINTF("  Protocol: %s\r\n", protocol == HID_PROTOCOL_BOOT ? "BOOT" : "REPORT");

// Try to set boot protocol for keyboards

// if (tuh_hid_set_protocol(dev_addr, instance, HID_PROTOCOL_BOOT) == true)
// PRINTF(" Set Boot Protocol OK\r\n");

tuh_hid_receive_report(dev_addr, instance);

}

void tuh_device_mount_cb(uint8_t daddr)
{
PRINTF("Device mounted at addr %d\r\n", daddr);

tusb_desc_device_t desc;
if (tuh_descriptor_get_device_sync(daddr, &desc, sizeof(desc)) == XFER_RESULT_SUCCESS)
{
    PRINTF("VID:PID = %04X:%04X  Class: %02X\r\n",
           desc.idVendor, desc.idProduct, desc.bDeviceClass);
}

}

void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t instance)
{
PRINTF("HID device unmounted (addr=%d, instance=%d)\r\n", dev_addr, instance);
}

void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t const* report, uint16_t len)
{
keyboard_report_callback(dev_addr, instance, report, len);
tuh_hid_receive_report(dev_addr, instance); // re-arm
}
void USB_HostClockInit(void)
{
#if ((defined USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
CLOCK_EnableUsbhs0HostClock(kCLOCK_UsbSrcUsbPll, 48000000U);
// 1. Force route to Host side by explicitly dropping Bit 16
USBHSH->PORTMODE &= ~(1UL << 16);
// 2. Set Bit 17 (VBUS_DEBOUNCE = 1) to ignore line drift glitches
USBHSH->PORTMODE |= (1UL << 17);
// Clear Bit 8 (Disable internal ID pull-up)
USBHSH->PORTMODE &= ~(1UL << 8);
// Give it a solid delay loop to clear pipeline states
for (volatile uint32_t d = 0; d < 500000; d++) { __NOP(); }
#if ((defined FSL_FEATURE_USBHSH_USB_RAM) && (FSL_FEATURE_USBHSH_USB_RAM > 0U))
for (int i = 0; i < (FSL_FEATURE_USBHSH_USB_RAM >> 2); i++)
{
((uint32_t )FSL_FEATURE_USBHSH_USB_RAM_BASE_ADDRESS)[i] = 0U;
}
#endif
#endif / USB_HOST_CONFIG_IP3511HS */
}

void USB_HostIsrEnable(void)
{
uint8_t irqNumber;
#if ((defined USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
IRQn_Type usbHsIrqs[] = {(IRQn_Type)USB1_IRQn};
irqNumber = usbHsIrqs[CONTROLLER_ID - kUSB_ControllerIp3516Hs0];
#endif

#if defined(__GIC_PRIO_BITS)
GIC_SetPriority((IRQn_Type)irqNumber, USB_HOST_INTERRUPT_PRIORITY);
#else
NVIC_SetPriority((IRQn_Type)irqNumber, USB_HOST_INTERRUPT_PRIORITY);
#endif
EnableIRQ((IRQn_Type)irqNumber);
}

usb_status_t USB_HostApplicationInit(void)
{
usb_status_t status = kStatus_USB_Success;

USB_HostClockInit();
PRINTF("Clock Init done\r\n");

// status = USB_HostInit(CONTROLLER_ID, &g_HostHandle, USB_HostEvent);
// if (status != kStatus_USB_Success)
// {
// PRINTF("USB_HostInit FAILED (status=%d)\r\n", status);
// return status;//
// }
// PRINTF("USB_HostInit SUCCESS\r\n");
// USB_HostIsrEnable();
// PRINTF("host ISR enabled\r\n");
return status;
}

void BOARD_InitHardware(void)
{
BOARD_InitBootPins();
BOARD_InitBootClocks();
BOARD_InitPeripherals();
PRINTF("Init Perip. called\r\n");
// POWER_DisablePD(kPDRUNCFG_PD_USB0_PHY); /*< Turn on USB Phy /
POWER_DisablePD(kPDRUNCFG_PD_USB1_PHY); /< Turn on USB Phy */
PRINTF("power up usb1 done\r\n");
}

#ifdef __cplusplus
extern "C" {
#endif

#if (defined(USB_HOST_CONFIG_IP3516HS) && (USB_HOST_CONFIG_IP3516HS > 0U))
void USB1_IRQHandler(void)
{
tusb_int_handler(1, true);
// NVIC_ClearPendingIRQ(USB1_IRQn); (does nothing conscructive)
}

#endif
#ifdef __cplusplus
}
#endif

static void usb_host_task(void *param)
{
while (1)
{
tuh_task();
vTaskDelay(pdMS_TO_TICKS(1));
// Actually pass the hardware register values into the format string!
// PRINTF("USBSTS=0x%08X PORTSC1=0x%08X\r\n", USBHSH->USBSTS, USBHSH->PORTSC1);
}
}

/* ====================== MAIN ====================== */
int main(void)
{
vPortDefineHeapRegions(xHeapRegions);
SEGGER_RTT_Init();
PRINTF("RTT init done\r\n");
BOARD_InitHardware();
PRINTF("board init hardware done\r\n");
// USB_HostDeinit(g_HostHandle);
tusb_rhport_init_t host_init = {
.role = TUSB_ROLE_HOST,
.speed = TUSB_SPEED_HIGH
};
if (!tusb_init(1, &host_init))
{
PRINTF("tusb_init FAILED\r\n");
while(1);
}
PRINTF("tusb_init SUCCESS - TinyUSB Host started\r\n");

flashCtx.xSem = xSemaphoreCreateBinary();
SPI_MasterTransferCreateHandleDMA(FLEXCOMM5_PERIPHERAL, &FLEXCOMM5_DMA_Handle,
                                  spi_flash_callback, &flashCtx,
                                  &FLEXCOMM5_TX_Handle, &FLEXCOMM5_RX_Handle);

xTaskCreate(usb_host_task, "usbhost", 4096, NULL, 4, NULL);
   PRINTF("usb host task created...\r\n");

// xTaskCreate(test_task, "test", 2048, NULL, 2, NULL);
//PRINTF("test task created...\r\n");
// xTaskCreate(motor_task, "motor", 1096, NULL, 2, NULL);
//PRINTF("motor task created...\r\n");

PRINTF("Free heap: %u bytes (min ever: %u)\n",
               xPortGetFreeHeapSize(),
               xPortGetMinimumEverFreeHeapSize());


vTaskStartScheduler();

while (1) {}

}

#ifndef TUSB_CONFIG_H_
#define TUSB_CONFIG_H_

#ifdef __cplusplus
extern "C" {
#endif

//--------------------------------------------------------------------
// Common Configuration
//--------------------------------------------------------------------
#define CFG_TUSB_OS OPT_OS_FREERTOS
#define CFG_TUSB_DEBUG 2
// In tusb_config.h
#define CFG_TUSB_DEBUG_PRINTF my_printf

#define CFG_TUH_MEM_SECTION
#define CFG_TUH_MEM_ALIGN attribute ((aligned(4)))

//--------------------------------------------------------------------
// Host Configuration
//--------------------------------------------------------------------
#define CFG_TUH_ENABLED 1
#define BOARD_TUH_RHPORT 1 // USB1 = High Speed
#define BOARD_TUH_MAX_SPEED BOARD_TUH_HIGH_SPEED // Use High Speed

#define CFG_TUH_ENUMERATION_BUFSIZE 256

//--------------------------------------------------------------------
// Device Max + Hub
//--------------------------------------------------------------------
#define CFG_TUH_HUB 1
#define CFG_TUH_DEVICE_MAX (3 * CFG_TUH_HUB + 2)

//--------------------------------------------------------------------
// Class Drivers
//--------------------------------------------------------------------
#define CFG_TUH_HID 2
#define CFG_TUH_MIDI 2
#define CFG_TUH_CDC 0
#define CFG_TUH_MSC 0
#define CFG_TUH_VENDOR 0
#define TUH_ATTACH_DEBOUNCE_DELAY_MS 800
#define TUH_RESET_DELAY_MS 300
#define CFG_TUH_ENUMERATION_TIMEOUT_MS 5000
//--------------------------------------------------------------------
// Memory Pool Configuration
//--------------------------------------------------------------------
#define CFG_TUH_HID_KEYBOARD 2
#define CFG_TUH_HID_MOUSE 2
#define CFG_TUH_HID_GENERIC 2
#define CFG_TLB_TASK_QUEUE_SZ 16

// Endpoint & Interface pools
#define CFG_TUH_ENDPOINT_MAX (12)
#define CFG_TUH_INTERFACE_MAX (8)

// Memory size for control transfers + class drivers
#define CFG_TUSB_HOST_ENDPOINT_SIZE 64
#define CFG_TUSB_HOST_INTERFACE_SIZE 256

// Total memory for TinyUSB host
#define CFG_TUH_MEM_SIZE (8*4096)

#ifdef _cplusplus
}
#endif
#endif /* TUSB_CONFIG_H */

[ghost]

I tested again with a Full speed keypad, again Tiny recognises the speed, and sends the descriptor bytes, but nothing comes back. I'm using macos, McuXpresso IDE (last version, 25 x)

Also with some other low speed devices, keyboard, mouse, same: none enumeration.

I used an externally powered 5v supply to rule out low power on enumeration. And considering it does the same with low and full speed devices, it seems not to be a timing issue solely with Low speed devices.

I tested a High speed device, and again recognised the speed, but not enumerated. However that was an MSC device which was not properly coded in. But it reached the same loop point as all the other devices - low full high speed all react the same - nischoire.

[ghost]

Nobody has any tips on where to look, at all?

[HiFiPhile]

“Nobody has any tips on where to look, at all?” comes across as entitled, especially given that this is a volunteer-maintained project and your post was made only 3 days ago, including over a weekend.

In its current form, it is an unformatted dump of logs, code, and assumptions. That makes it difficult for others to understand what you actually tried, what is known to work, and where the failure begins. Just read it yourself !

If you want useful help, please do the following first:

1. Format the post properly
   Put logs and code in code blocks, and remove everything that is not directly relevant to the failure.

2. Start from a known working example instead of a large custom application
   If you are new to embedded development, bringing up a custom HS host stack, FreeRTOS app, HID, MIDI, board init, and peripheral code all at once is not a good debugging strategy. First take a supported board of the same MCU family (LPCXpresso54608), get that building and enumerating, and only then port your changes incrementally.

3. Reduce this to a minimal reproducer
   Show the smallest possible example that demonstrates the problem:

• exact MCU/board
• exact TinyUSB version/commit
• exact port/PHY used
• relevant tusb_config.h
• relevant clock / IRQ setup
• exact log up to the point where enumeration stops

[ghost]

hi,
I have read it myself. I tried to be as clear as possible.
I'm not entitled to help, just asking for it.
I'll keep trying.
thanks for responding.