Detect USB CDC device again

Author: hikalium

src/console.cc

@@ -101,9 +101,7 @@ void PutChar(char c) {
 }
 
 void PutString(const char* s) {
-  while (*s) {
-    PutChar(*(s++));
-  }
+  CoreFunc::PutString(s);
 }
 
 void PutDecimal64(uint64_t value) {

src/corefunc.h

@@ -5,5 +5,6 @@
 class EFI;
 namespace CoreFunc {
 void PutChar(char c);
+void PutString(const char* s);
 EFI& GetEFI();
 };  // namespace CoreFunc

src/kernel.cc

@@ -42,7 +42,7 @@ void kprintf(const char* fmt, ...) {
     PutStringAndHex("kprintf: warning: vsnprintf returned", len);
     buf[kSizeOfBuffer - 1] = 0;
   }
-  PutString(buf);
+  liumos->main_console->PutString(buf);
   va_end(args);
 }
 
@@ -212,6 +212,9 @@ void TimerHandler(uint64_t, InterruptInfo* info) {
 void CoreFunc::PutChar(char c) {
   liumos->main_console->PutChar(c);
 }
+void CoreFunc::PutString(const char* s) {
+  liumos->main_console->PutString(s);
+}
 
 EFI& CoreFunc::GetEFI() {
   assert(loader_info_);

src/libcxx_support.cc

@@ -5,9 +5,7 @@ void* operator new(unsigned long size) {
   return AllocKernelMemory<void*>(size);
 }
 
-void operator delete(void*) {
-  kprintf("warning: delete called but not implemented yet\n");
-}
+void operator delete(void*) {}
 
 void* operator new(unsigned long, std::align_val_t) {
   Panic("void * operator new(unsigned long, std::align_val_t)");

src/loader.cc

@@ -123,6 +123,9 @@ void IdentifyCPU() {
 void CoreFunc::PutChar(char c) {
   main_console_.PutChar(c);
 }
+void CoreFunc::PutString(const char* s) {
+  main_console_.PutString(s);
+}
 
 EFI& CoreFunc::GetEFI() {
   return efi_;

src/usb_manager.cc

@@ -37,6 +37,7 @@ class USBCommunicationClassDriver : public USBClassDriver {
     switch (state_) {
       case kDriverAttached: {
         config_desc_idx_ = 0;
+        kprintf("Requesting config descriptor...\n");
         xhc.RequestConfigDescriptor(slot_, config_desc_idx_);
         state_ = kCheckingConfigDescriptor;
       } break;
@@ -45,6 +46,7 @@ class USBCommunicationClassDriver : public USBClassDriver {
         if (!e.has_value()) {
           return;
         }
+        kprintf("Got config descriptor\n");
         ConfigDescriptor* config_desc =
             xhc.ReadDescriptorBuffer<ConfigDescriptor>(slot_, 0);
         assert(config_desc);
@@ -127,6 +129,7 @@ class USBCommunicationClassDriver : public USBClassDriver {
         }
         kprintf("\n");
         xhc.SetConfig(slot_, config_value_);
+        kprintf("Using config value = %d\n", config_value_);
         state_ = kWaitingForConfigCompletion;
       } break;
       case kWaitingForConfigCompletion: {
@@ -166,6 +169,8 @@ class USBCommunicationClassDriver : public USBClassDriver {
 
         xhc.SetInterface(slot_, data_interface_alt_setting_,
                          data_interface_number_);
+        kprintf("Using interface num = %d, alt setting = %d\n",
+                data_interface_number_, data_interface_alt_setting_);
         state_ = kWaitingForSetInterfaceCompletion;
       } break;
       case kWaitingForSetInterfaceCompletion: {
@@ -339,14 +344,18 @@ class USBCommonDriver : public USBClassDriver {
       } break;
       case kDone: {
         kprintf("Got %d config descriptors in total\n", config_desc_idx_);
+        bool found_cdc_net = false;
         for (int i = 0; i < config_desc_idx_; i++) {
           auto& config = slot_state[slot_].config_descriptors[i];
           kprintf("config[%d]:\n", i);
+          kprintf("  config value = %d:\n", config->config_value);
           for (const auto& e : *config) {
             if (e->type == kDescriptorTypeInterface) {
               InterfaceDescriptor& interface_desc =
                   *reinterpret_cast<InterfaceDescriptor*>(e);
               kprintf("  interface:\n");
+              kprintf("    num:      %d\n", interface_desc.interface_number);
+              kprintf("    alt:      %d\n", interface_desc.alt_setting);
               kprintf("    class:    0x%02X\n", interface_desc.interface_class);
               kprintf("    subclass: 0x%02X\n",
                       interface_desc.interface_subclass);
@@ -356,14 +365,24 @@ class USBCommonDriver : public USBClassDriver {
                   interface_desc.interface_subclass == 0x06 &&
                   interface_desc.interface_protocol == 0x00) {
                 kprintf("USB CDC Network device found!\n");
-                auto cdc_net_driver = new USBCommunicationClassDriver(slot_);
-                delete slot_state[slot_].driver;
-                slot_state[slot_].driver = cdc_net_driver;
-                return;
+                found_cdc_net = true;
               }
             }
+            if (e->type == kDescriptorTypeEndpoint) {
+              EndpointDescriptor& ep_desc =
+                  *reinterpret_cast<EndpointDescriptor*>(e);
+              kprintf("    endpoint:\n");
+              kprintf("      addr:    0x%02X\n", ep_desc.endpoint_address);
+              kprintf("      attributes: 0x%02X\n", ep_desc.attributes);
+            }
           }
         }
+        if (found_cdc_net) {
+          auto cdc_net_driver = new USBCommunicationClassDriver(slot_);
+          delete slot_state[slot_].driver;
+          slot_state[slot_].driver = cdc_net_driver;
+          return;
+        }
         state_ = kFailed;
       } break;
       case kFailed: {

src/xhci.cc

@@ -818,6 +818,7 @@ void Controller::HandleTransferEvent(BasicTRB& e) {
           "(%02X, %02X, %02X)\n",
           si.device_class, si.device_subclass, si.device_protocol);
       si.state = SlotState::kAvailable;
+      port_is_initializing_[slot_info_[slot].port] = false;
     } break;
     case SlotState::kManaged: {
       si.event_queue.Push(SlotEvent::kTransferSucceeded);
@@ -952,7 +953,6 @@ void Controller::HandleAddressDeviceCommandCompletion(const BasicTRB& e) {
   }
   uint8_t* buf = AllocMemoryForMappedIO<uint8_t*>(kSizeOfDescriptorBuffer);
   descriptor_buffers_[slot] = buf;
-  port_is_initializing_[slot_info_[slot].port] = false;
   RequestDeviceDescriptor(slot, SlotState::kWaitingForDeviceDescriptor);
 }