| // Copyright 2017 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 "hidctl.h" | |
| #include <fidl/fuchsia.hardware.hidctl/cpp/wire.h> | |
| #include <lib/ddk/binding_driver.h> | |
| #include <lib/ddk/debug.h> | |
| #include <lib/ddk/driver.h> | |
| #include <lib/ddk/platform-defs.h> | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <zircon/compiler.h> | |
| #include <memory> | |
| #include <utility> | |
| #include <cinttypes> | |
| #include <fbl/array.h> | |
| #include <fbl/auto_lock.h> | |
| #include <pretty/hexdump.h> | |
| namespace hidctl { | |
| namespace fhidbus = fuchsia_hardware_hidbus; | |
| zx_status_t HidCtl::Create(void* ctx, zx_device_t* parent) { | |
| auto dev = std::unique_ptr<HidCtl>(new HidCtl(parent)); | |
| zx_status_t status = dev->DdkAdd(ddk::DeviceAddArgs("hidctl").set_flags(DEVICE_ADD_NON_BINDABLE)); | |
| if (status != ZX_OK) { | |
| zxlogf(ERROR, "%s: could not add device: %d", __func__, status); | |
| } else { | |
| // devmgr owns the memory now | |
| [[maybe_unused]] auto* ptr = dev.release(); | |
| } | |
| return status; | |
| } | |
| void HidCtl::MakeHidDevice(MakeHidDeviceRequestView request, | |
| MakeHidDeviceCompleter::Sync& completer) { | |
| // Create the sockets for Sending/Recieving fake HID reports. | |
| zx::socket local, remote; | |
| zx_status_t status = zx::socket::create(ZX_SOCKET_DATAGRAM, &local, &remote); | |
| if (status != ZX_OK) { | |
| completer.Close(status); | |
| return; | |
| } | |
| // Create the fake HID device. | |
| uint8_t* report_desc_data = new uint8_t[request->rpt_desc.size()]; | |
| memcpy(report_desc_data, request->rpt_desc.data(), request->rpt_desc.size()); | |
| fbl::Array<const uint8_t> report_desc(report_desc_data, request->rpt_desc.size()); | |
| auto hiddev = std::make_unique<hidctl::HidDevice>(zxdev(), request->config, | |
| std::move(report_desc), std::move(local)); | |
| auto client_end = hiddev->ServeOutgoing(); | |
| std::array offers = { | |
| fhidbus::Service::Name, | |
| }; | |
| status = hiddev->DdkAdd(ddk::DeviceAddArgs("hidctl-dev") | |
| .set_fidl_service_offers(offers) | |
| .set_outgoing_dir(client_end->TakeChannel())); | |
| if (status != ZX_OK) { | |
| zxlogf(ERROR, "hidctl: could not add hid device: %d", status); | |
| completer.Close(status); | |
| return; | |
| } | |
| // The device thread will be created in DdkInit. | |
| zxlogf(INFO, "hidctl: created hid device"); | |
| // devmgr owns the memory until release is called | |
| [[maybe_unused]] auto ptr = hiddev.release(); | |
| completer.Reply(std::move(remote)); | |
| } | |
| HidCtl::HidCtl(zx_device_t* device) : DeviceType(device) {} | |
| void HidCtl::DdkRelease() { delete this; } | |
| HidDevice::HidDevice(zx_device_t* device, const fuchsia_hardware_hidctl::wire::HidCtlConfig& config, | |
| fbl::Array<const uint8_t> report_desc, zx::socket data) | |
| : ddk::Device<HidDevice, ddk::Initializable, ddk::Unbindable>(device), | |
| outgoing_(fdf::Dispatcher::GetCurrent()->async_dispatcher()), | |
| boot_protocol_(config.boot_device | |
| ? static_cast<fhidbus::wire::HidBootProtocol>(config.dev_class) | |
| : fhidbus::wire::HidBootProtocol::kNone), | |
| report_desc_(std::move(report_desc)), | |
| data_(std::move(data)) { | |
| ZX_DEBUG_ASSERT(data_.is_valid()); | |
| } | |
| void HidDevice::DdkInit(ddk::InitTxn txn) { | |
| wait_handler_.set_object(data_.get()); | |
| wait_handler_.set_trigger(ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED); | |
| txn.Reply(wait_handler_.Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher())); | |
| } | |
| void HidDevice::DdkRelease() { | |
| zxlogf(DEBUG, "hidctl: DdkRelease"); | |
| delete this; | |
| } | |
| void HidDevice::DdkUnbind(ddk::UnbindTxn txn) { | |
| zxlogf(DEBUG, "hidctl: DdkUnbind"); | |
| fbl::AutoLock lock(&lock_); | |
| if (data_.is_valid()) { | |
| // Prevent further writes to the socket | |
| zx_status_t status = data_.set_disposition(0, ZX_SOCKET_DISPOSITION_WRITE_DISABLED); | |
| ZX_DEBUG_ASSERT(status == ZX_OK); | |
| // Signal the thread to shutdown | |
| wait_handler_.Cancel(); | |
| } | |
| txn.Reply(); | |
| } | |
| zx::result<fidl::ClientEnd<fuchsia_io::Directory>> HidDevice::ServeOutgoing() { | |
| zx::result<> result = outgoing_.AddService<fhidbus::Service>(fhidbus::Service::InstanceHandler({ | |
| .device = | |
| [this](fidl::ServerEnd<fhidbus::Hidbus> server_end) { | |
| if (binding_) { | |
| server_end.Close(ZX_ERR_ALREADY_BOUND); | |
| return; | |
| } | |
| binding_.emplace(fdf::Dispatcher::GetCurrent()->async_dispatcher(), | |
| std::move(server_end), this, [this](fidl::UnbindInfo info) { | |
| Stop(); | |
| binding_.reset(); | |
| }); | |
| }, | |
| })); | |
| if (result.is_error()) { | |
| zxlogf(ERROR, "Failed to add Hidbus protocol: %s", result.status_string()); | |
| return result.take_error(); | |
| } | |
| auto [client, server] = fidl::Endpoints<fuchsia_io::Directory>::Create(); | |
| result = outgoing_.Serve(std::move(server)); | |
| if (result.is_error()) { | |
| zxlogf(ERROR, "Failed to service the outgoing directory"); | |
| return result.take_error(); | |
| } | |
| return zx::ok(std::move(client)); | |
| } | |
| void HidDevice::Query(QueryCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: query"); | |
| fidl::Arena<> arena; | |
| completer.ReplySuccess(fhidbus::wire::HidInfo::Builder(arena) | |
| .dev_num(0) | |
| .boot_protocol(boot_protocol_) | |
| .vendor_id(0) | |
| .product_id(0) | |
| .version(0) | |
| .polling_rate(0) | |
| .Build()); | |
| } | |
| void HidDevice::Start(StartCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: start"); | |
| if (started_) { | |
| zxlogf(ERROR, "Already started"); | |
| completer.ReplyError(ZX_ERR_ALREADY_BOUND); | |
| return; | |
| } | |
| started_ = true; | |
| completer.ReplySuccess(); | |
| } | |
| void HidDevice::Stop(StopCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: stop"); | |
| Stop(); | |
| } | |
| void HidDevice::Stop() { started_ = false; } | |
| void HidDevice::GetDescriptor(fhidbus::wire::HidbusGetDescriptorRequest* request, | |
| GetDescriptorCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: get descriptor %" PRIu8, static_cast<uint8_t>(request->desc_type)); | |
| if (request->desc_type != fhidbus::wire::HidDescriptorType::kReport) { | |
| completer.ReplyError(ZX_ERR_NOT_FOUND); | |
| return; | |
| } | |
| completer.ReplySuccess(fidl::VectorView<uint8_t>::FromExternal( | |
| const_cast<uint8_t*>(report_desc_.data()), report_desc_.size())); | |
| } | |
| void HidDevice::SetDescriptor(fhidbus::wire::HidbusSetDescriptorRequest* request, | |
| SetDescriptorCompleter::Sync& completer) { | |
| completer.ReplyError(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| void HidDevice::GetReport(fhidbus::wire::HidbusGetReportRequest* request, | |
| GetReportCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: get report type=%" PRIu8 " id=%" PRIu8, | |
| static_cast<uint8_t>(request->rpt_type), request->rpt_id); | |
| // TODO: send get report message over socket | |
| completer.ReplyError(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| void HidDevice::SetReport(fhidbus::wire::HidbusSetReportRequest* request, | |
| SetReportCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: set report type=%" PRIu8 " id=%" PRIu8, | |
| static_cast<uint8_t>(request->rpt_type), request->rpt_id); | |
| // TODO: send set report message over socket | |
| completer.ReplyError(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| void HidDevice::GetIdle(fhidbus::wire::HidbusGetIdleRequest* request, | |
| GetIdleCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: get idle"); | |
| // TODO: send get idle message over socket | |
| completer.ReplyError(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| void HidDevice::SetIdle(fhidbus::wire::HidbusSetIdleRequest* request, | |
| SetIdleCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: set idle"); | |
| // TODO: send set idle message over socket | |
| completer.ReplySuccess(); | |
| } | |
| void HidDevice::GetProtocol(GetProtocolCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: get protocol"); | |
| // TODO: send get protocol message over socket | |
| completer.ReplyError(ZX_ERR_NOT_SUPPORTED); | |
| } | |
| void HidDevice::SetProtocol(fhidbus::wire::HidbusSetProtocolRequest* request, | |
| SetProtocolCompleter::Sync& completer) { | |
| zxlogf(DEBUG, "hidctl: set protocol"); | |
| // TODO: send set protocol message over socket | |
| completer.ReplySuccess(); | |
| } | |
| void HidDevice::HandleData(async_dispatcher_t* dispatcher, async::WaitBase* wait, | |
| zx_status_t status, const zx_packet_signal_t* signal) { | |
| if (status != ZX_OK) { | |
| zxlogf(ERROR, "hidctl: error waiting on data: %d", status); | |
| DdkAsyncRemove(); | |
| return; | |
| } | |
| if (signal->observed & ZX_SOCKET_READABLE) { | |
| status = Recv(buf_.data(), mtu_); | |
| if (status != ZX_OK) { | |
| DdkAsyncRemove(); | |
| return; | |
| } | |
| } | |
| if (signal->observed & ZX_SOCKET_PEER_CLOSED) { | |
| zxlogf(DEBUG, "hidctl: socket closed (peer)"); | |
| DdkAsyncRemove(); | |
| return; | |
| } | |
| wait_handler_.Begin(dispatcher); | |
| } | |
| zx_status_t HidDevice::Recv(uint8_t* buffer, uint32_t capacity) { | |
| size_t actual = 0; | |
| zx_status_t status = ZX_OK; | |
| // Read all the datagrams out of the socket. | |
| while (status == ZX_OK) { | |
| status = data_.read(0u, buffer, capacity, &actual); | |
| if (status == ZX_ERR_SHOULD_WAIT || status == ZX_ERR_PEER_CLOSED) { | |
| break; | |
| } | |
| if (status != ZX_OK) { | |
| zxlogf(ERROR, "hidctl: error reading data: %d", status); | |
| return status; | |
| } | |
| fbl::AutoLock lock(&lock_); | |
| if (unlikely(zxlog_level_enabled(DEBUG))) { | |
| zxlogf(DEBUG, "hidctl: received %zu bytes", actual); | |
| hexdump8_ex(buffer, actual, 0); | |
| } | |
| if (started_ && binding_) { | |
| fidl::Arena arena; | |
| auto result = fidl::WireSendEvent(*binding_)->OnReportReceived( | |
| fhidbus::wire::Report::Builder(arena) | |
| .buf(fidl::VectorView<uint8_t>::FromExternal(buffer, actual)) | |
| .timestamp(zx_clock_get_monotonic()) | |
| .Build()); | |
| if (!result.ok()) { | |
| zxlogf(ERROR, "OnReportReceived failed %s", result.error().FormatDescription().c_str()); | |
| } | |
| } | |
| } | |
| return ZX_OK; | |
| } | |
| static constexpr zx_driver_ops_t driver_ops = []() { | |
| zx_driver_ops_t ops = {}; | |
| ops.version = DRIVER_OPS_VERSION; | |
| ops.bind = HidCtl::Create; | |
| return ops; | |
| }(); | |
| } // namespace hidctl | |
| ZIRCON_DRIVER(hidctl, hidctl::driver_ops, "zircon", "0.1"); |