github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-26 08:02:27 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

firmware: stratix10-rsu: Migrate RSU driver to use stratix10 asynchronous framework.

Browse Source 
* Add support for asynchronous communication to the RSU client channel.
* Migrate functions that communicate with the SDM to use the asynchronous
  framework.

Signed-off-by: Mahesh Rao <mahesh.rao@altera.com>
Reviewed-by: Matthew Gerlach <matthew.gerlach@altera.com>
Signed-off-by: Dinh Nguyen <dinguyen@kernel.org>
This commit is contained in:
Mahesh Rao 2025-10-27 22:54:43 +08:00 committed by Dinh Nguyen
parent ec52379341
commit 15847537b6
1 changed files with 141 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
drivers/firmware/stratix10-rsu.c
View File

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0 // SPDX-License-Identifier: GPL-2.0
/* /*
* Copyright (C) 2018-2019, Intel Corporation * Copyright (C) 2018-2019, Intel Corporation
* Copyright (C) 2025, Altera Corporation
*/ */
#include <linux/arm-smccc.h> #include <linux/arm-smccc.h>
@ -14,11 +15,9 @@
#include <linux/firmware/intel/stratix10-svc-client.h> #include <linux/firmware/intel/stratix10-svc-client.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/sysfs.h> #include <linux/sysfs.h>
#include <linux/delay.h>
#define RSU_STATE_MASK GENMASK_ULL(31, 0) #define RSU_ERASE_SIZE_MASK GENMASK_ULL(63, 32)
#define RSU_VERSION_MASK GENMASK_ULL(63, 32)
#define RSU_ERROR_LOCATION_MASK GENMASK_ULL(31, 0)
#define RSU_ERROR_DETAIL_MASK GENMASK_ULL(63, 32)
#define RSU_DCMF0_MASK GENMASK_ULL(31, 0) #define RSU_DCMF0_MASK GENMASK_ULL(31, 0)
#define RSU_DCMF1_MASK GENMASK_ULL(63, 32) #define RSU_DCMF1_MASK GENMASK_ULL(63, 32)
#define RSU_DCMF2_MASK GENMASK_ULL(31, 0) #define RSU_DCMF2_MASK GENMASK_ULL(31, 0)
@ -35,7 +34,8 @@
#define INVALID_DCMF_STATUS 0xFFFFFFFF #define INVALID_DCMF_STATUS 0xFFFFFFFF
#define INVALID_SPT_ADDRESS 0x0 #define INVALID_SPT_ADDRESS 0x0
#define RSU_GET_SPT_CMD 0x5A #define RSU_RETRY_SLEEP_MS (1U)
#define RSU_ASYNC_MSG_RETRY (3U)
#define RSU_GET_SPT_RESP_LEN (4 * sizeof(unsigned int)) #define RSU_GET_SPT_RESP_LEN (4 * sizeof(unsigned int))
typedef void (*rsu_callback)(struct stratix10_svc_client *client, typedef void (*rsu_callback)(struct stratix10_svc_client *client,
@ -64,7 +64,6 @@ typedef void (*rsu_callback)(struct stratix10_svc_client *client,
* @max_retry: the preset max retry value * @max_retry: the preset max retry value
* @spt0_address: address of spt0 * @spt0_address: address of spt0
* @spt1_address: address of spt1 * @spt1_address: address of spt1
* @get_spt_response_buf: response from sdm for get_spt command
*/ */
struct stratix10_rsu_priv { struct stratix10_rsu_priv {
struct stratix10_svc_chan *chan; struct stratix10_svc_chan *chan;
@ -99,47 +98,32 @@ struct stratix10_rsu_priv {
unsigned long spt0_address; unsigned long spt0_address;
unsigned long spt1_address; unsigned long spt1_address;
unsigned int *get_spt_response_buf;
}; };
typedef void (*rsu_async_callback)(struct device *dev,
struct stratix10_rsu_priv *priv, struct stratix10_svc_cb_data *data);
/** /**
* rsu_status_callback() - Status callback from Intel Service Layer * rsu_async_status_callback() - Status callback from rsu_async_send()
* @client: pointer to service client * @dev: pointer to device object
* @priv: pointer to priv object
* @data: pointer to callback data structure * @data: pointer to callback data structure
* *
* Callback from Intel service layer for RSU status request. Status is * Callback from rsu_async_send() to get the system rsu error status.
* only updated after a system reboot, so a get updated status call is
* made during driver probe.
*/ */
static void rsu_status_callback(struct stratix10_svc_client *client, static void rsu_async_status_callback(struct device *dev,
struct stratix10_svc_cb_data *data) struct stratix10_rsu_priv *priv,
struct stratix10_svc_cb_data *data)
{ {
struct stratix10_rsu_priv *priv = client->priv; struct arm_smccc_1_2_regs *res = (struct arm_smccc_1_2_regs *)data->kaddr1;
struct arm_smccc_res *res = (struct arm_smccc_res *)data->kaddr1;
if (data->status == BIT(SVC_STATUS_OK)) { priv->status.current_image = res->a2;
priv->status.version = FIELD_GET(RSU_VERSION_MASK, priv->status.fail_image = res->a3;
res->a2); priv->status.state = res->a4;
priv->status.state = FIELD_GET(RSU_STATE_MASK, res->a2); priv->status.version = res->a5;
priv->status.fail_image = res->a1; priv->status.error_location = res->a7;
priv->status.current_image = res->a0; priv->status.error_details = res->a8;
priv->status.error_location = priv->retry_counter = res->a9;
FIELD_GET(RSU_ERROR_LOCATION_MASK, res->a3);
priv->status.error_details =
FIELD_GET(RSU_ERROR_DETAIL_MASK, res->a3);
} else {
dev_err(client->dev, "COMMAND_RSU_STATUS returned 0x%lX\n",
res->a0);
priv->status.version = 0;
priv->status.state = 0;
priv->status.fail_image = 0;
priv->status.current_image = 0;
priv->status.error_location = 0;
priv->status.error_details = 0;
}
complete(&priv->completion);
} }
/** /**
@ -163,32 +147,6 @@ static void rsu_command_callback(struct stratix10_svc_client *client,
complete(&priv->completion); complete(&priv->completion);
} }
/**
* rsu_retry_callback() - Callback from Intel service layer for getting
* the current image's retry counter from the firmware
* @client: pointer to client
* @data: pointer to callback data structure
*
* Callback from Intel service layer for retry counter, which is used by
* user to know how many times the images is still allowed to reload
* itself before giving up and starting RSU fail-over flow.
*/
static void rsu_retry_callback(struct stratix10_svc_client *client,
struct stratix10_svc_cb_data *data)
{
struct stratix10_rsu_priv *priv = client->priv;
unsigned int *counter = (unsigned int *)data->kaddr1;
if (data->status == BIT(SVC_STATUS_OK))
priv->retry_counter = *counter;
else if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
dev_warn(client->dev, "Secure FW doesn't support retry\n");
else
dev_err(client->dev, "Failed to get retry counter %lu\n",
BIT(data->status));
complete(&priv->completion);
}
/** /**
* rsu_max_retry_callback() - Callback from Intel service layer for getting * rsu_max_retry_callback() - Callback from Intel service layer for getting
@ -270,34 +228,19 @@ static void rsu_dcmf_status_callback(struct stratix10_svc_client *client,
complete(&priv->completion); complete(&priv->completion);
} }
static void rsu_get_spt_callback(struct stratix10_svc_client *client, /**
struct stratix10_svc_cb_data *data) * rsu_async_get_spt_table_callback() - Callback to be used by the rsu_async_send()
* to retrieve the SPT table information.
* @dev: pointer to device object
* @priv: pointer to priv object
* @data: pointer to callback data structure
*/
static void rsu_async_get_spt_table_callback(struct device *dev,
struct stratix10_rsu_priv *priv,
struct stratix10_svc_cb_data *data)
{ {
struct stratix10_rsu_priv *priv = client->priv; priv->spt0_address = *((unsigned long *)data->kaddr1);
unsigned long *mbox_err = (unsigned long *)data->kaddr1; priv->spt1_address = *((unsigned long *)data->kaddr2);
unsigned long *resp_len = (unsigned long *)data->kaddr2;
if (data->status != BIT(SVC_STATUS_OK) || (*mbox_err) ||
(*resp_len != RSU_GET_SPT_RESP_LEN))
goto error;
priv->spt0_address = priv->get_spt_response_buf[0];
priv->spt0_address <<= 32;
priv->spt0_address |= priv->get_spt_response_buf[1];
priv->spt1_address = priv->get_spt_response_buf[2];
priv->spt1_address <<= 32;
priv->spt1_address |= priv->get_spt_response_buf[3];
goto complete;
error:
dev_err(client->dev, "failed to get SPTs\n");
complete:
stratix10_svc_free_memory(priv->chan, priv->get_spt_response_buf);
priv->get_spt_response_buf = NULL;
complete(&priv->completion);
} }
/** /**
@ -329,14 +272,6 @@ static int rsu_send_msg(struct stratix10_rsu_priv *priv,
if (arg) if (arg)
msg.arg[0] = arg; msg.arg[0] = arg;
if (command == COMMAND_MBOX_SEND_CMD) {
msg.arg[1] = 0;
msg.payload = NULL;
msg.payload_length = 0;
msg.payload_output = priv->get_spt_response_buf;
msg.payload_length_output = RSU_GET_SPT_RESP_LEN;
}
ret = stratix10_svc_send(priv->chan, &msg); ret = stratix10_svc_send(priv->chan, &msg);
if (ret < 0) if (ret < 0)
goto status_done; goto status_done;
@ -362,6 +297,95 @@ static int rsu_send_msg(struct stratix10_rsu_priv *priv,
return ret; return ret;
} }
/**
* soc64_async_callback() - Callback from Intel service layer for async requests
* @ptr: pointer to the completion object
*/
static void soc64_async_callback(void *ptr)
{
if (ptr)
complete(ptr);
}
/**
* rsu_send_async_msg() - send an async message to Intel service layer
* @dev: pointer to device object
* @priv: pointer to rsu private data
* @command: RSU status or update command
* @arg: the request argument, notify status
* @callback: function pointer for the callback (status or update)
*/
static int rsu_send_async_msg(struct device *dev, struct stratix10_rsu_priv *priv,
enum stratix10_svc_command_code command,
unsigned long arg,
rsu_async_callback callback)
{
struct stratix10_svc_client_msg msg = {0};
struct stratix10_svc_cb_data data = {0};
struct completion completion;
int status, index, ret;
void *handle = NULL;
msg.command = command;
msg.arg[0] = arg;
init_completion(&completion);
for (index = 0; index < RSU_ASYNC_MSG_RETRY; index++) {
status = stratix10_svc_async_send(priv->chan, &msg,
&handle, soc64_async_callback,
&completion);
if (status == 0)
break;
dev_warn(dev, "Failed to send async message\n");
msleep(RSU_RETRY_SLEEP_MS);
}
if (status && !handle) {
dev_err(dev, "Failed to send async message\n");
return -ETIMEDOUT;
}
ret = wait_for_completion_io_timeout(&completion, RSU_TIMEOUT);
if (ret > 0)
dev_dbg(dev, "Received async interrupt\n");
else if (ret == 0)
dev_dbg(dev, "Timeout occurred. Trying to poll the response\n");
for (index = 0; index < RSU_ASYNC_MSG_RETRY; index++) {
status = stratix10_svc_async_poll(priv->chan, handle, &data);
if (status == -EAGAIN) {
dev_dbg(dev, "Async message is still in progress\n");
} else if (status < 0) {
dev_alert(dev, "Failed to poll async message\n");
ret = -ETIMEDOUT;
} else if (status == 0) {
ret = 0;
break;
}
msleep(RSU_RETRY_SLEEP_MS);
}
if (ret) {
dev_err(dev, "Failed to get async response\n");
goto status_done;
}
if (data.status == 0) {
ret = 0;
if (callback)
callback(dev, priv, &data);
} else {
dev_err(dev, "%s returned 0x%x from SDM\n", __func__,
data.status);
ret = -EFAULT;
}
status_done:
stratix10_svc_async_done(priv->chan, handle);
return ret;
}
/* /*
* This driver exposes some optional features of the Intel Stratix 10 SoC FPGA. * This driver exposes some optional features of the Intel Stratix 10 SoC FPGA.
* The sysfs interfaces exposed here are FPGA Remote System Update (RSU) * The sysfs interfaces exposed here are FPGA Remote System Update (RSU)
@ -597,27 +621,20 @@ static ssize_t notify_store(struct device *dev,
if (ret) if (ret)
return ret; return ret;
ret = rsu_send_msg(priv, COMMAND_RSU_NOTIFY, ret = rsu_send_async_msg(dev, priv, COMMAND_RSU_NOTIFY, status, NULL);
status, rsu_command_callback);
if (ret) { if (ret) {
dev_err(dev, "Error, RSU notify returned %i\n", ret); dev_err(dev, "Error, RSU notify returned %i\n", ret);
return ret; return ret;
} }
/* to get the updated state */ /* to get the updated state */
ret = rsu_send_msg(priv, COMMAND_RSU_STATUS, ret = rsu_send_async_msg(dev, priv, COMMAND_RSU_STATUS, 0,
0, rsu_status_callback); rsu_async_status_callback);
if (ret) { if (ret) {
dev_err(dev, "Error, getting RSU status %i\n", ret); dev_err(dev, "Error, getting RSU status %i\n", ret);
return ret; return ret;
} }
ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
if (ret) {
dev_err(dev, "Error, getting RSU retry %i\n", ret);
return ret;
}
return count; return count;
} }
@ -737,12 +754,19 @@ static int stratix10_rsu_probe(struct platform_device *pdev)
return PTR_ERR(priv->chan); return PTR_ERR(priv->chan);
} }
ret = stratix10_svc_add_async_client(priv->chan, false);
if (ret) {
dev_err(dev, "failed to add async client\n");
stratix10_svc_free_channel(priv->chan);
return ret;
}
init_completion(&priv->completion); init_completion(&priv->completion);
platform_set_drvdata(pdev, priv); platform_set_drvdata(pdev, priv);
/* get the initial state from firmware */ /* get the initial state from firmware */
ret = rsu_send_msg(priv, COMMAND_RSU_STATUS, ret = rsu_send_async_msg(dev, priv, COMMAND_RSU_STATUS, 0,
0, rsu_status_callback); rsu_async_status_callback);
if (ret) { if (ret) {
dev_err(dev, "Error, getting RSU status %i\n", ret); dev_err(dev, "Error, getting RSU status %i\n", ret);
stratix10_svc_free_channel(priv->chan); stratix10_svc_free_channel(priv->chan);
@ -763,12 +787,6 @@ static int stratix10_rsu_probe(struct platform_device *pdev)
stratix10_svc_free_channel(priv->chan); stratix10_svc_free_channel(priv->chan);
} }
ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
if (ret) {
dev_err(dev, "Error, getting RSU retry %i\n", ret);
stratix10_svc_free_channel(priv->chan);
}
ret = rsu_send_msg(priv, COMMAND_RSU_MAX_RETRY, 0, ret = rsu_send_msg(priv, COMMAND_RSU_MAX_RETRY, 0,
rsu_max_retry_callback); rsu_max_retry_callback);
if (ret) { if (ret) {
@ -776,18 +794,12 @@ static int stratix10_rsu_probe(struct platform_device *pdev)
stratix10_svc_free_channel(priv->chan); stratix10_svc_free_channel(priv->chan);
} }
priv->get_spt_response_buf =
stratix10_svc_allocate_memory(priv->chan, RSU_GET_SPT_RESP_LEN);
if (IS_ERR(priv->get_spt_response_buf)) { ret = rsu_send_async_msg(dev, priv, COMMAND_RSU_GET_SPT_TABLE, 0,
dev_err(dev, "failed to allocate get spt buffer\n"); rsu_async_get_spt_table_callback);
} else { if (ret) {
ret = rsu_send_msg(priv, COMMAND_MBOX_SEND_CMD, dev_err(dev, "Error, getting SPT table %i\n", ret);
RSU_GET_SPT_CMD, rsu_get_spt_callback); stratix10_svc_free_channel(priv->chan);
if (ret) {
dev_err(dev, "Error, getting SPT table %i\n", ret);
stratix10_svc_free_channel(priv->chan);
}
} }
return ret; return ret;