USB Device API (usb)

s32 usbInit(void);

s32 usbEnd(void);

s32 usbRegisterLdd(usbLddOps *lddops);

s32 usbUnregisterLdd(usbLddOps *lddops);

s32 usbRegisterExtraLdd(usbLddOps *lddops, u16 vendor_id, u16 product_id);

s32 usbRegisterExtraLdd2(usbLddOps *lddops, u16 vendor_id, 
                         u16 product_id_min, u16 product_id_max);

s32 usbUnregisterExtraLdd(usbLddOps *lddops);

s32 usbOpenPipe(s32 device_id, usbEndpointDescriptor *end_desc);

s32 usbClosePipe(s32 pipe_id);

s32 usbBulkTransfer(s32 pipe_id, void *buf, s32 len, 
                    usbDoneCallback cb, void* arg);

s32 usbControlTransfer(s32 pipe_id, usbDeviceRequest *req, void *buf, 
                       usbDoneCallback cb, void *arg);

s32 usbInterruptTransfer(s32 pipe_id, void *buf, s32 len, 
                         usbDoneCallback cb, void *arg);

s32 usbIsochronousTransfer(s32 pipe_id, usbIsochRequest *req, 
                           usbIsochDoneCallback cb, void *arg);

s32 usbHSIsochronousTransfer(s32 pipe_id, usbHSIsochRequest *req, 
                             usbHSIsochDoneCallback cb, void *arg);

s32 usbGetDeviceLocation(s32 device_id, unsigned char *location);

s32 usbGetDeviceSpeed(s32 device_id, u8 *speed);

void *usbScanStaticDescriptor(s32 device_id, void *ptr, unsigned char type);

s32 usbAllocateMemory(void **ptr, size_t size);

s32 usbFreeMemory(void *ptr);

void *usbGetPrivateData(s32 device_id);

s32 usbSetPrivateData(s32 device_id, void *priv);

#include <sysmodule/sysmodule.h>
#include <usb/usb.h>
#include <stdio.h>

// Transfer completion callback
static void transfer_done(s32 result, s32 count, void* arg) {
    printf("Transfer completed: result=0x%x, count=%d\n", result, count);
}

// USB device probe
static s32 my_usb_probe(s32 dev_id) {
    usbDeviceDescriptor *dev_desc;
    
    // Get device descriptor
    dev_desc = (usbDeviceDescriptor*)usbScanStaticDescriptor(
        dev_id, NULL, USB_DESCRIPTOR_TYPE_DEVICE);
    
    if (dev_desc) {
        printf("USB Device: VID=0x%04x PID=0x%04x\n",
               dev_desc->idVendor, dev_desc->idProduct);
        
        // Check if this is our device
        if (dev_desc->idVendor == 0x1234 && 
            dev_desc->idProduct == 0x5678) {
            return USB_PROBE_SUCCEEDED;
        }
    }
    
    return USB_PROBE_FAILED;
}

// USB device attach
static s32 my_usb_attach(s32 dev_id) {
    usbConfigDescriptor *config_desc;
    usbInterfaceDescriptor *if_desc;
    usbEndpointDescriptor *ep_desc;
    s32 pipe_id;
    void *buffer;
    s32 ret;
    
    printf("Device attached: %d\n", dev_id);
    
    // Get configuration descriptor
    config_desc = (usbConfigDescriptor*)usbScanStaticDescriptor(
        dev_id, NULL, USB_DESCRIPTOR_TYPE_CONFIG);
    
    // Get first interface
    if_desc = (usbInterfaceDescriptor*)usbScanStaticDescriptor(
        dev_id, (void*)config_desc, USB_DESCRIPTOR_TYPE_INTERFACE);
    
    // Find bulk IN endpoint
    ep_desc = (usbEndpointDescriptor*)usbScanStaticDescriptor(
        dev_id, (void*)if_desc, USB_DESCRIPTOR_TYPE_ENDPOINT);
    
    while (ep_desc) {
        if ((ep_desc->bmAttributes & USB_ENDPOINT_TRANSFER_TYPE_BITS) == 
            USB_ENDPOINT_TRANSFER_TYPE_BULK &&
            (ep_desc->bEndpointAddress & USB_ENDPOINT_DIRECTION_BITS) == 
            USB_ENDPOINT_DIRECTION_IN) {
            // Found bulk IN endpoint
            break;
        }
        ep_desc = (usbEndpointDescriptor*)usbScanStaticDescriptor(
            dev_id, (void*)ep_desc, USB_DESCRIPTOR_TYPE_ENDPOINT);
    }
    
    if (!ep_desc) {
        printf("No bulk IN endpoint found\n");
        return USB_ATTACH_FAILED;
    }
    
    // Open pipe to endpoint
    pipe_id = usbOpenPipe(dev_id, ep_desc);
    if (pipe_id < 0) {
        printf("Failed to open pipe: 0x%x\n", pipe_id);
        return USB_ATTACH_FAILED;
    }
    
    printf("Opened pipe: %d\n", pipe_id);
    
    // Allocate transfer buffer
    ret = usbAllocateMemory(&buffer, 512);
    if (ret != USB_OK) {
        printf("Failed to allocate memory\n");
        usbClosePipe(pipe_id);
        return USB_ATTACH_FAILED;
    }
    
    // Perform bulk transfer
    ret = usbBulkTransfer(pipe_id, buffer, 512, transfer_done, NULL);
    if (ret != USB_OK) {
        printf("Bulk transfer failed: 0x%x\n", ret);
        usbFreeMemory(buffer);
        usbClosePipe(pipe_id);
        return USB_ATTACH_FAILED;
    }
    
    // Store pipe_id in private data for cleanup
    usbSetPrivateData(dev_id, (void*)(intptr_t)pipe_id);
    
    return USB_ATTACH_SUCCEEDED;
}

// USB device detach
static s32 my_usb_detach(s32 dev_id) {
    s32 pipe_id;
    
    printf("Device detached: %d\n", dev_id);
    
    // Get pipe_id from private data
    pipe_id = (s32)(intptr_t)usbGetPrivateData(dev_id);
    if (pipe_id > 0) {
        usbClosePipe(pipe_id);
    }
    
    return USB_DETACH_SUCCEEDED;
}

// LDD operations
static usbLddOps my_ldd_ops = {
    .name = "my_usb_driver",
    .probe = my_usb_probe,
    .attach = my_usb_attach,
    .detach = my_usb_detach
};

int main() {
    s32 ret;
    
    // Load USB module
    ret = sysModuleLoad(SYSMODULE_USB);
    if (ret != 0) {
        printf("Failed to load USB module\n");
        return -1;
    }
    
    // Register our USB driver
    ret = usbRegisterExtraLdd(&my_ldd_ops, 0x1234, 0x5678);
    if (ret != USB_OK) {
        printf("Failed to register LDD: 0x%x\n", ret);
        return -1;
    }
    
    printf("USB driver registered. Waiting for devices...\n");
    
    // Wait for device events (in real app, use proper event loop)
    // ...
    
    // Cleanup
    usbUnregisterExtraLdd(&my_ldd_ops);
    sysModuleUnload(SYSMODULE_USB);
    
    return 0;
}