OSDev.org

Code: Select all

BOOL EhciResetController(EHCI_DEVICE* Ehci){ 
     Ehci->OperationnalRegisters->UsbCommand.RunStop = 0; // Stop the USB Controller 
     while(!Ehci->OperationnalRegisters->UsbStatus.HcHalted); 
     EhciAckAllInterrupts(Ehci); 
     Ehci->OperationnalRegisters->UsbCommand.HostControllerReset = 1; 
     while(Ehci->OperationnalRegisters->UsbCommand.HostControllerReset); 
     // All registers will be set to their initial value 
     return TRUE; 
 }

Code: Select all

            if(!EhciResetPort(Ehci, i)){ 
                 SystemDebugPrint(L"Failed to reset port %d", i); 
             } 
             if(!Ehci->OperationnalRegisters->PortStatusControl[i].PortEnabled) { 
                 SystemDebugPrint(L"Resetted port is not enabled."); 
                 continue; 
             } 
  
  
             if(Ehci->OperationnalRegisters->PortStatusControl[i].CurrentConnectStatus == 1){ 
                 SystemDebugPrint(L"EHCI Device Connected to port %d. Line Status : %d", i, Ehci->OperationnalRegisters->PortStatusControl[i].LineStatus); 
                 EhciHandleDeviceConnection(Ehci, i); 
             }else{ 
 // TODO : Handle device disconnection                SystemDebugPrint(L"EHCI Device Disconnected from port %d", i); 
             } 
  
             Ehci->OperationnalRegisters->PortStatusControl[i].ConnectStatusChange = 1; 
         }

Code: Select all

