| // 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 "platform-device.h" |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <ddk/debug.h> |
| #include <ddk/device.h> |
| #include <ddk/driver.h> |
| #include <ddk/binding.h> |
| #include <ddk/metadata.h> |
| #include <ddk/protocol/platform-defs.h> |
| #include <zircon/syscalls/resource.h> |
| |
| #include "platform-bus.h" |
| |
| namespace platform_bus { |
| |
| zx_status_t PlatformDevice::Create(const pbus_dev_t* pdev, zx_device_t* parent, PlatformBus* bus, |
| uint32_t flags, |
| fbl::unique_ptr<platform_bus::PlatformDevice>* out) { |
| fbl::AllocChecker ac; |
| fbl::unique_ptr<platform_bus::PlatformDevice> dev(new (&ac) |
| platform_bus::PlatformDevice(parent, bus, flags, pdev)); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| auto status = dev->Init(pdev); |
| if (status != ZX_OK) { |
| return status; |
| } |
| out->swap(dev); |
| return ZX_OK; |
| } |
| |
| PlatformDevice::PlatformDevice(zx_device_t* parent, PlatformBus* bus, uint32_t flags, |
| const pbus_dev_t* pdev) |
| : PlatformDeviceType(parent), bus_(bus), flags_(flags), vid_(pdev->vid), pid_(pdev->pid), |
| did_(pdev->did), serial_port_info_(pdev->serial_port_info) { |
| strlcpy(name_, pdev->name, sizeof(name_)); |
| } |
| |
| zx_status_t PlatformDevice::Init(const pbus_dev_t* pdev) { |
| fbl::AllocChecker ac; |
| |
| if (pdev->mmio_count) { |
| mmios_.reserve(pdev->mmio_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->mmio_count; i++) { |
| mmios_.push_back(pdev->mmios[i]); |
| } |
| } |
| if (pdev->irq_count) { |
| irqs_.reserve(pdev->irq_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->irq_count; i++) { |
| irqs_.push_back(pdev->irqs[i]); |
| } |
| } |
| if (pdev->gpio_count) { |
| gpios_.reserve(pdev->gpio_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->gpio_count; i++) { |
| gpios_.push_back(pdev->gpios[i]); |
| } |
| } |
| if (pdev->i2c_channel_count) { |
| i2c_channels_.reserve(pdev->i2c_channel_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->i2c_channel_count; i++) { |
| i2c_channels_.push_back(pdev->i2c_channels[i]); |
| } |
| } |
| if (pdev->clk_count) { |
| clks_.reserve(pdev->clk_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->clk_count; i++) { |
| clks_.push_back(pdev->clks[i]); |
| } |
| } |
| if (pdev->bti_count) { |
| btis_.reserve(pdev->bti_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->bti_count; i++) { |
| btis_.push_back(pdev->btis[i]); |
| } |
| } |
| if (pdev->metadata_count) { |
| metadata_.reserve(pdev->metadata_count, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| for (uint32_t i = 0; i < pdev->metadata_count; i++) { |
| metadata_.push_back(pdev->metadata[i]); |
| } |
| } |
| |
| return ZX_OK; |
| } |
| |
| |
| zx_status_t PlatformDevice::MapMmio(uint32_t index, uint32_t cache_policy, void** out_vaddr, |
| size_t* out_size, zx_paddr_t* out_paddr, |
| zx_handle_t* out_handle) { |
| if (index >= mmios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| const pbus_mmio_t& mmio = mmios_[index]; |
| const zx_paddr_t vmo_base = ROUNDDOWN(mmio.base, PAGE_SIZE); |
| const size_t vmo_size = ROUNDUP(mmio.base + mmio.length - vmo_base, PAGE_SIZE); |
| zx_handle_t vmo_handle; |
| zx_status_t status = zx_vmo_create_physical(bus_->GetResource(), vmo_base, vmo_size, |
| &vmo_handle); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_map_mmio: zx_vmo_create_physical failed %d\n", status); |
| return status; |
| } |
| |
| status = zx_vmo_set_cache_policy(vmo_handle, cache_policy); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_map_mmio: zx_vmo_set_cache_policy failed %d\n", status); |
| goto fail; |
| } |
| |
| uintptr_t virt; |
| status = zx_vmar_map(zx_vmar_root_self(), 0, vmo_handle, 0, vmo_size, |
| ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE | ZX_VM_FLAG_MAP_RANGE, |
| &virt); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_map_mmio: zx_vmar_map failed %d\n", status); |
| goto fail; |
| } |
| |
| *out_size = mmio.length; |
| *out_handle = vmo_handle; |
| if (out_paddr) { |
| *out_paddr = vmo_base; |
| } |
| *out_vaddr = reinterpret_cast<void*>(virt + (mmio.base - vmo_base)); |
| return ZX_OK; |
| |
| fail: |
| zx_handle_close(vmo_handle); |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::MapInterrupt(uint32_t index, uint32_t flags, zx_handle_t* out_handle) { |
| if (index >= irqs_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| if (out_handle == nullptr) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| pbus_irq_t& irq = irqs_[index]; |
| if (flags == 0) { |
| flags = irq.mode; |
| } |
| zx_status_t status = zx_interrupt_create(bus_->GetResource(), irq.irq, flags, out_handle); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_map_interrupt: zx_interrupt_create failed %d\n", status); |
| return status; |
| } |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::GetBti(uint32_t index, zx_handle_t* out_handle) { |
| if (index >= btis_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| if (out_handle == nullptr) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| pbus_bti_t& bti = btis_[index]; |
| |
| return bus_->GetBti(bti.iommu_index, bti.bti_id, out_handle); |
| } |
| |
| zx_status_t PlatformDevice::GetDeviceInfo(pdev_device_info_t* out_info) { |
| memset(out_info, 0, sizeof(*out_info)); |
| out_info->vid = vid_; |
| out_info->pid = pid_; |
| out_info->did = did_; |
| memcpy(&out_info->serial_port_info, &serial_port_info_, sizeof(out_info->serial_port_info)); |
| out_info->mmio_count = static_cast<uint32_t>(mmios_.size()); |
| out_info->irq_count = static_cast<uint32_t>(irqs_.size()); |
| out_info->gpio_count = static_cast<uint32_t>(gpios_.size()); |
| out_info->i2c_channel_count = static_cast<uint32_t>(i2c_channels_.size()); |
| out_info->clk_count = static_cast<uint32_t>(clks_.size()); |
| out_info->bti_count = static_cast<uint32_t>(btis_.size()); |
| out_info->metadata_count = static_cast<uint32_t>(metadata_.size()); |
| memcpy(out_info->name, name_, sizeof(out_info->name)); |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t PlatformDevice::GetBoardInfo(pdev_board_info_t* out_info) { |
| return bus_->GetBoardInfo(out_info); |
| } |
| |
| // Create a resource and pass it back to the proxy along with necessary metadata |
| // to create/map the VMO in the driver process. |
| zx_status_t PlatformDevice::RpcGetMmio(uint32_t index, zx_paddr_t* out_paddr, size_t *out_length, |
| zx_handle_t* out_handle, uint32_t* out_handle_count) { |
| if (index >= mmios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| pbus_mmio_t* mmio = &mmios_[index]; |
| zx_handle_t handle; |
| char rsrc_name[ZX_MAX_NAME_LEN]; |
| snprintf(rsrc_name, ZX_MAX_NAME_LEN-1, "%s.pbus[%u]", name_, index); |
| zx_status_t status = zx_resource_create(bus_->GetResource(), ZX_RSRC_KIND_MMIO, mmio->base, |
| mmio->length, rsrc_name, sizeof(rsrc_name), &handle); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s: pdev_rpc_get_mmio: zx_resource_create failed: %d\n", name_, status); |
| return status; |
| } |
| |
| *out_paddr = mmio->base; |
| *out_length = mmio->length; |
| *out_handle_count = 1; |
| *out_handle = handle; |
| return ZX_OK; |
| } |
| |
| // Create a resource and pass it back to the proxy along with necessary metadata |
| // to create the IRQ in the driver process. |
| zx_status_t PlatformDevice::RpcGetInterrupt(uint32_t index, uint32_t* out_irq, uint32_t* out_mode, |
| zx_handle_t* out_handle, uint32_t* out_handle_count) { |
| if (index >= irqs_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| zx_handle_t handle; |
| pbus_irq_t* irq = &irqs_[index]; |
| uint32_t options = ZX_RSRC_KIND_IRQ | ZX_RSRC_FLAG_EXCLUSIVE; |
| char rsrc_name[ZX_MAX_NAME_LEN]; |
| snprintf(rsrc_name, ZX_MAX_NAME_LEN-1, "%s.pbus[%u]", name_, index); |
| zx_status_t status = zx_resource_create(bus_->GetResource(), options, irq->irq, 1, rsrc_name, |
| sizeof(rsrc_name), &handle); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| *out_irq = irq->irq; |
| *out_mode = irq->mode; |
| *out_handle_count = 1; |
| *out_handle = handle; |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::RpcGetBti(uint32_t index, zx_handle_t* out_handle, |
| uint32_t* out_handle_count) { |
| zx_status_t status = GetBti(index, out_handle); |
| if (status == ZX_OK) { |
| *out_handle_count = 1; |
| } |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::RpcUmsSetMode(usb_mode_t mode) { |
| if (bus_->ums() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->ums()->SetMode(mode); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioConfig(uint32_t index, uint32_t flags) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->gpio()->Config(gpios_[index].gpio, flags); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioSetAltFunction(uint32_t index, uint64_t function) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->gpio()->SetAltFunction(gpios_[index].gpio, function); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioRead(uint32_t index, uint8_t* out_value) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->gpio()->Read(gpios_[index].gpio, out_value); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioWrite(uint32_t index, uint8_t value) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->gpio()->Write(gpios_[index].gpio, value); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioGetInterrupt(uint32_t index, uint32_t flags, |
| zx_handle_t* out_handle, |
| uint32_t* out_handle_count) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| zx_status_t status = bus_->gpio()->GetInterrupt(gpios_[index].gpio, flags, out_handle); |
| if (status == ZX_OK) { |
| *out_handle_count = 1; |
| } |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioReleaseInterrupt(uint32_t index) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| return bus_->gpio()->ReleaseInterrupt(gpios_[index].gpio); |
| } |
| |
| zx_status_t PlatformDevice::RpcGpioSetPolarity(uint32_t index, uint32_t flags) { |
| if (bus_->gpio() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= gpios_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| return bus_->gpio()->SetPolarity(gpios_[index].gpio, flags); |
| } |
| |
| zx_status_t PlatformDevice::RpcCanvasConfig(zx_handle_t vmo, size_t offset, |
| canvas_info_t* info, uint8_t* canvas_idx) { |
| if (bus_->canvas() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->canvas()->Config(vmo, offset, info, canvas_idx); |
| } |
| |
| zx_status_t PlatformDevice::RpcCanvasFree(uint8_t canvas_idx) { |
| if (bus_->canvas() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->canvas()->Free(canvas_idx); |
| } |
| |
| zx_status_t PlatformDevice::RpcScpiGetSensor(char* name, uint32_t *sensor_id) { |
| if (bus_->scpi() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->scpi()->GetSensor(name, sensor_id); |
| } |
| |
| zx_status_t PlatformDevice::RpcScpiGetSensorValue(uint32_t sensor_id, uint32_t* sensor_value) { |
| if (bus_->scpi() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->scpi()->GetSensorValue(sensor_id, sensor_value); |
| } |
| |
| zx_status_t PlatformDevice::RpcScpiGetDvfsInfo(uint8_t power_domain, scpi_opp_t* opps) { |
| if (bus_->scpi() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->scpi()->GetDvfsInfo(power_domain, opps); |
| } |
| |
| zx_status_t PlatformDevice::RpcScpiGetDvfsIdx(uint8_t power_domain, uint16_t* idx) { |
| if (bus_->scpi() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->scpi()->GetDvfsIdx(power_domain, idx); |
| } |
| |
| zx_status_t PlatformDevice::RpcScpiSetDvfsIdx(uint8_t power_domain, uint16_t idx) { |
| if (bus_->scpi() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return bus_->scpi()->SetDvfsIdx(power_domain, idx); |
| } |
| |
| zx_status_t PlatformDevice::RpcI2cTransact(uint32_t txid, rpc_i2c_req_t* req, uint8_t* data, |
| zx_handle_t channel) { |
| if (bus_->i2c() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| uint32_t index = req->index; |
| if (index >= i2c_channels_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| // pbus_i2c_channel_t* pdev_channel = &i2c_channels_[index]; |
| |
| //FIXME return bus_->i2c()->Transact(pdev_channel->bus_id, out_size); |
| return 0; |
| } |
| |
| zx_status_t PlatformDevice::RpcI2cGetMaxTransferSize(uint32_t index, size_t* out_size) { |
| if (bus_->i2c() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= i2c_channels_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| pbus_i2c_channel_t* pdev_channel = &i2c_channels_[index]; |
| |
| return bus_->i2c()->GetMaxTransferSize(pdev_channel->bus_id, out_size); |
| } |
| |
| zx_status_t PlatformDevice::RpcClkEnable(uint32_t index) { |
| if (bus_->clk() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= clks_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->clk()->Enable(clks_[index].clk); |
| } |
| |
| zx_status_t PlatformDevice::RpcDisable(uint32_t index) { |
| if (bus_->clk() == nullptr) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (index >= clks_.size()) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| return bus_->clk()->Disable(clks_[index].clk); |
| } |
| |
| zx_status_t PlatformDevice::DdkRxrpc(zx_handle_t channel) { |
| if (channel == ZX_HANDLE_INVALID) { |
| // proxy device has connected |
| return ZX_OK; |
| } |
| |
| uint8_t req_buf[PROXY_MAX_TRANSFER_SIZE]; |
| uint8_t resp_buf[PROXY_MAX_TRANSFER_SIZE]; |
| auto* req_header = reinterpret_cast<rpc_req_header_t*>(&req_buf); |
| auto* resp_header = reinterpret_cast<rpc_rsp_header_t*>(&resp_buf); |
| uint32_t actual; |
| zx_handle_t in_handle; |
| uint32_t in_handle_count = 1; |
| |
| auto status = zx_channel_read(channel, 0, &req_buf, &in_handle, sizeof(req_buf), |
| in_handle_count, &actual, &in_handle_count); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_rxrpc: zx_channel_read failed %d\n", status); |
| return status; |
| } |
| |
| resp_header->txid = req_header->txid; |
| zx_handle_t handle = ZX_HANDLE_INVALID; |
| uint32_t handle_count = 0; |
| uint32_t resp_len; |
| |
| switch (req_header->protocol) { |
| case ZX_PROTOCOL_PLATFORM_DEV: { |
| auto req = reinterpret_cast<rpc_pdev_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| auto resp = reinterpret_cast<rpc_pdev_rsp_t*>(&resp_buf); |
| resp_len = sizeof(*resp); |
| |
| switch (req_header->op) { |
| case PDEV_GET_MMIO: |
| status = RpcGetMmio(req->index, &resp->paddr, &resp->length, &handle, &handle_count); |
| break; |
| case PDEV_GET_INTERRUPT: |
| status = RpcGetInterrupt(req->index, &resp->irq, &resp->mode, &handle, &handle_count); |
| break; |
| case PDEV_GET_BTI: |
| status = RpcGetBti(req->index, &handle, &handle_count); |
| break; |
| case PDEV_GET_DEVICE_INFO: |
| status = GetDeviceInfo(&resp->device_info); |
| break; |
| case PDEV_GET_BOARD_INFO: |
| status = bus_->GetBoardInfo(&resp->board_info); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_USB_MODE_SWITCH: { |
| auto req = reinterpret_cast<rpc_ums_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| resp_len = sizeof(*resp_header); |
| |
| switch (req_header->op) { |
| case UMS_SET_MODE: |
| status = RpcUmsSetMode(req->usb_mode); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_GPIO: { |
| auto req = reinterpret_cast<rpc_gpio_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| auto resp = reinterpret_cast<rpc_gpio_rsp_t*>(&resp_buf); |
| resp_len = sizeof(*resp); |
| |
| switch (req_header->op) { |
| case GPIO_CONFIG: |
| status = RpcGpioConfig(req->index, req->flags); |
| break; |
| case GPIO_SET_ALT_FUNCTION: |
| status = RpcGpioSetAltFunction(req->index, req->alt_function); |
| break; |
| case GPIO_READ: |
| status = RpcGpioRead(req->index, &resp->value); |
| break; |
| case GPIO_WRITE: |
| status = RpcGpioWrite(req->index, req->value); |
| break; |
| case GPIO_GET_INTERRUPT: |
| status = RpcGpioGetInterrupt(req->index, req->flags, &handle, &handle_count); |
| break; |
| case GPIO_RELEASE_INTERRUPT: |
| status = RpcGpioReleaseInterrupt(req->index); |
| break; |
| case GPIO_SET_POLARITY: |
| status = RpcGpioSetPolarity(req->index, req->polarity); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_SCPI: { |
| auto req = reinterpret_cast<rpc_scpi_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| auto resp = reinterpret_cast<rpc_scpi_rsp_t*>(&resp_buf); |
| resp_len = sizeof(*resp); |
| |
| switch (req_header->op) { |
| case SCPI_GET_SENSOR: |
| status = RpcScpiGetSensor(req->name, &resp->sensor_id); |
| break; |
| case SCPI_GET_SENSOR_VALUE: |
| status = RpcScpiGetSensorValue(req->sensor_id, &resp->sensor_value); |
| break; |
| case SCPI_GET_DVFS_INFO: |
| status = RpcScpiGetDvfsInfo(req->power_domain, &resp->opps); |
| break; |
| case SCPI_GET_DVFS_IDX: |
| status = RpcScpiGetDvfsIdx(req->power_domain, &resp->dvfs_idx); |
| break; |
| case SCPI_SET_DVFS_IDX: |
| status = RpcScpiSetDvfsIdx(req->power_domain, req->idx); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_I2C: { |
| auto req = reinterpret_cast<rpc_i2c_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| auto resp = reinterpret_cast<rpc_i2c_rsp_t*>(&resp_buf); |
| resp_len = sizeof(*resp); |
| |
| switch (req_header->op) { |
| case I2C_GET_MAX_TRANSFER: |
| status = RpcI2cGetMaxTransferSize(req->index, &resp->max_transfer); |
| break; |
| case I2C_TRANSACT: { |
| auto buf = reinterpret_cast<uint8_t*>(&req[1]); |
| status = RpcI2cTransact(req_header->txid, req, buf, channel); |
| if (status == ZX_OK) { |
| // If platform_i2c_transact succeeds, we return immmediately instead of calling |
| // zx_channel_write below. Instead we will respond in platform_i2c_complete(). |
| return ZX_OK; |
| } |
| break; |
| } |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_CLK: { |
| auto req = reinterpret_cast<rpc_clk_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| resp_len = sizeof(*resp_header); |
| |
| switch (req_header->op) { |
| case CLK_ENABLE: |
| status = RpcClkEnable(req->index); |
| break; |
| case CLK_DISABLE: |
| status = RpcDisable(req->index); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| case ZX_PROTOCOL_CANVAS: { |
| auto req = reinterpret_cast<rpc_canvas_req_t*>(&req_buf); |
| if (actual < sizeof(*req)) { |
| zxlogf(ERROR, "%s received %u, expecting %zu\n", __FUNCTION__, actual, sizeof(*req)); |
| return ZX_ERR_INTERNAL; |
| } |
| auto resp = reinterpret_cast<rpc_canvas_rsp_t*>(&resp_buf); |
| resp_len = sizeof(*resp); |
| |
| switch (req_header->op) { |
| case CANVAS_CONFIG: |
| status = RpcCanvasConfig(in_handle, req->offset, &req->info, |
| &resp->idx); |
| break; |
| case CANVAS_FREE: |
| status = RpcCanvasFree(req->idx); |
| break; |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| break; |
| } |
| default: |
| zxlogf(ERROR, "platform_dev_rxrpc: unknown op %u\n", req_header->op); |
| return ZX_ERR_INTERNAL; |
| } |
| |
| // set op to match request so zx_channel_write will return our response |
| resp_header->status = status; |
| status = zx_channel_write(channel, 0, resp_header, resp_len, |
| (handle_count == 1 ? &handle : nullptr), handle_count); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "platform_dev_rxrpc: zx_channel_write failed %d\n", status); |
| } |
| return status; |
| } |
| |
| zx_status_t PlatformDevice::DdkGetProtocol(uint32_t proto_id, void* out) { |
| if (proto_id == ZX_PROTOCOL_PLATFORM_DEV) { |
| auto proto = static_cast<platform_device_protocol_t*>(out); |
| proto->ops = &pdev_proto_ops_; |
| proto->ctx = this; |
| return ZX_OK; |
| } else { |
| return bus_->DdkGetProtocol(proto_id, out); |
| } |
| } |
| |
| void PlatformDevice::DdkRelease() { |
| delete this; |
| } |
| |
| zx_status_t PlatformDevice::AddMetaData(const pbus_metadata_t& pbm) { |
| const uint32_t type = pbm.type; |
| const uint32_t extra = pbm.extra; |
| const uint8_t* metadata = bus_->metadata(); |
| const size_t metadata_size = bus_->metadata_size(); |
| size_t offset = 0; |
| |
| while (offset < metadata_size) { |
| auto header = reinterpret_cast<const zbi_header_t*>(metadata); |
| size_t length = ZBI_ALIGN(sizeof(zbi_header_t) + header->length); |
| |
| if (header->type == type && header->extra == extra) { |
| return DdkAddMetadata(type, header + 1, length - sizeof(zbi_header_t)); |
| } |
| metadata += length; |
| offset += length; |
| } |
| zxlogf(ERROR, "%s metadata not found for type %08x, extra %u\n", __FUNCTION__, type, extra); |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| zx_status_t PlatformDevice::Enable(bool enable) { |
| zx_status_t status = ZX_OK; |
| |
| if (enable && !enabled_) { |
| zx_device_prop_t props[] = { |
| {BIND_PLATFORM_DEV_VID, 0, vid_}, |
| {BIND_PLATFORM_DEV_PID, 0, pid_}, |
| {BIND_PLATFORM_DEV_DID, 0, did_}, |
| }; |
| |
| char namestr[ZX_DEVICE_NAME_MAX]; |
| if (vid_ == PDEV_VID_GENERIC && pid_ == PDEV_PID_GENERIC && did_ == PDEV_DID_KPCI) { |
| strlcpy(namestr, "pci", sizeof(namestr)); |
| } else { |
| |
| snprintf(namestr, sizeof(namestr), "%02x:%02x:%01x", vid_, pid_, did_); |
| } |
| char argstr[64]; |
| snprintf(argstr, sizeof(argstr), "pdev:%s,", namestr); |
| uint32_t flags = 0; |
| if (!(flags_ & PDEV_ADD_PBUS_DEVHOST)) { |
| flags |= DEVICE_ADD_MUST_ISOLATE; |
| } |
| if (metadata_.size() > 0) { |
| flags |= DEVICE_ADD_INVISIBLE; |
| } |
| |
| status = DdkAdd(namestr, flags, props, countof(props), argstr); |
| |
| if (metadata_.size() > 0) { |
| for (const auto& pbm : metadata_) { |
| if (pbm.data && pbm.len) { |
| DdkAddMetadata(pbm.type, pbm.data, pbm.len); |
| } else { |
| AddMetaData(pbm); |
| } |
| } |
| DdkMakeVisible(); |
| } |
| } else if (!enable && enabled_) { |
| DdkRemove(); |
| } |
| |
| if (status == ZX_OK) { |
| enabled_ = enable; |
| } |
| |
| return status; |
| } |
| |
| } // namespace platform_bus |
