OSDev.org

Code: Select all

USB_HANDSHAKE_PACKET* Handshake = (USB_HANDSHAKE_PACKET*)((UINT64)Transfer->Qtd->BufferPointer0 | ((UINT64)Transfer->Qtd->ExtendedBufferPointer0 << 32));
// Trying to see if the handshake is somewhere on the buffer
    SystemDebugPrint(L"SETUP_TOKEN SENT. PID : %x, FIRST : %x SECOND : %x", Handshake->Pid, *(UINT64*)((UINT64)Transfer->Qtd->BufferPointer0 - 8), *(UINT64*)((UINT64)Transfer->Qtd->BufferPointer0));

Code: Select all

int EhciControlDeviceRequest(RFEHCI_ASYNC_TRANSFER Transfer, USB_DEVICE_REQUEST* DeviceRequest, UINT NumBytes /*For Buffer*/, void* Buffer){
    Transfer->Qtd->PidCode = EHCI_SETUP;
    ZeroMemory(Transfer->Buffer, 0x1000);
    Transfer->Qtd->BufferPointer0 &= ~(0xfff);
    USB_TOKEN_PACKET* Setup = Transfer->Buffer;
    Setup->Pid = USB_PID_SETUP;
    Setup->DeviceAddress = 0;
    // Setup->SyncField = 1;

    Transfer->Qtd->TotalBytesToTransfer = 8;
    Transfer->Qtd->Active = 1;
    while(Transfer->Qtd->Active);


    memcpy((void*)((char*)Transfer->Buffer + 8), DeviceRequest, 8);
    Transfer->Qtd->TotalBytesToTransfer = 8;
    // Transfer->Qtd->DataToggle = 1;
    Transfer->Qtd->Active = 1;
    while(Transfer->Qtd->Active);
    USB_HANDSHAKE_PACKET* Handshake = (USB_HANDSHAKE_PACKET*)((UINT64)Transfer->Qtd->BufferPointer0 | ((UINT64)Transfer->Qtd->ExtendedBufferPointer0 << 32));
    SystemDebugPrint(L"SETUP_TOKEN SENT. PID : %x, FIRST : %x SECOND : %x", Handshake->Pid, *(UINT64*)((UINT64)Transfer->Qtd->BufferPointer0 - 8), *(UINT64*)((UINT64)Transfer->Qtd->BufferPointer0));
    while(1);
    return 0;
}

Code: Select all

#pragma pack(push, 1)

typedef struct _USB_TOKEN_PACKET{
    UINT64 SyncField : 32;
    UINT64 Pid : 8; // Packet Id

    UINT64 DeviceAddress : 7;
    UINT64 Endpoint : 4;
    UINT64 CRC5 : 5; // Cyclic Redundancy Check
} USB_TOKEN_PACKET;

typedef struct _USB_DATA_PACKET{
    UINT32 SyncField;
    UINT8 Pid;
    char Data[8]; // [8] Just temporarely
    UINT16 CRC16;
    UINT16 EOP;
} USB_DATA_PACKET;

typedef struct _USB_HANDSHAKE_PACKET{
    UINT64 SyncField : 32;
    UINT64 Pid : 8;
} USB_HANDSHAKE_PACKET;

typedef struct _USB_SOF_PACKET{
    UINT64 SyncField : 32;
    UINT64 Pid : 8;
    UINT64 FrameNumber : 11;
    UINT64 CRC5 : 5;
} USB_SOF_PACKET;


typedef struct _USB_DEVICE_REQUEST{
    unsigned char RequestType;
    unsigned char Request;
    unsigned short Value;
    unsigned short Index;
    unsigned short Length;
} USB_DEVICE_REQUEST;

typedef enum _USB_DESCRIPTOR_TYPE{
    USB_DESCRIPTOR_TYPE_DEVICE = 1,
    USB_DESCRIPTOR_TYPE_CONFIGURATION = 2,
    USB_DESCRIPTOR_TYPE_STRING = 3,
    USB_DESCRIPTOR_TYPE_INTERFACE = 4,
    USB_DESCRIPTOR_TYPE_ENDPOINT = 5,
    USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER = 6,
    USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION = 7,
    USB_DESCRIPTOR_TYPE_INTERFACE_POWER = 8
} USB_DESCRIPTOR_TYPE;

typedef struct _USB_DEVICE_DESCRIPTOR{
    UINT8 Length;
    UINT8 DescriptorType;
    UINT16 UsbSpecificationReleaseNumber;
    UINT8 DeviceClass;
    UINT8 DeviceSubclass;
    UINT8 DeviceProtocol;
    UINT8 Endpoint0MaxPacketSize;
    UINT16 VendorId;
    UINT16 ProductId;
    UINT16 DeviceRelease;
    UCHAR Manufacturer; // index of string descriptor
    UCHAR Product;
    UCHAR SerialNumber;
    UINT8 NumConfigurations;
} USB_DEVICE_DESCRIPTOR;

#pragma pack(pop)

Code: Select all

#define CURRENT_QTD_PTR(qtd) (void*)((UINT64)qtd->BufferPointer0 | ((UINT64)qtd->ExtendedBufferPointer0 << 32))

void EhciControlWrite(RFEHCI_ASYNC_TRANSFER Transfer, void* Buffer, UINT NumBytes){
    memcpy(CURRENT_QTD_PTR(Transfer->Qtd), Buffer, 8);
    Transfer->Qtd->TotalBytesToTransfer = NumBytes;
    Transfer->Qtd->Active = 1;
    while(Transfer->Qtd->Active);
}

void EhciControlRead(RFEHCI_ASYNC_TRANSFER Transfer, void* Buffer, UINT* _NumBytes){
    UINT NumBytes = *_NumBytes;
    void* Src = CURRENT_QTD_PTR(Transfer->Qtd);
    UINT64* _D = CURRENT_QTD_PTR(Transfer->Qtd);
    Transfer->Qtd->DataToggle = 1;
    Transfer->Qtd->TotalBytesToTransfer = NumBytes;
    Transfer->Qtd->Active = 1;
    while(Transfer->Qtd->Active);
    *_NumBytes = Transfer->Qtd->TotalBytesToTransfer;
    memcpy(Buffer, Src, NumBytes);
    Transfer->Qtd->DataToggle = 0;
}

int EhciControlDeviceRequest(RFEHCI_ASYNC_TRANSFER Transfer, void* DeviceRequest, UINT NumBytes, void* Buffer){
    
    // Refresh some data

    Transfer->Qtd->PidCode = EHCI_SETUP;
    Transfer->Qtd->BufferPointer0 = (UINT32)(UINT64)Transfer->Buffer;
    Transfer->Qtd->ExtendedBufferPointer0 = (UINT32)((UINT64)Transfer->Buffer >> 32);
    Transfer->Qtd->DataToggle = 0;


    USB_TOKEN_PACKET Token = {0};
    Token.SyncField = 1;
    
    // Send DEVICE_REQUEST

    EhciControlWrite(Transfer, DeviceRequest, 8);

    // Set PID_CODE to IN & Receive data from the device

    Transfer->Qtd->PidCode = EHCI_IN;
    EhciControlRead(Transfer, Buffer, &NumBytes);

    // Set PID_CODE to OUT & Send ACK

    Transfer->Qtd->PidCode = EHCI_OUT;

    Token.Pid = USB_PID_ACK;
    EhciControlWrite(Transfer, &Token, 8);
  
    return 0;
}