KERNELSTATUS EhciHandleDeviceConnection(EHCI_DEVICE* Ehci, DWORD PortNumber){ 
      
     RFEHCI_ASYNC_QUEUE ControlQueue = EhciCreateAsynchronousQueue(Ehci, 0, 0, 0, USB_HIGH_SPEED); 
     RFEHCI_ASYNC_TRANSFER ControlTransfer = EhciCreateControlTransfer(ControlQueue, USB_SETUP); 
     if(!ControlTransfer || !ControlQueue) { 
         SystemDebugPrint(L"Failed to create async control queue or async control transfer"); 
         return KERNEL_SERR; 
     } 
     USB_DEVICE_DESCRIPTOR DeviceDescriptor = {0}; 
     USB_DEVICE_REQUEST DeviceRequest = {0}; 
     DeviceRequest.Request = USB_DEVICE_GET_DESCRIPTOR; 
     DeviceRequest.RequestType = 0x80; 
     DeviceRequest.Value = 1 << 8; 
     DeviceRequest.Length = 0x12; 
      
     // SystemDebugPrint(L"USB_GET_DESCRIPTOR"); 
  
     int Status = EhciControlDeviceRequest(ControlTransfer, &DeviceRequest, 0x12, &DeviceDescriptor); 
      
     if(Status != 0) return Status; 
      
      
     // Set Device Address 
     DeviceRequest.Request = USB_DEVICE_SET_ADDRESS; 
     DeviceRequest.RequestType = 0; 
     DeviceRequest.Value = EhciAllocateDeviceAddress(Ehci); 
     UINT DeviceAddress = DeviceRequest.Value; 
     DeviceRequest.Length = 0; 
  
     // SystemDebugPrint(L"DEVICE_ADDRESS : %x", DeviceRequest.Value); 
     Status = EhciControlDeviceRequest(ControlTransfer, &DeviceRequest, 0, NULL); 
     if(Status != 0) return Status; 
     
     // Set Device Address 
     ControlQueue->QueueHead->DeviceAddress = DeviceAddress; 
  
 //    // Set Device configuration 
 //     DeviceRequest.Request = USB_DEVICE_SET_CONFIGURATION; 
 //     DeviceRequest.Value = 1; 
 //     Status = EhciControlDeviceRequest(ControlTransfer, &DeviceRequest, 0, NULL); 
  
     // SystemDebugPrint(L"LENGTH : %x, DESCRIPTOR_TYPE : %x, EP0_MAX_PACKET_SIZE : %x", (UINT64)DeviceDescriptor.Length, (UINT64)DeviceDescriptor.DescriptorType, (UINT64)DeviceDescriptor.Endpoint0MaxPacketSize); 
     SystemDebugPrint(L"PRODUCT_ID : %x, NUM_CONFIGS : %x", DeviceDescriptor.ProductId, DeviceDescriptor.NumConfigurations); 
     SystemDebugPrint(L"CLASS : %x, SUB_CLASS : %x, VENDOR_ID : %x, DEVICE_PROTOCOL : %x", (UINT64)DeviceDescriptor.DeviceClass, (UINT64)DeviceDescriptor.DeviceSubclass, (UINT64)DeviceDescriptor.VendorId, (UINT64)DeviceDescriptor.DeviceProtocol);     
     USB_STRING_DESCRIPTOR String = {0}; 
     if(DeviceDescriptor.SerialNumber){ 
         EhciControlGetString(ControlTransfer, &String, DeviceDescriptor.SerialNumber); 
         SystemDebugPrint(L"SERIAL_NUMBER : %ls", String.String); 
     } 
     if(DeviceDescriptor.Manufacturer){ 
         EhciControlGetString(ControlTransfer, &String, DeviceDescriptor.Manufacturer); 
         SystemDebugPrint(L"MANUFACTURER : %ls", String.String); 
     } 
  
     if(DeviceDescriptor.Product){ 
         EhciControlGetString(ControlTransfer, &String, DeviceDescriptor.Product); 
         SystemDebugPrint(L"PRODUCT_NAME : %ls", String.String); 
     } 
     
      ...... // Loading the driver and queues

Code: Select all

int EhciControlDeviceRequest(RFEHCI_ASYNC_TRANSFER Transfer, void* DeviceRequest, UINT NumBytes, void* Buffer){ 
      
  
  
     // Refresh some data 
  
     Transfer->Qtd->BufferPointer0 = (UINT32)(UINT64)Transfer->Buffer; 
     Transfer->Qtd->ExtendedBufferPointer0 = (UINT32)((UINT64)Transfer->Buffer >> 32); 
     Transfer->Qtd->DataToggle = 0; 
     Transfer->Qtd->CurrentPage = 0; 
  
     Transfer->AsyncQueue->QueueHead->PortNumber = 0; 
  
  
     Transfer->Qtd->PidCode = EHCI_SETUP; 
     // Send DEVICE_REQUEST 
  
     if(EhciControlWrite(Transfer, DeviceRequest, 8) != 1) return -1; 
  
     // Set PID_CODE to IN & Receive data from the device 
  
     Transfer->Qtd->PidCode = EHCI_IN; 
     if(EhciControlRead(Transfer, Buffer, NumBytes) != 1) return -1; 
  
  
     return 0; 
 }

Code: Select all

int EhciControlWrite(RFEHCI_ASYNC_TRANSFER Transfer, void* Buffer, UINT NumBytes){ 
     memcpy(CURRENT_QTD_PTR(Transfer->Qtd), Buffer, NumBytes); 
     Transfer->Qtd->TotalBytesToTransfer = NumBytes; 
     Transfer->Qtd->Active = 1; 
     for(UINT64 i = 0;Transfer->Qtd->Active;i++){ 
         if(Transfer->Qtd->TransactionError){ 
             SystemDebugPrint(L"TRANSACTION_ERROR"); 
             return 0; 
         } 
         if(Transfer->Qtd->DataBufferError){ 
             SystemDebugPrint(L"DATA_BUFFER_ERROR"); 
             return 0; 
         } 
         if(Transfer->Qtd->BabbleDetected){ 
             SystemDebugPrint(L"BABBLE_DETECTED"); 
             return 0; 
         } 
         if(Transfer->Qtd->Halted){ 
             SystemDebugPrint(L"QTD_HALTED."); 
         } 
         if(i > 1000) { 
             SystemDebugPrint(L"EHCI CONTROL WRITE : Device Response time exceeded. (ACTIVE = %x)", Transfer->Qtd->Active); 
             for(UINT c = 0;c<10;c++){ 
                 SystemDebugPrint(L"ASYNCQ : %x, QH_CQTD : %x, QH_NQTD : %x, QTD : %x, ASYNCADDR : %x", Transfer->AsyncQueue->QueueHead, Transfer->AsyncQueue->QueueHead->CurrentQtdPointer, Transfer->AsyncQueue->QueueHead->HcOverlayArea.NextQtdPointer, Transfer->Qtd, Transfer->AsyncQueue->Ehci->OperationnalRegisters->AsyncListAddress); 
                 Sleep(100); 
             } 
             return 0; 
         } 
         Sleep(1); 
     } 
     return 1; 
 } 
  
 int EhciControlRead(RFEHCI_ASYNC_TRANSFER Transfer, void* Buffer, UINT8 NumBytes){ 
     // Transfer->Qtd->BufferPointer0 = (UINT32)(UINT64)Transfer->Buffer; 
     // Transfer->Qtd->ExtendedBufferPointer0 = (UINT32)((UINT64)Transfer->Buffer >> 32); 
     void* Src = CURRENT_QTD_PTR(Transfer->Qtd); 
     Transfer->Qtd->TotalBytesToTransfer = NumBytes; 
     Transfer->Qtd->DataToggle = 1; 
     Transfer->Qtd->Active = 1; 
     for(UINT64 i = 0;Transfer->Qtd->Active;i++){ 
         if(Transfer->Qtd->TransactionError){ 
             SystemDebugPrint(L"TRANSACTION_ERROR"); 
             return 0; 
         } 
         if(Transfer->Qtd->DataBufferError){ 
             SystemDebugPrint(L"DATA_BUFFER_ERROR"); 
             return 0; 
         } 
         if(Transfer->Qtd->BabbleDetected){ 
             SystemDebugPrint(L"BABBLE_DETECTED"); 
             return 0; 
         } 
         if(Transfer->Qtd->Halted){ 
             SystemDebugPrint(L"QTD_HALTED."); 
         } 
  
         if(i > 1000) { 
             SystemDebugPrint(L"EHCI CONTROL WRITE : Device Response time exceeded. (ACTIVE = %x)", Transfer->Qtd->Active); 
             return 0; 
         } 
         Sleep(1); 
     } 
     memcpy(Buffer, Src, NumBytes);  
      
     Transfer->Qtd->DataToggle = 0; 
  
     return 1; 
 }

Code: Select all

int EhciControlGetString(RFEHCI_ASYNC_TRANSFER ControlTransfer, void* StringDescriptor, UINT StringIndex){ 
     USB_DEVICE_REQUEST Request = {0}; 
     Request.Request = USB_DEVICE_GET_DESCRIPTOR; 
     Request.RequestType = 0x80; 
     Request.Value = 3 << 8 | StringIndex; 
     Request.Length = 8; // STEP 1 : GetStringLength 
     int Status = EhciControlDeviceRequest(ControlTransfer, &Request, 8, StringDescriptor); 
     if(Status != 0) return Status; 
     USB_STRING_DESCRIPTOR* StringDesc = StringDescriptor; 
     Request.Length = StringDesc->Length; // STEP 2 : GetString By StringDescriptorLength 
     ZeroMemory(StringDesc, Request.Length + 2); 
     Status = EhciControlDeviceRequest(ControlTransfer, &Request, Request.Length, StringDesc); 
     return Status; 
 }