| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. |
| |
| #include "usb_bus.h" |
| |
| #include <algorithm> |
| |
| #include <ddk/debug.h> |
| #include <ddk/protocol/usb.h> |
| #include <fbl/algorithm.h> |
| #include <lib/zx/time.h> |
| #include <usb/usb.h> |
| #include <zircon/compiler.h> |
| #include <zircon/errors.h> |
| #include <zircon/hw/usb.h> |
| #include <zircon/status.h> |
| |
| #include "rtl88xx_registers.h" |
| |
| namespace wlan { |
| namespace rtl88xx { |
| namespace { |
| |
| // Set to true to log all bus transactions. |
| constexpr bool kLogBusTransactions = false; |
| |
| // Register read/write deadline, after which a read or write will fail. |
| constexpr zx::duration kRegisterIoDeadline = zx::msec(1); |
| |
| // Returns true iff the given USB interface describes a supported rtl88xx chip's WLAN functionality. |
| constexpr bool IsRealtekWlanDevice(const usb_interface_descriptor_t& desc) { |
| if (desc.bInterfaceClass == 0xFF && desc.bInterfaceSubClass == 0xFF && |
| desc.bInterfaceProtocol == 0xFF) { |
| // Prototype board; assume that this is a WLAN interface. |
| return true; |
| } |
| return false; |
| } |
| |
| // This class implements the Bus interface over the USB bus. |
| class UsbBus : public Bus { |
| public: |
| ~UsbBus() override; |
| |
| // Bus implementation. |
| Bus::BusType GetBusType() const override; |
| zx_status_t ReadRegister(uint16_t offset, uint8_t* value, const char* name) override; |
| zx_status_t ReadRegister(uint16_t offset, uint16_t* value, const char* name) override; |
| zx_status_t ReadRegister(uint16_t offset, uint32_t* value, const char* name) override; |
| zx_status_t WriteRegister(uint16_t offset, uint8_t value, const char* name) override; |
| zx_status_t WriteRegister(uint16_t offset, uint16_t value, const char* name) override; |
| zx_status_t WriteRegister(uint16_t offset, uint32_t value, const char* name) override; |
| |
| // Factory function for UsbBus instances. Returns an instance iff USB initialization is |
| // successful. |
| static zx_status_t Create(usb_protocol_t* usb_protocol, |
| const usb_interface_descriptor_t& usb_iface_desc, |
| std::unique_ptr<Bus>* bus); |
| |
| private: |
| UsbBus(); |
| UsbBus(const UsbBus& other) = delete; |
| UsbBus(UsbBus&& other) = delete; |
| UsbBus& operator=(UsbBus other) = delete; |
| |
| // Implement the register read/write on the USB bus. |
| zx_status_t ControlReadRegister(uint16_t offset, char* value, size_t size); |
| zx_status_t ControlWriteRegister(uint16_t offset, char* value, size_t size); |
| |
| usb_protocol_t usb_protocol_; |
| }; |
| |
| UsbBus::UsbBus() : usb_protocol_{} {} |
| |
| UsbBus::~UsbBus() {} |
| |
| zx_status_t UsbBus::Create(usb_protocol_t* usb_protocol, |
| const usb_interface_descriptor_t& usb_iface_desc, |
| std::unique_ptr<Bus>* bus) { |
| zx_status_t status = ZX_OK; |
| |
| #if 0 // TODO(sheu): re-enable when Zircon control endpoint stalls are fixed. |
| status = usb_set_interface(usb_protocol, usb_iface_desc.bInterfaceNumber, |
| usb_iface_desc.bAlternateSetting); |
| if (status != ZX_OK) { |
| // usb_set_interface() fails on some Realtek chipsets, with no impact on subsequent |
| // functionality. |
| zxlogf(TRACE, "rtl88xx: UsbBus::Create() failed to set interface %d alternate %d: %s\n", |
| usb_iface_desc.bInterfaceNumber, usb_iface_desc.bAlternateSetting, |
| zx_status_get_string(status)); |
| } |
| #endif // 0 |
| |
| std::unique_ptr<UsbBus> usb_bus(new UsbBus()); |
| usb_bus->usb_protocol_ = *usb_protocol; |
| |
| // Downcast UsbBus to Bus, so the template versions of {Read,Write}Register are resolved below. |
| Bus* const bus_interface = usb_bus.get(); |
| |
| reg::RXDMA_MODE rxdma_mode; |
| rxdma_mode.set_dma_mode(1); |
| rxdma_mode.set_burst_cnt(3); |
| |
| // Configure the USB bus for USB 1/2/3. |
| reg::SYS_CFG2 cfg2; |
| if ((status = bus_interface->ReadRegister(&cfg2)) != ZX_OK) { return status; } |
| if (cfg2.u3_term_detect()) { |
| // USB 3.0 mode. |
| rxdma_mode.set_burst_size(reg::BURST_SIZE_3_0); |
| } else { |
| reg::USB_USBSTAT usb_usbstat; |
| if ((status = bus_interface->ReadRegister(&usb_usbstat)) != ZX_OK) { return status; } |
| if (usb_usbstat.burst_size() == reg::BURST_SIZE_2_0_HS) { |
| // USB 2.0 mode. |
| rxdma_mode.set_burst_size(reg::BURST_SIZE_2_0_HS); |
| } else { |
| // USB 1.1 mode. |
| rxdma_mode.set_burst_size(reg::BURST_SIZE_2_0_FS); |
| } |
| } |
| if ((status = bus_interface->WriteRegister(rxdma_mode)) != ZX_OK) { return status; } |
| |
| reg::TXDMA_OFFSET_CHK txdma_offset_chk; |
| if ((status = bus_interface->ReadRegister(&txdma_offset_chk)) != ZX_OK) { return status; } |
| txdma_offset_chk.set_drop_data_en(1); |
| if ((status = bus_interface->WriteRegister(txdma_offset_chk)) != ZX_OK) { return status; } |
| |
| *bus = std::move(usb_bus); |
| return ZX_OK; |
| } |
| |
| Bus::BusType UsbBus::GetBusType() const { |
| return Bus::BusType::kUsb; |
| } |
| |
| zx_status_t UsbBus::ReadRegister(uint16_t offset, uint8_t* value, const char* name) { |
| const zx_status_t status = |
| ControlReadRegister(offset, reinterpret_cast<char*>(value), sizeof(*value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::ReadRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { zxlogf(INFO, "rtl88xx: UsbBus %-24s > 0x%02x\n", name, *value); } |
| return status; |
| } |
| |
| zx_status_t UsbBus::ReadRegister(uint16_t offset, uint16_t* value, const char* name) { |
| const zx_status_t status = |
| ControlReadRegister(offset, reinterpret_cast<char*>(value), sizeof(*value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::ReadRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { zxlogf(INFO, "rtl88xx: UsbBus %-24s > 0x%04x\n", name, *value); } |
| return status; |
| } |
| |
| zx_status_t UsbBus::ReadRegister(uint16_t offset, uint32_t* value, const char* name) { |
| const zx_status_t status = |
| ControlReadRegister(offset, reinterpret_cast<char*>(value), sizeof(*value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::ReadRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { zxlogf(INFO, "rtl88xx: UsbBus %-24s > 0x%08x\n", name, *value); } |
| return status; |
| } |
| |
| zx_status_t UsbBus::WriteRegister(uint16_t offset, uint8_t value, const char* name) { |
| const uint8_t original_value = value; |
| const zx_status_t status = |
| ControlWriteRegister(offset, reinterpret_cast<char*>(&value), sizeof(value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::WriteRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { |
| zxlogf(INFO, "rtl88xx: UsbBus %-24s < 0x%02x\n", name, original_value); |
| } |
| return status; |
| } |
| |
| zx_status_t UsbBus::WriteRegister(uint16_t offset, uint16_t value, const char* name) { |
| const uint8_t original_value = value; |
| const zx_status_t status = |
| ControlWriteRegister(offset, reinterpret_cast<char*>(&value), sizeof(value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::WriteRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { |
| zxlogf(INFO, "rtl88xx: UsbBus %-24s < 0x%04x\n", name, original_value); |
| } |
| return status; |
| } |
| |
| zx_status_t UsbBus::WriteRegister(uint16_t offset, uint32_t value, const char* name) { |
| const uint32_t original_value = value; |
| const zx_status_t status = |
| ControlWriteRegister(offset, reinterpret_cast<char*>(&value), sizeof(value)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::WriteRegister(%s) returned %s\n", name, |
| zx_status_get_string(status)); |
| } |
| if (kLogBusTransactions) { |
| zxlogf(INFO, "rtl88xx: UsbBus %-24s < 0x%08x\n", name, original_value); |
| } |
| return status; |
| } |
| |
| zx_status_t UsbBus::ControlReadRegister(uint16_t offset, char* value, size_t size) { |
| constexpr uint8_t kRequestType = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE; |
| constexpr uint8_t kRequest = 0x0; |
| constexpr uint8_t kIndex = 0x0; |
| |
| return usb_control_in(&usb_protocol_, kRequestType, kRequest, offset, kIndex, |
| zx::deadline_after(kRegisterIoDeadline).get(), value, size, |
| nullptr); |
| } |
| |
| zx_status_t UsbBus::ControlWriteRegister(uint16_t offset, char* value, size_t size) { |
| constexpr uint8_t kRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE; |
| constexpr uint8_t kRequest = 0x0; |
| constexpr uint8_t kIndex = 0x0; |
| |
| return usb_control_out(&usb_protocol_, kRequestType, kRequest, offset, kIndex, |
| zx::deadline_after(kRegisterIoDeadline).get(), value, size); |
| } |
| |
| } // namespace |
| |
| zx_status_t CreateUsbBus(zx_device_t* bus_device, std::unique_ptr<Bus>* bus) { |
| zx_status_t status = ZX_OK; |
| |
| usb_protocol_t usb_protocol = {}; |
| status = device_get_protocol(bus_device, ZX_PROTOCOL_USB, &usb_protocol); |
| if (status != ZX_OK) { |
| // Explicitly do not log an error here. The caller may try with another bus type instead. |
| return status; |
| } |
| |
| usb_device_descriptor_t usb_device_desc; |
| usb_get_device_descriptor(&usb_protocol, &usb_device_desc); |
| |
| usb_desc_iter_t usb_iter; |
| status = usb_desc_iter_init(&usb_protocol, &usb_iter); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: CreateUsbBus() failed to iterate descriptor: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| const usb_interface_descriptor_t* usb_iface_desc = |
| usb_desc_iter_next_interface(&usb_iter, true); |
| while (usb_iface_desc != nullptr) { |
| if (IsRealtekWlanDevice(*usb_iface_desc)) { break; } |
| usb_iface_desc = usb_desc_iter_next_interface(&usb_iter, true); |
| } |
| |
| if (usb_iface_desc != nullptr) { |
| const uint16_t kLangId = 0; |
| uint8_t id_buf[256]; |
| size_t actual_buflen = 0; |
| uint16_t actual_langid = 0; |
| if (usb_get_string_descriptor(&usb_protocol, usb_iface_desc->iInterface, kLangId, |
| &actual_langid, id_buf, sizeof(id_buf), &actual_buflen) |
| != ZX_OK) { |
| actual_buflen = 0; |
| } |
| id_buf[std::min(actual_buflen, fbl::count_of(id_buf) - 1)] = '\0'; |
| zxlogf(INFO, |
| "rtl88xx: CreateUsbBus() vid=%04x pid=%04x interface=%d alternate=%d class=%d " |
| "subclass=%d protocol=%d id=\"%s\"\n", |
| usb_device_desc.idVendor, usb_device_desc.idProduct, |
| usb_iface_desc->bInterfaceNumber, usb_iface_desc->bAlternateSetting, |
| usb_iface_desc->bInterfaceClass, usb_iface_desc->bInterfaceSubClass, |
| usb_iface_desc->bInterfaceProtocol, id_buf); |
| |
| status = UsbBus::Create(&usb_protocol, *usb_iface_desc, bus); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "rtl88xx: UsbBus::Create() returned %s\n", zx_status_get_string(status)); |
| } |
| } else { |
| status = ZX_ERR_NOT_SUPPORTED; |
| zxlogf(ERROR, "rtl88xx: UsbBus::Create() failed to find interface\n"); |
| } |
| usb_desc_iter_release(&usb_iter); |
| |
| return status; |
| } |
| |
| } // namespace rtl88xx |
| } // namespace wlan |
