mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
645 lines
16 KiB
645 lines
16 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) 2019-2021 Linaro Ltd. |
|
*/ |
|
|
|
#include <linux/io.h> |
|
#include <linux/of.h> |
|
#include <linux/of_address.h> |
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/mutex.h> |
|
#include <linux/slab.h> |
|
#include <linux/tee_drv.h> |
|
#include <linux/uuid.h> |
|
#include <uapi/linux/tee.h> |
|
|
|
#include "common.h" |
|
|
|
#define SCMI_OPTEE_MAX_MSG_SIZE 128 |
|
|
|
enum scmi_optee_pta_cmd { |
|
/* |
|
* PTA_SCMI_CMD_CAPABILITIES - Get channel capabilities |
|
* |
|
* [out] value[0].a: Capability bit mask (enum pta_scmi_caps) |
|
* [out] value[0].b: Extended capabilities or 0 |
|
*/ |
|
PTA_SCMI_CMD_CAPABILITIES = 0, |
|
|
|
/* |
|
* PTA_SCMI_CMD_PROCESS_SMT_CHANNEL - Process SCMI message in SMT buffer |
|
* |
|
* [in] value[0].a: Channel handle |
|
* |
|
* Shared memory used for SCMI message/response exhange is expected |
|
* already identified and bound to channel handle in both SCMI agent |
|
* and SCMI server (OP-TEE) parts. |
|
* The memory uses SMT header to carry SCMI meta-data (protocol ID and |
|
* protocol message ID). |
|
*/ |
|
PTA_SCMI_CMD_PROCESS_SMT_CHANNEL = 1, |
|
|
|
/* |
|
* PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE - Process SMT/SCMI message |
|
* |
|
* [in] value[0].a: Channel handle |
|
* [in/out] memref[1]: Message/response buffer (SMT and SCMI payload) |
|
* |
|
* Shared memory used for SCMI message/response is a SMT buffer |
|
* referenced by param[1]. It shall be 128 bytes large to fit response |
|
* payload whatever message playload size. |
|
* The memory uses SMT header to carry SCMI meta-data (protocol ID and |
|
* protocol message ID). |
|
*/ |
|
PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE = 2, |
|
|
|
/* |
|
* PTA_SCMI_CMD_GET_CHANNEL - Get channel handle |
|
* |
|
* SCMI shm information are 0 if agent expects to use OP-TEE regular SHM |
|
* |
|
* [in] value[0].a: Channel identifier |
|
* [out] value[0].a: Returned channel handle |
|
* [in] value[0].b: Requested capabilities mask (enum pta_scmi_caps) |
|
*/ |
|
PTA_SCMI_CMD_GET_CHANNEL = 3, |
|
|
|
/* |
|
* PTA_SCMI_CMD_PROCESS_MSG_CHANNEL - Process SCMI message in a MSG |
|
* buffer pointed by memref parameters |
|
* |
|
* [in] value[0].a: Channel handle |
|
* [in] memref[1]: Message buffer (MSG and SCMI payload) |
|
* [out] memref[2]: Response buffer (MSG and SCMI payload) |
|
* |
|
* Shared memories used for SCMI message/response are MSG buffers |
|
* referenced by param[1] and param[2]. MSG transport protocol |
|
* uses a 32bit header to carry SCMI meta-data (protocol ID and |
|
* protocol message ID) followed by the effective SCMI message |
|
* payload. |
|
*/ |
|
PTA_SCMI_CMD_PROCESS_MSG_CHANNEL = 4, |
|
}; |
|
|
|
/* |
|
* OP-TEE SCMI service capabilities bit flags (32bit) |
|
* |
|
* PTA_SCMI_CAPS_SMT_HEADER |
|
* When set, OP-TEE supports command using SMT header protocol (SCMI shmem) in |
|
* shared memory buffers to carry SCMI protocol synchronisation information. |
|
* |
|
* PTA_SCMI_CAPS_MSG_HEADER |
|
* When set, OP-TEE supports command using MSG header protocol in an OP-TEE |
|
* shared memory to carry SCMI protocol synchronisation information and SCMI |
|
* message payload. |
|
*/ |
|
#define PTA_SCMI_CAPS_NONE 0 |
|
#define PTA_SCMI_CAPS_SMT_HEADER BIT(0) |
|
#define PTA_SCMI_CAPS_MSG_HEADER BIT(1) |
|
#define PTA_SCMI_CAPS_MASK (PTA_SCMI_CAPS_SMT_HEADER | \ |
|
PTA_SCMI_CAPS_MSG_HEADER) |
|
|
|
/** |
|
* struct scmi_optee_channel - Description of an OP-TEE SCMI channel |
|
* |
|
* @channel_id: OP-TEE channel ID used for this transport |
|
* @tee_session: TEE session identifier |
|
* @caps: OP-TEE SCMI channel capabilities |
|
* @rx_len: Response size |
|
* @mu: Mutex protection on channel access |
|
* @cinfo: SCMI channel information |
|
* @shmem: Virtual base address of the shared memory |
|
* @req: Shared memory protocol handle for SCMI request and synchronous response |
|
* @tee_shm: TEE shared memory handle @req or NULL if using IOMEM shmem |
|
* @link: Reference in agent's channel list |
|
*/ |
|
struct scmi_optee_channel { |
|
u32 channel_id; |
|
u32 tee_session; |
|
u32 caps; |
|
u32 rx_len; |
|
struct mutex mu; |
|
struct scmi_chan_info *cinfo; |
|
union { |
|
struct scmi_shared_mem __iomem *shmem; |
|
struct scmi_msg_payld *msg; |
|
} req; |
|
struct tee_shm *tee_shm; |
|
struct list_head link; |
|
}; |
|
|
|
/** |
|
* struct scmi_optee_agent - OP-TEE transport private data |
|
* |
|
* @dev: Device used for communication with TEE |
|
* @tee_ctx: TEE context used for communication |
|
* @caps: Supported channel capabilities |
|
* @mu: Mutex for protection of @channel_list |
|
* @channel_list: List of all created channels for the agent |
|
*/ |
|
struct scmi_optee_agent { |
|
struct device *dev; |
|
struct tee_context *tee_ctx; |
|
u32 caps; |
|
struct mutex mu; |
|
struct list_head channel_list; |
|
}; |
|
|
|
/* There can be only 1 SCMI service in OP-TEE we connect to */ |
|
static struct scmi_optee_agent *scmi_optee_private; |
|
|
|
/* Forward reference to scmi_optee transport initialization */ |
|
static int scmi_optee_init(void); |
|
|
|
/* Open a session toward SCMI OP-TEE service with REE_KERNEL identity */ |
|
static int open_session(struct scmi_optee_agent *agent, u32 *tee_session) |
|
{ |
|
struct device *dev = agent->dev; |
|
struct tee_client_device *scmi_pta = to_tee_client_device(dev); |
|
struct tee_ioctl_open_session_arg arg = { }; |
|
int ret; |
|
|
|
memcpy(arg.uuid, scmi_pta->id.uuid.b, TEE_IOCTL_UUID_LEN); |
|
arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL; |
|
|
|
ret = tee_client_open_session(agent->tee_ctx, &arg, NULL); |
|
if (ret < 0 || arg.ret) { |
|
dev_err(dev, "Can't open tee session: %d / %#x\n", ret, arg.ret); |
|
return -EOPNOTSUPP; |
|
} |
|
|
|
*tee_session = arg.session; |
|
|
|
return 0; |
|
} |
|
|
|
static void close_session(struct scmi_optee_agent *agent, u32 tee_session) |
|
{ |
|
tee_client_close_session(agent->tee_ctx, tee_session); |
|
} |
|
|
|
static int get_capabilities(struct scmi_optee_agent *agent) |
|
{ |
|
struct tee_ioctl_invoke_arg arg = { }; |
|
struct tee_param param[1] = { }; |
|
u32 caps; |
|
u32 tee_session; |
|
int ret; |
|
|
|
ret = open_session(agent, &tee_session); |
|
if (ret) |
|
return ret; |
|
|
|
arg.func = PTA_SCMI_CMD_CAPABILITIES; |
|
arg.session = tee_session; |
|
arg.num_params = 1; |
|
|
|
param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT; |
|
|
|
ret = tee_client_invoke_func(agent->tee_ctx, &arg, param); |
|
|
|
close_session(agent, tee_session); |
|
|
|
if (ret < 0 || arg.ret) { |
|
dev_err(agent->dev, "Can't get capabilities: %d / %#x\n", ret, arg.ret); |
|
return -EOPNOTSUPP; |
|
} |
|
|
|
caps = param[0].u.value.a; |
|
|
|
if (!(caps & (PTA_SCMI_CAPS_SMT_HEADER | PTA_SCMI_CAPS_MSG_HEADER))) { |
|
dev_err(agent->dev, "OP-TEE SCMI PTA doesn't support SMT and MSG\n"); |
|
return -EOPNOTSUPP; |
|
} |
|
|
|
agent->caps = caps; |
|
|
|
return 0; |
|
} |
|
|
|
static int get_channel(struct scmi_optee_channel *channel) |
|
{ |
|
struct device *dev = scmi_optee_private->dev; |
|
struct tee_ioctl_invoke_arg arg = { }; |
|
struct tee_param param[1] = { }; |
|
unsigned int caps = 0; |
|
int ret; |
|
|
|
if (channel->tee_shm) |
|
caps = PTA_SCMI_CAPS_MSG_HEADER; |
|
else |
|
caps = PTA_SCMI_CAPS_SMT_HEADER; |
|
|
|
arg.func = PTA_SCMI_CMD_GET_CHANNEL; |
|
arg.session = channel->tee_session; |
|
arg.num_params = 1; |
|
|
|
param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT; |
|
param[0].u.value.a = channel->channel_id; |
|
param[0].u.value.b = caps; |
|
|
|
ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param); |
|
|
|
if (ret || arg.ret) { |
|
dev_err(dev, "Can't get channel with caps %#x: %d / %#x\n", caps, ret, arg.ret); |
|
return -EOPNOTSUPP; |
|
} |
|
|
|
/* From now on use channel identifer provided by OP-TEE SCMI service */ |
|
channel->channel_id = param[0].u.value.a; |
|
channel->caps = caps; |
|
|
|
return 0; |
|
} |
|
|
|
static int invoke_process_smt_channel(struct scmi_optee_channel *channel) |
|
{ |
|
struct tee_ioctl_invoke_arg arg = { |
|
.func = PTA_SCMI_CMD_PROCESS_SMT_CHANNEL, |
|
.session = channel->tee_session, |
|
.num_params = 1, |
|
}; |
|
struct tee_param param[1] = { }; |
|
int ret; |
|
|
|
param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT; |
|
param[0].u.value.a = channel->channel_id; |
|
|
|
ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param); |
|
if (ret < 0 || arg.ret) { |
|
dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n", |
|
channel->channel_id, ret, arg.ret); |
|
return -EIO; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int invoke_process_msg_channel(struct scmi_optee_channel *channel, size_t msg_size) |
|
{ |
|
struct tee_ioctl_invoke_arg arg = { |
|
.func = PTA_SCMI_CMD_PROCESS_MSG_CHANNEL, |
|
.session = channel->tee_session, |
|
.num_params = 3, |
|
}; |
|
struct tee_param param[3] = { }; |
|
int ret; |
|
|
|
param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT; |
|
param[0].u.value.a = channel->channel_id; |
|
|
|
param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; |
|
param[1].u.memref.shm = channel->tee_shm; |
|
param[1].u.memref.size = msg_size; |
|
|
|
param[2].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT; |
|
param[2].u.memref.shm = channel->tee_shm; |
|
param[2].u.memref.size = SCMI_OPTEE_MAX_MSG_SIZE; |
|
|
|
ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param); |
|
if (ret < 0 || arg.ret) { |
|
dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n", |
|
channel->channel_id, ret, arg.ret); |
|
return -EIO; |
|
} |
|
|
|
/* Save response size */ |
|
channel->rx_len = param[2].u.memref.size; |
|
|
|
return 0; |
|
} |
|
|
|
static int scmi_optee_link_supplier(struct device *dev) |
|
{ |
|
if (!scmi_optee_private) { |
|
if (scmi_optee_init()) |
|
dev_dbg(dev, "Optee bus not yet ready\n"); |
|
|
|
/* Wait for optee bus */ |
|
return -EPROBE_DEFER; |
|
} |
|
|
|
if (!device_link_add(dev, scmi_optee_private->dev, DL_FLAG_AUTOREMOVE_CONSUMER)) { |
|
dev_err(dev, "Adding link to supplier optee device failed\n"); |
|
return -ECANCELED; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static bool scmi_optee_chan_available(struct device *dev, int idx) |
|
{ |
|
u32 channel_id; |
|
|
|
return !of_property_read_u32_index(dev->of_node, "linaro,optee-channel-id", |
|
idx, &channel_id); |
|
} |
|
|
|
static void scmi_optee_clear_channel(struct scmi_chan_info *cinfo) |
|
{ |
|
struct scmi_optee_channel *channel = cinfo->transport_info; |
|
|
|
if (!channel->tee_shm) |
|
shmem_clear_channel(channel->req.shmem); |
|
} |
|
|
|
static int setup_dynamic_shmem(struct device *dev, struct scmi_optee_channel *channel) |
|
{ |
|
const size_t msg_size = SCMI_OPTEE_MAX_MSG_SIZE; |
|
void *shbuf; |
|
|
|
channel->tee_shm = tee_shm_alloc_kernel_buf(scmi_optee_private->tee_ctx, msg_size); |
|
if (IS_ERR(channel->tee_shm)) { |
|
dev_err(channel->cinfo->dev, "shmem allocation failed\n"); |
|
return -ENOMEM; |
|
} |
|
|
|
shbuf = tee_shm_get_va(channel->tee_shm, 0); |
|
memset(shbuf, 0, msg_size); |
|
channel->req.msg = shbuf; |
|
channel->rx_len = msg_size; |
|
|
|
return 0; |
|
} |
|
|
|
static int setup_static_shmem(struct device *dev, struct scmi_chan_info *cinfo, |
|
struct scmi_optee_channel *channel) |
|
{ |
|
struct device_node *np; |
|
resource_size_t size; |
|
struct resource res; |
|
int ret; |
|
|
|
np = of_parse_phandle(cinfo->dev->of_node, "shmem", 0); |
|
if (!of_device_is_compatible(np, "arm,scmi-shmem")) { |
|
ret = -ENXIO; |
|
goto out; |
|
} |
|
|
|
ret = of_address_to_resource(np, 0, &res); |
|
if (ret) { |
|
dev_err(dev, "Failed to get SCMI Tx shared memory\n"); |
|
goto out; |
|
} |
|
|
|
size = resource_size(&res); |
|
|
|
channel->req.shmem = devm_ioremap(dev, res.start, size); |
|
if (!channel->req.shmem) { |
|
dev_err(dev, "Failed to ioremap SCMI Tx shared memory\n"); |
|
ret = -EADDRNOTAVAIL; |
|
goto out; |
|
} |
|
|
|
ret = 0; |
|
|
|
out: |
|
of_node_put(np); |
|
|
|
return ret; |
|
} |
|
|
|
static int setup_shmem(struct device *dev, struct scmi_chan_info *cinfo, |
|
struct scmi_optee_channel *channel) |
|
{ |
|
if (of_find_property(cinfo->dev->of_node, "shmem", NULL)) |
|
return setup_static_shmem(dev, cinfo, channel); |
|
else |
|
return setup_dynamic_shmem(dev, channel); |
|
} |
|
|
|
static int scmi_optee_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, bool tx) |
|
{ |
|
struct scmi_optee_channel *channel; |
|
uint32_t channel_id; |
|
int ret; |
|
|
|
if (!tx) |
|
return -ENODEV; |
|
|
|
channel = devm_kzalloc(dev, sizeof(*channel), GFP_KERNEL); |
|
if (!channel) |
|
return -ENOMEM; |
|
|
|
ret = of_property_read_u32_index(cinfo->dev->of_node, "linaro,optee-channel-id", |
|
0, &channel_id); |
|
if (ret) |
|
return ret; |
|
|
|
cinfo->transport_info = channel; |
|
channel->cinfo = cinfo; |
|
channel->channel_id = channel_id; |
|
mutex_init(&channel->mu); |
|
|
|
ret = setup_shmem(dev, cinfo, channel); |
|
if (ret) |
|
return ret; |
|
|
|
ret = open_session(scmi_optee_private, &channel->tee_session); |
|
if (ret) |
|
goto err_free_shm; |
|
|
|
ret = get_channel(channel); |
|
if (ret) |
|
goto err_close_sess; |
|
|
|
/* Enable polling */ |
|
cinfo->no_completion_irq = true; |
|
|
|
mutex_lock(&scmi_optee_private->mu); |
|
list_add(&channel->link, &scmi_optee_private->channel_list); |
|
mutex_unlock(&scmi_optee_private->mu); |
|
|
|
return 0; |
|
|
|
err_close_sess: |
|
close_session(scmi_optee_private, channel->tee_session); |
|
err_free_shm: |
|
if (channel->tee_shm) |
|
tee_shm_free(channel->tee_shm); |
|
|
|
return ret; |
|
} |
|
|
|
static int scmi_optee_chan_free(int id, void *p, void *data) |
|
{ |
|
struct scmi_chan_info *cinfo = p; |
|
struct scmi_optee_channel *channel = cinfo->transport_info; |
|
|
|
mutex_lock(&scmi_optee_private->mu); |
|
list_del(&channel->link); |
|
mutex_unlock(&scmi_optee_private->mu); |
|
|
|
close_session(scmi_optee_private, channel->tee_session); |
|
|
|
if (channel->tee_shm) { |
|
tee_shm_free(channel->tee_shm); |
|
channel->tee_shm = NULL; |
|
} |
|
|
|
cinfo->transport_info = NULL; |
|
channel->cinfo = NULL; |
|
|
|
scmi_free_channel(cinfo, data, id); |
|
|
|
return 0; |
|
} |
|
|
|
static int scmi_optee_send_message(struct scmi_chan_info *cinfo, |
|
struct scmi_xfer *xfer) |
|
{ |
|
struct scmi_optee_channel *channel = cinfo->transport_info; |
|
int ret; |
|
|
|
mutex_lock(&channel->mu); |
|
|
|
if (channel->tee_shm) { |
|
msg_tx_prepare(channel->req.msg, xfer); |
|
ret = invoke_process_msg_channel(channel, msg_command_size(xfer)); |
|
} else { |
|
shmem_tx_prepare(channel->req.shmem, xfer, cinfo); |
|
ret = invoke_process_smt_channel(channel); |
|
} |
|
|
|
if (ret) |
|
mutex_unlock(&channel->mu); |
|
|
|
return ret; |
|
} |
|
|
|
static void scmi_optee_fetch_response(struct scmi_chan_info *cinfo, |
|
struct scmi_xfer *xfer) |
|
{ |
|
struct scmi_optee_channel *channel = cinfo->transport_info; |
|
|
|
if (channel->tee_shm) |
|
msg_fetch_response(channel->req.msg, channel->rx_len, xfer); |
|
else |
|
shmem_fetch_response(channel->req.shmem, xfer); |
|
} |
|
|
|
static void scmi_optee_mark_txdone(struct scmi_chan_info *cinfo, int ret, |
|
struct scmi_xfer *__unused) |
|
{ |
|
struct scmi_optee_channel *channel = cinfo->transport_info; |
|
|
|
mutex_unlock(&channel->mu); |
|
} |
|
|
|
static struct scmi_transport_ops scmi_optee_ops = { |
|
.link_supplier = scmi_optee_link_supplier, |
|
.chan_available = scmi_optee_chan_available, |
|
.chan_setup = scmi_optee_chan_setup, |
|
.chan_free = scmi_optee_chan_free, |
|
.send_message = scmi_optee_send_message, |
|
.mark_txdone = scmi_optee_mark_txdone, |
|
.fetch_response = scmi_optee_fetch_response, |
|
.clear_channel = scmi_optee_clear_channel, |
|
}; |
|
|
|
static int scmi_optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data) |
|
{ |
|
return ver->impl_id == TEE_IMPL_ID_OPTEE; |
|
} |
|
|
|
static int scmi_optee_service_probe(struct device *dev) |
|
{ |
|
struct scmi_optee_agent *agent; |
|
struct tee_context *tee_ctx; |
|
int ret; |
|
|
|
/* Only one SCMI OP-TEE device allowed */ |
|
if (scmi_optee_private) { |
|
dev_err(dev, "An SCMI OP-TEE device was already initialized: only one allowed\n"); |
|
return -EBUSY; |
|
} |
|
|
|
tee_ctx = tee_client_open_context(NULL, scmi_optee_ctx_match, NULL, NULL); |
|
if (IS_ERR(tee_ctx)) |
|
return -ENODEV; |
|
|
|
agent = devm_kzalloc(dev, sizeof(*agent), GFP_KERNEL); |
|
if (!agent) { |
|
ret = -ENOMEM; |
|
goto err; |
|
} |
|
|
|
agent->dev = dev; |
|
agent->tee_ctx = tee_ctx; |
|
INIT_LIST_HEAD(&agent->channel_list); |
|
mutex_init(&agent->mu); |
|
|
|
ret = get_capabilities(agent); |
|
if (ret) |
|
goto err; |
|
|
|
/* Ensure agent resources are all visible before scmi_optee_private is */ |
|
smp_mb(); |
|
scmi_optee_private = agent; |
|
|
|
return 0; |
|
|
|
err: |
|
tee_client_close_context(tee_ctx); |
|
|
|
return ret; |
|
} |
|
|
|
static int scmi_optee_service_remove(struct device *dev) |
|
{ |
|
struct scmi_optee_agent *agent = scmi_optee_private; |
|
|
|
if (!scmi_optee_private) |
|
return -EINVAL; |
|
|
|
if (!list_empty(&scmi_optee_private->channel_list)) |
|
return -EBUSY; |
|
|
|
/* Ensure cleared reference is visible before resources are released */ |
|
smp_store_mb(scmi_optee_private, NULL); |
|
|
|
tee_client_close_context(agent->tee_ctx); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct tee_client_device_id scmi_optee_service_id[] = { |
|
{ |
|
UUID_INIT(0xa8cfe406, 0xd4f5, 0x4a2e, |
|
0x9f, 0x8d, 0xa2, 0x5d, 0xc7, 0x54, 0xc0, 0x99) |
|
}, |
|
{ } |
|
}; |
|
|
|
MODULE_DEVICE_TABLE(tee, scmi_optee_service_id); |
|
|
|
static struct tee_client_driver scmi_optee_driver = { |
|
.id_table = scmi_optee_service_id, |
|
.driver = { |
|
.name = "scmi-optee", |
|
.bus = &tee_bus_type, |
|
.probe = scmi_optee_service_probe, |
|
.remove = scmi_optee_service_remove, |
|
}, |
|
}; |
|
|
|
static int scmi_optee_init(void) |
|
{ |
|
return driver_register(&scmi_optee_driver.driver); |
|
} |
|
|
|
static void scmi_optee_exit(void) |
|
{ |
|
if (scmi_optee_private) |
|
driver_unregister(&scmi_optee_driver.driver); |
|
} |
|
|
|
const struct scmi_desc scmi_optee_desc = { |
|
.transport_exit = scmi_optee_exit, |
|
.ops = &scmi_optee_ops, |
|
.max_rx_timeout_ms = 30, |
|
.max_msg = 20, |
|
.max_msg_size = SCMI_OPTEE_MAX_MSG_SIZE, |
|
.sync_cmds_completed_on_ret = true, |
|
};
|
|
|