mirror of
https://github.com/smaeul/u-boot.git
synced 2025-10-30 19:48:19 +00:00
58543c0d41
In SCMI base protocol version 2 (0x20000), new interfaces, BASE_SET_DEVICE_PERMISSIONS/BASE_SET_PROTOCOL_PERMISSIONS/ BASE_RESET_AGENT_CONFIGURATION, were added. Moreover, the api of BASE_DISCOVER_AGENT was changed to support self-agent discovery. So the driver expects SCMI firmware support version 2 of base protocol. Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org> Reviewed-by: Etienne Carriere <etienne.carriere@foss.st.com>
665 lines
16 KiB
C
665 lines
16 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* SCMI Base protocol as U-Boot device
|
|
*
|
|
* Copyright (C) 2023 Linaro Limited
|
|
* author: AKASHI Takahiro <takahiro.akashi@linaro.org>
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <dm.h>
|
|
#include <scmi_agent.h>
|
|
#include <scmi_protocols.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <asm/types.h>
|
|
#include <dm/device_compat.h>
|
|
#include <linux/kernel.h>
|
|
|
|
/**
|
|
* scmi_generic_protocol_version - get protocol version
|
|
* @dev: SCMI device
|
|
* @id: SCMI protocol ID
|
|
* @version: Pointer to SCMI protocol version
|
|
*
|
|
* Obtain the protocol version number in @version.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
int scmi_generic_protocol_version(struct udevice *dev,
|
|
enum scmi_std_protocol id, u32 *version)
|
|
{
|
|
struct scmi_protocol_version_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = id,
|
|
.message_id = SCMI_PROTOCOL_VERSION,
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*version = out.version;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_protocol_version_int - get Base protocol version
|
|
* @dev: SCMI device
|
|
* @version: Pointer to SCMI protocol version
|
|
*
|
|
* Obtain the protocol version number in @version for Base protocol.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_protocol_version_int(struct udevice *dev, u32 *version)
|
|
{
|
|
return scmi_generic_protocol_version(dev, SCMI_PROTOCOL_ID_BASE,
|
|
version);
|
|
}
|
|
|
|
/**
|
|
* scmi_protocol_attrs_int - get protocol attributes
|
|
* @dev: SCMI device
|
|
* @num_agents: Number of SCMI agents
|
|
* @num_protocols: Number of SCMI protocols
|
|
*
|
|
* Obtain the protocol attributes, the number of agents and the number
|
|
* of protocols, in @num_agents and @num_protocols respectively, that
|
|
* the device provides.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_protocol_attrs_int(struct udevice *dev, u32 *num_agents,
|
|
u32 *num_protocols)
|
|
{
|
|
struct scmi_protocol_attrs_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_PROTOCOL_ATTRIBUTES,
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*num_agents = SCMI_PROTOCOL_ATTRS_NUM_AGENTS(out.attributes);
|
|
*num_protocols = SCMI_PROTOCOL_ATTRS_NUM_PROTOCOLS(out.attributes);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_protocol_message_attrs_int - get message-specific attributes
|
|
* @dev: SCMI device
|
|
* @message_id: SCMI message ID
|
|
* @attributes: Message-specific attributes
|
|
*
|
|
* Obtain the message-specific attributes in @attributes.
|
|
* This command succeeds if the message is implemented and available.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_protocol_message_attrs_int(struct udevice *dev, u32 message_id,
|
|
u32 *attributes)
|
|
{
|
|
struct scmi_protocol_msg_attrs_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_PROTOCOL_MESSAGE_ATTRIBUTES,
|
|
.in_msg = (u8 *)&message_id,
|
|
.in_msg_sz = sizeof(message_id),
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*attributes = out.attributes;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_discover_vendor_int - get vendor name
|
|
* @dev: SCMI device
|
|
* @vendor: Pointer to vendor name
|
|
*
|
|
* Obtain the vendor's name in @vendor.
|
|
* It is a caller's responsibility to free @vendor.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_discover_vendor_int(struct udevice *dev, u8 **vendor)
|
|
{
|
|
struct scmi_base_discover_vendor_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_DISCOVER_VENDOR,
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
if (!vendor)
|
|
return -EINVAL;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*vendor = strdup(out.vendor_identifier);
|
|
if (!*vendor)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_discover_sub_vendor_int - get sub-vendor name
|
|
* @dev: SCMI device
|
|
* @sub_vendor: Pointer to sub-vendor name
|
|
*
|
|
* Obtain the sub-vendor's name in @sub_vendor.
|
|
* It is a caller's responsibility to free @sub_vendor.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_discover_sub_vendor_int(struct udevice *dev,
|
|
u8 **sub_vendor)
|
|
{
|
|
struct scmi_base_discover_vendor_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_DISCOVER_SUB_VENDOR,
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
if (!sub_vendor)
|
|
return -EINVAL;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*sub_vendor = strdup(out.vendor_identifier);
|
|
if (!*sub_vendor)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_discover_impl_version_int - get implementation version
|
|
* @dev: SCMI device
|
|
* @impl_version: Pointer to implementation version
|
|
*
|
|
* Obtain the implementation version number in @impl_version.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_discover_impl_version_int(struct udevice *dev,
|
|
u32 *impl_version)
|
|
{
|
|
struct scmi_base_discover_impl_version_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_DISCOVER_IMPL_VERSION,
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
*impl_version = out.impl_version;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_discover_list_protocols_int - get list of protocols
|
|
* @dev: SCMI device
|
|
* @protocols: Pointer to array of SCMI protocols
|
|
*
|
|
* Obtain the list of protocols provided in @protocols.
|
|
* The number of elements in @protocols always match to the number of
|
|
* protocols returned by smci_protocol_attrs() when this function succeeds.
|
|
* It is a caller's responsibility to free @protocols.
|
|
*
|
|
* Return: the number of protocols in @protocols on success, error code on
|
|
* failure
|
|
*/
|
|
static int scmi_base_discover_list_protocols_int(struct udevice *dev,
|
|
u8 **protocols)
|
|
{
|
|
struct scmi_base_discover_list_protocols_out out;
|
|
int cur;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_DISCOVER_LIST_PROTOCOLS,
|
|
.in_msg = (u8 *)&cur,
|
|
.in_msg_sz = sizeof(cur),
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
u32 num_agents, num_protocols;
|
|
u8 *buf;
|
|
int i, ret;
|
|
|
|
ret = scmi_base_protocol_attrs(dev, &num_agents, &num_protocols);
|
|
if (ret)
|
|
return ret;
|
|
|
|
buf = calloc(sizeof(u8), num_protocols);
|
|
if (!buf)
|
|
return -ENOMEM;
|
|
|
|
cur = 0;
|
|
do {
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
goto err;
|
|
if (out.status) {
|
|
ret = scmi_to_linux_errno(out.status);
|
|
goto err;
|
|
}
|
|
|
|
for (i = 0; i < out.num_protocols; i++, cur++)
|
|
buf[cur] = out.protocols[i / 4] >> ((i % 4) * 8);
|
|
} while (cur < num_protocols);
|
|
|
|
*protocols = buf;
|
|
|
|
return num_protocols;
|
|
err:
|
|
free(buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_discover_agent_int - identify agent
|
|
* @dev: SCMI device
|
|
* @agent_id: SCMI agent ID
|
|
* @ret_agent_id: Pointer to SCMI agent ID
|
|
* @name: Pointer to SCMI agent name
|
|
*
|
|
* Obtain the agent's name in @name. If @agent_id is equal to 0xffffffff,
|
|
* this function returns the caller's agent id in @ret_agent_id.
|
|
* It is a caller's responsibility to free @name.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_discover_agent_int(struct udevice *dev, u32 agent_id,
|
|
u32 *ret_agent_id, u8 **name)
|
|
{
|
|
struct scmi_base_discover_agent_out out;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_DISCOVER_AGENT,
|
|
.in_msg = (u8 *)&agent_id,
|
|
.in_msg_sz = sizeof(agent_id),
|
|
.out_msg = (u8 *)&out,
|
|
.out_msg_sz = sizeof(out),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (out.status)
|
|
return scmi_to_linux_errno(out.status);
|
|
|
|
if (ret_agent_id)
|
|
*ret_agent_id = out.agent_id;
|
|
if (name) {
|
|
*name = strdup(out.name);
|
|
if (!*name)
|
|
return -ENOMEM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_set_device_permissions_int - configure access permission to device
|
|
* @dev: SCMI device
|
|
* @agent_id: SCMI agent ID
|
|
* @device_id: ID of device to access
|
|
* @flags: A set of flags
|
|
*
|
|
* Ask for allowing or denying access permission to the device, @device_id.
|
|
* The meaning of @flags is defined in SCMI specification.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_set_device_permissions_int(struct udevice *dev, u32 agent_id,
|
|
u32 device_id, u32 flags)
|
|
{
|
|
struct scmi_base_set_device_permissions_in in = {
|
|
.agent_id = agent_id,
|
|
.device_id = device_id,
|
|
.flags = flags,
|
|
};
|
|
s32 status;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_SET_DEVICE_PERMISSIONS,
|
|
.in_msg = (u8 *)&in,
|
|
.in_msg_sz = sizeof(in),
|
|
.out_msg = (u8 *)&status,
|
|
.out_msg_sz = sizeof(status),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (status)
|
|
return scmi_to_linux_errno(status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_set_protocol_permissions_int - configure access permission to
|
|
* protocol on device
|
|
* @dev: SCMI device
|
|
* @agent_id: SCMI agent ID
|
|
* @device_id: ID of device to access
|
|
* @command_id: SCMI command ID
|
|
* @flags: A set of flags
|
|
*
|
|
* Ask for allowing or denying access permission to the protocol, @command_id,
|
|
* on the device, @device_id.
|
|
* The meaning of @flags is defined in SCMI specification.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_set_protocol_permissions_int(struct udevice *dev,
|
|
u32 agent_id, u32 device_id,
|
|
u32 command_id, u32 flags)
|
|
{
|
|
struct scmi_base_set_protocol_permissions_in in = {
|
|
.agent_id = agent_id,
|
|
.device_id = device_id,
|
|
.command_id = command_id,
|
|
.flags = flags,
|
|
};
|
|
s32 status;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_SET_PROTOCOL_PERMISSIONS,
|
|
.in_msg = (u8 *)&in,
|
|
.in_msg_sz = sizeof(in),
|
|
.out_msg = (u8 *)&status,
|
|
.out_msg_sz = sizeof(status),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (status)
|
|
return scmi_to_linux_errno(status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_reset_agent_configuration_int - reset resource settings
|
|
* @dev: SCMI device
|
|
* @agent_id: SCMI agent ID
|
|
* @flags: A set of flags
|
|
*
|
|
* Reset all the resource settings against @agent_id.
|
|
* The meaning of @flags is defined in SCMI specification.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_reset_agent_configuration_int(struct udevice *dev,
|
|
u32 agent_id, u32 flags)
|
|
{
|
|
struct scmi_base_reset_agent_configuration_in in = {
|
|
.agent_id = agent_id,
|
|
.flags = flags,
|
|
};
|
|
s32 status;
|
|
struct scmi_msg msg = {
|
|
.protocol_id = SCMI_PROTOCOL_ID_BASE,
|
|
.message_id = SCMI_BASE_RESET_AGENT_CONFIGURATION,
|
|
.in_msg = (u8 *)&in,
|
|
.in_msg_sz = sizeof(in),
|
|
.out_msg = (u8 *)&status,
|
|
.out_msg_sz = sizeof(status),
|
|
};
|
|
int ret;
|
|
|
|
ret = devm_scmi_process_msg(dev, &msg);
|
|
if (ret)
|
|
return ret;
|
|
if (status)
|
|
return scmi_to_linux_errno(status);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_base_probe - probe base protocol device
|
|
* @dev: SCMI device
|
|
*
|
|
* Probe the device for SCMI base protocol and initialize the private data.
|
|
*
|
|
* Return: 0 on success, error code on failure
|
|
*/
|
|
static int scmi_base_probe(struct udevice *dev)
|
|
{
|
|
u32 version;
|
|
int ret;
|
|
|
|
ret = devm_scmi_of_get_channel(dev);
|
|
if (ret) {
|
|
dev_err(dev, "get_channel failed\n");
|
|
return ret;
|
|
}
|
|
ret = scmi_base_protocol_version_int(dev, &version);
|
|
if (ret) {
|
|
dev_err(dev, "getting protocol version failed\n");
|
|
return ret;
|
|
}
|
|
if (version < SCMI_BASE_PROTOCOL_VERSION)
|
|
return -EINVAL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct scmi_base_ops scmi_base_ops = {
|
|
/* Commands */
|
|
.protocol_version = scmi_base_protocol_version_int,
|
|
.protocol_attrs = scmi_protocol_attrs_int,
|
|
.protocol_message_attrs = scmi_protocol_message_attrs_int,
|
|
.base_discover_vendor = scmi_base_discover_vendor_int,
|
|
.base_discover_sub_vendor = scmi_base_discover_sub_vendor_int,
|
|
.base_discover_impl_version = scmi_base_discover_impl_version_int,
|
|
.base_discover_list_protocols = scmi_base_discover_list_protocols_int,
|
|
.base_discover_agent = scmi_base_discover_agent_int,
|
|
.base_notify_errors = NULL,
|
|
.base_set_device_permissions = scmi_base_set_device_permissions_int,
|
|
.base_set_protocol_permissions = scmi_base_set_protocol_permissions_int,
|
|
.base_reset_agent_configuration =
|
|
scmi_base_reset_agent_configuration_int,
|
|
};
|
|
|
|
int scmi_base_protocol_version(struct udevice *dev, u32 *version)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->protocol_version)
|
|
return (*ops->protocol_version)(dev, version);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_protocol_attrs(struct udevice *dev, u32 *num_agents,
|
|
u32 *num_protocols)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->protocol_attrs)
|
|
return (*ops->protocol_attrs)(dev, num_agents, num_protocols);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_protocol_message_attrs(struct udevice *dev, u32 message_id,
|
|
u32 *attributes)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->protocol_message_attrs)
|
|
return (*ops->protocol_message_attrs)(dev, message_id,
|
|
attributes);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_discover_vendor(struct udevice *dev, u8 **vendor)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_discover_vendor)
|
|
return (*ops->base_discover_vendor)(dev, vendor);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_discover_sub_vendor(struct udevice *dev, u8 **sub_vendor)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_discover_sub_vendor)
|
|
return (*ops->base_discover_sub_vendor)(dev, sub_vendor);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_discover_impl_version(struct udevice *dev, u32 *impl_version)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_discover_impl_version)
|
|
return (*ops->base_discover_impl_version)(dev, impl_version);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_discover_list_protocols(struct udevice *dev, u8 **protocols)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_discover_list_protocols)
|
|
return (*ops->base_discover_list_protocols)(dev, protocols);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_discover_agent(struct udevice *dev, u32 agent_id,
|
|
u32 *ret_agent_id, u8 **name)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_discover_agent)
|
|
return (*ops->base_discover_agent)(dev, agent_id, ret_agent_id,
|
|
name);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_notify_errors(struct udevice *dev, u32 enable)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_notify_errors)
|
|
return (*ops->base_notify_errors)(dev, enable);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_set_device_permissions(struct udevice *dev, u32 agent_id,
|
|
u32 device_id, u32 flags)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_set_device_permissions)
|
|
return (*ops->base_set_device_permissions)(dev, agent_id,
|
|
device_id, flags);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_set_protocol_permissions(struct udevice *dev,
|
|
u32 agent_id, u32 device_id,
|
|
u32 command_id, u32 flags)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_set_protocol_permissions)
|
|
return (*ops->base_set_protocol_permissions)(dev, agent_id,
|
|
device_id,
|
|
command_id,
|
|
flags);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
int scmi_base_reset_agent_configuration(struct udevice *dev, u32 agent_id,
|
|
u32 flags)
|
|
{
|
|
const struct scmi_base_ops *ops = device_get_ops(dev);
|
|
|
|
if (ops->base_reset_agent_configuration)
|
|
return (*ops->base_reset_agent_configuration)(dev, agent_id,
|
|
flags);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
U_BOOT_DRIVER(scmi_base_drv) = {
|
|
.id = UCLASS_SCMI_BASE,
|
|
.name = "scmi_base_drv",
|
|
.ops = &scmi_base_ops,
|
|
.probe = scmi_base_probe,
|
|
};
|
|
|
|
UCLASS_DRIVER(scmi_base) = {
|
|
.id = UCLASS_SCMI_BASE,
|
|
.name = "scmi_base",
|
|
};
|