blob: bc183814b97382f021ecd1fe9179396b16c5b020 [file] [edit]
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
//
// This file is provided under a dual BSD/GPLv2 license. When using or
// redistributing this file, you may do so under either license.
//
// Copyright(c) 2026 Advanced Micro Devices, Inc. All rights reserved.
//
// Authors: Vijendar Mukunda <Vijendar.Mukunda@amd.com>
/*
* ASP (AMD Security Processor) mailbox communication and ACP7.B/7.F carveout
* memory firmware load/restore for the ACP7.B/7.F platform.
*/
#include <linux/acpi.h>
#include <linux/firmware.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/unaligned.h>
#include <asm/amd/node.h>
#include "../ops.h"
#include "acp-dsp-offset.h"
#include "acp.h"
/*
* acp7x_asp_send_cmd - send one ASP mailbox command via the ACPI AMSG method.
*
* The ACPI method "AMSG" (stored as 'GSMA' LE) is used to
* proxy commands to ASP. Direct SMN writes to MPASP_C2PMSG_* do not work
* because the BIOS gates host access to those registers and requires all
* ASP mailbox traffic to go through this ACPI method.
*
* The caller must fill adata->asp_mbox_buf with the payload before calling.
* On return the same buffer contains ASP's response fields.
*
* ACPI method signature: AMSG(CommandId, PayloadPhysAddrHi, PayloadPhysAddrLo)
* GET_CARVEOUT_ADDR uses a short 50 ms probe timeout; other commands use 5 s.
*/
static int acp7x_asp_send_cmd(struct snd_sof_dev *sdev, u16 cmd_id)
{
struct pci_dev *pci = to_pci_dev(sdev->dev);
struct acp_dev_data *adata = sdev->pdata->hw_pdata;
struct acpi_device *adev = ACPI_COMPANION(&pci->dev);
union acpi_object args[3];
struct acpi_object_list arg_list = { ARRAY_SIZE(args), args };
unsigned long timeout;
acpi_handle handle;
acpi_status status;
unsigned int ready_timeout;
u32 ctrl;
int ret, smn_ret;
if (!adev) {
dev_err(sdev->dev, "ASP cmd 0x%04x: no ACPI companion device\n", cmd_id);
return -ENODEV;
}
handle = adev->handle;
/* Short timeout for GET_CARVEOUT_ADDR to fail fast if ASP lacks carveout support. */
ready_timeout = (cmd_id == ASP_MBOX_CMD_GET_CARVEOUT_ADDR) ?
ASP_MBOX_PROBE_TIMEOUT_US : ASP_MBOX_TIMEOUT_US;
timeout = jiffies + usecs_to_jiffies(ready_timeout);
ret = -ETIMEDOUT;
do {
smn_ret = amd_smn_read(0, MPASP_C2PMSG_173_REG, &ctrl);
if (smn_ret) {
dev_err(sdev->dev, "ASP mailbox SMN read failed: %d\n", smn_ret);
return smn_ret;
}
if (ctrl & ASP_MBOX_READY_BIT) {
ret = 0;
break;
}
usleep_range(ASP_MBOX_POLL_INTERVAL_US, ASP_MBOX_POLL_INTERVAL_US + 100);
} while (!time_after(jiffies, timeout));
if (ret) {
dev_err(sdev->dev, "ASP mailbox not ready before cmd 0x%04x\n", cmd_id);
return -ETIMEDOUT;
}
args[0].type = ACPI_TYPE_INTEGER;
args[0].integer.value = cmd_id;
args[1].type = ACPI_TYPE_INTEGER;
args[1].integer.value = upper_32_bits(adata->asp_mbox_buf_phys);
args[2].type = ACPI_TYPE_INTEGER;
args[2].integer.value = lower_32_bits(adata->asp_mbox_buf_phys);
status = acpi_evaluate_object(handle, "AMSG", &arg_list, NULL);
if (ACPI_FAILURE(status)) {
dev_err(sdev->dev, "ASP AMSG cmd 0x%04x: ACPI method failed: %s\n",
cmd_id, acpi_format_exception(status));
return -EIO;
}
return 0;
}
/*
* acp7x_configure_carveout_pte - program ATU groups for ACP7.B/7.F carveout.
*
* Programs PAGE_SIZE, BASE_ADDR and PTE entries for each ATU group covering
* the carveout region using 2 MB pages with PAGE_Enable | MALL_Enable flags.
* Must be called after GET_CARVEOUT_ADDR and on every D0 resume since
* acp_init() resets the scratch SRAM and ATU registers.
*/
int acp7x_configure_carveout_pte(struct snd_sof_dev *sdev)
{
struct acp_dev_data *adata = sdev->pdata->hw_pdata;
const struct sof_amd_acp_desc *desc = get_chip_info(sdev->pdata);
u64 phys_addr;
u32 grp_start = adata->asp_carveout_group_start;
u32 grp_count = adata->asp_carveout_group_count;
u32 total_pages, pages_per_group;
u32 grp, page_in_grp, page_idx;
u32 pte_scratch_offset, page_size_reg, base_addr_reg, reg_val;
u32 pte_lo_addr, pte_hi_addr;
u32 low, high;
u32 abs_grp;
if (!adata->asp_carveout_base) {
dev_err(sdev->dev, "carveout PTE: no valid carveout address\n");
return -EINVAL;
}
if (!grp_count || grp_start < 8 || grp_start + grp_count > 16) {
dev_err(sdev->dev, "carveout PTE: invalid ATU group range %u+%u\n",
grp_start, grp_count);
return -EINVAL;
}
/*
* ASP is expected to allocate exactly four contiguous 8 MB ATU groups
* for the fixed 32 MB carveout. Warn if the response differs so that
* unexpected firmware behaviour is clearly visible in the log.
*/
if (grp_count != 4)
dev_warn(sdev->dev, "carveout PTE: expected 4 ATU groups, got %u\n",
grp_count);
total_pages = adata->asp_carveout_size / ACP7X_CARVEOUT_PAGE_SIZE;
pages_per_group = total_pages / grp_count;
page_idx = 0;
for (grp = 0; grp < grp_count; grp++) {
abs_grp = grp_start + grp;
/*
* asp_carveout_group_start is the 0-based index from
* __ffs(mall_addr_valid): bit N in MallGroupEntries represents
* hardware GRP_(N+1), so abs_grp is 0-based and GRP number is
* (abs_grp + 1). Example: bits 11-14 set -> abs_grp 11..14 ->
* programs GRP_12..GRP_15 (registers 0xC5C..0xC74).
* ATU_CTRL (0xC40) sits between GRP_8 and GRP_9, adding a
* 4-byte gap for abs_grp >= 8 (i.e. GRP_9 and above).
*/
if (abs_grp < 8)
page_size_reg = ACPAXI2AXI_ATU_PAGE_SIZE_GRP_1 + abs_grp * 8;
else
page_size_reg = ACPAXI2AXI_ATU_PAGE_SIZE_GRP_1 + abs_grp * 8 + 4;
base_addr_reg = page_size_reg + 4;
pte_scratch_offset = abs_grp * 0x20;
reg_val = desc->sram_pte_offset + pte_scratch_offset;
snd_sof_dsp_write(sdev, ACP_DSP_BAR, page_size_reg, PAGE_SIZE_2M_ENABLE);
snd_sof_dsp_write(sdev, ACP_DSP_BAR, base_addr_reg, reg_val | BIT(31));
dev_dbg(sdev->dev,
"carveout ATU: abs_grp=%u PAGE_SIZE_reg=0x%x BASE_ADDR_reg=0x%x val=0x%x\n",
abs_grp, page_size_reg, base_addr_reg,
(u32)(reg_val | BIT(31)));
for (page_in_grp = 0; page_in_grp < pages_per_group;
page_in_grp++, page_idx++) {
pte_lo_addr = ACP_SCRATCH_REG_0 + pte_scratch_offset + (page_in_grp * 8);
pte_hi_addr = pte_lo_addr + 4;
phys_addr = adata->asp_carveout_base +
((u64)page_idx * ACP7X_CARVEOUT_PAGE_SIZE);
low = lower_32_bits(phys_addr);
high = upper_32_bits(phys_addr) | ACP_ATU_PTE_CARVEOUT_FLAGS;
snd_sof_dsp_write(sdev, ACP_DSP_BAR, pte_lo_addr, low);
snd_sof_dsp_write(sdev, ACP_DSP_BAR, pte_hi_addr, high);
}
}
snd_sof_dsp_write(sdev, ACP_DSP_BAR, ACPAXI2AXI_ATU_CTRL, ACP_ATU_CACHE_INVALID);
dev_dbg(sdev->dev,
"carveout PTE done: %u groups [%u..%u] covering 0x%llx..0x%llx\n",
grp_count, grp_start, grp_start + grp_count - 1,
adata->asp_carveout_base,
adata->asp_carveout_base + (u64)adata->asp_carveout_size);
return 0;
}
EXPORT_SYMBOL_NS(acp7x_configure_carveout_pte, "SND_SOC_SOF_AMD_COMMON");
/*
* acp7x_alloc_asp_payload - allocate a physically contiguous buffer below 4 GB.
*
* ASP accesses memory via the SoC fabric, bypassing the IOMMU, so the buffer
* must be below 4 GB and page_to_phys() must return the real CPU physical
* address. Use __GFP_DMA32/__GFP_DMA as hard zone constraints (not hints)
* to guarantee the physical address fits in 32 bits.
*/
static void *acp7x_alloc_asp_payload(struct snd_sof_dev *sdev, phys_addr_t *phys_out)
{
struct page *page;
void *vaddr;
page = alloc_page(GFP_KERNEL | __GFP_DMA32 | __GFP_ZERO);
if (!page)
page = alloc_page(GFP_KERNEL | __GFP_DMA | __GFP_ZERO);
if (!page) {
dev_err(sdev->dev, "ASP mbox: failed to allocate below-4GB payload page\n");
return NULL;
}
vaddr = page_address(page);
*phys_out = page_to_phys(page);
if (*phys_out > 0xFFFFFFFFULL) {
dev_err(sdev->dev, "ASP mbox: page at phys=0x%llx still exceeds 4 GB\n",
(u64)*phys_out);
__free_page(page);
return NULL;
}
return vaddr;
}
static void acp7x_free_asp_payload(void *vaddr)
{
if (vaddr)
__free_page(virt_to_page(vaddr));
}
int acp7x_query_asp_carveout(struct snd_sof_dev *sdev)
{
struct acp_dev_data *adata = sdev->pdata->hw_pdata;
struct asp_get_carveout_payload *co_payload;
phys_addr_t phys;
u32 group_bits, first_bit, count;
int ret = 0;
co_payload = acp7x_alloc_asp_payload(sdev, &phys);
if (!co_payload)
return -ENOMEM;
co_payload->cookie = ASP_MBOX_COOKIE;
/* Sentinel: ASP overwrites on success; 0xFFFFFFFF after the call means no carveout */
co_payload->carveout_size = 0xFFFFFFFF;
co_payload->mall_addr_valid = 0xFFFFFFFF;
co_payload->mall_valid = 0xFFFFFFFF;
adata->asp_mbox_buf = co_payload;
adata->asp_mbox_buf_phys = phys;
ret = acp7x_asp_send_cmd(sdev, ASP_MBOX_CMD_GET_CARVEOUT_ADDR);
dev_dbg(sdev->dev,
"GET_CARVEOUT response: status=0x%x addr=0x%llx size=0x%x mall_valid=0x%x mall_addr_valid=0x%x\n",
co_payload->status, co_payload->carveout_addr,
co_payload->carveout_size, co_payload->mall_valid,
co_payload->mall_addr_valid);
if (ret)
goto out_free;
if (co_payload->status || !co_payload->carveout_addr ||
!co_payload->carveout_size || co_payload->carveout_size == 0xFFFFFFFF) {
dev_warn(sdev->dev,
"ASP GET_CARVEOUT_ADDR: status=0x%x addr=0x%llx size=0x%x - no carveout\n",
co_payload->status, co_payload->carveout_addr,
co_payload->carveout_size);
ret = -ENODATA;
goto out_free;
}
if (!IS_ALIGNED(co_payload->carveout_addr, ACP7X_CARVEOUT_PAGE_SIZE) ||
co_payload->carveout_size != ACP7X_CARVEOUT_MAX_SIZE) {
dev_warn(sdev->dev,
"ASP carveout: unexpected base alignment or size (addr=0x%llx size=0x%x, expected 0x%x)\n",
co_payload->carveout_addr, co_payload->carveout_size,
ACP7X_CARVEOUT_MAX_SIZE);
ret = -ENODATA;
goto out_free;
}
/*
* Extract ATU group start and count from MallGroupEntries bits[15:0].
* Scan to find first set bit (start), then count
* contiguous set bits. Example: 0x7800 -> start=11, count=4.
* Defer committing asp_carveout_base/size until all validation passes
* so adata is never left with a non-zero base but zero group_count.
*/
group_bits = co_payload->mall_addr_valid & 0xFFFF;
first_bit = 0;
count = 0;
if (group_bits) {
first_bit = __ffs(group_bits);
while ((group_bits >> (first_bit + count)) & 1)
count++;
/* Validate contiguous run - reject non-contiguous masks */
if (group_bits != (((1u << count) - 1) << first_bit)) {
dev_warn(sdev->dev,
"ASP carveout: non-contiguous mall_addr_valid 0x%x unsupported\n",
group_bits);
ret = -ENODATA;
goto out_free;
}
}
if (!count) {
dev_warn(sdev->dev, "ASP carveout: no valid ATU groups in mall_addr_valid\n");
ret = -ENODATA;
goto out_free;
}
adata->asp_carveout_base = co_payload->carveout_addr;
adata->asp_carveout_size = co_payload->carveout_size;
adata->asp_carveout_group_start = first_bit;
adata->asp_carveout_group_count = count;
dev_dbg(sdev->dev, "ASP carveout: base=0x%llx size=0x%x grp_start=%u grp_count=%u\n",
adata->asp_carveout_base, adata->asp_carveout_size,
adata->asp_carveout_group_start, adata->asp_carveout_group_count);
out_free:
adata->asp_mbox_buf = NULL;
adata->asp_mbox_buf_phys = 0;
acp7x_free_asp_payload(co_payload);
return ret;
}
EXPORT_SYMBOL_NS(acp7x_query_asp_carveout, "SND_SOC_SOF_AMD_COMMON");
int acp7x_load_firmware_carveout(struct snd_sof_dev *sdev)
{
struct snd_sof_pdata *plat_data = sdev->pdata;
struct acp_dev_data *adata = plat_data->hw_pdata;
struct asp_validate_image_payload *vi_payload;
const char *fw_filename;
struct page *fw_page;
phys_addr_t vi_phys;
u64 dest;
u32 page_count, dma_size;
u32 size_fw_signed;
unsigned int order;
int ret;
/*
* Carveout query was already done in amd_sof_acp7x_probe() via
* acp7x_query_asp_carveout(). If ASP did not return a valid carveout
* address, fail immediately - no fallback to legacy path.
*/
/* Program PTEs for the entire carveout region before any DMA into it.
* acp_init() in resume clears the scratch SRAM so PTEs must be reprogrammed
* on every boot including D3->D0 resume.
*/
ret = acp7x_configure_carveout_pte(sdev);
if (ret)
return ret;
/*
* On D3->D0 resume the raw binary is already in the carveout region
* (placed by ASP during the previous VALIDATE_IMAGE call). Skip the
* filesystem load and VALIDATE_IMAGE - go directly to the data binary
* path. acp_dsp_pre_fw_run() will SHA-DMA from the preserved carveout
* address into DSP IRAM.
*
* On first boot fw_code_carveout_addr is 0 so the condition below is
* false and the full firmware load path executes.
*/
if (adata->fw_code_carveout_addr)
goto load_data_binary;
fw_filename = kasprintf(GFP_KERNEL, "%s/%s",
plat_data->fw_filename_prefix, adata->fw_code_bin);
if (!fw_filename)
return -ENOMEM;
/* Release any previously loaded firmware before requesting again */
if (sdev->basefw.fw) {
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
}
ret = request_firmware(&sdev->basefw.fw, fw_filename, sdev->dev);
kfree(fw_filename);
if (ret < 0) {
dev_err(sdev->dev, "request_firmware %s failed: %d\n",
adata->fw_code_bin, ret);
return ret;
}
page_count = PAGE_ALIGN(sdev->basefw.fw->size) >> PAGE_SHIFT;
dma_size = page_count * ACP_PAGE_SIZE;
/*
* Allocate the firmware staging buffer below 4 GB using alloc_pages so
* virt_to_phys() gives the real CPU physical address that ASP can read
* via the SoC fabric (bypassing the IOMMU). dma_alloc_coherent() gives
* an IOMMU-remapped DMA address which ASP cannot use.
*
* get_order() gives the smallest power-of-2 number of pages covering
* dma_size; alloc_pages() allocates that contiguous range.
*/
order = get_order(dma_size);
fw_page = alloc_pages(GFP_KERNEL | __GFP_DMA32 | __GFP_ZERO, order);
if (!fw_page)
fw_page = alloc_pages(GFP_KERNEL | __GFP_DMA | __GFP_ZERO, order);
if (!fw_page) {
dev_err(sdev->dev, "failed to allocate FW staging buffer\n");
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return -ENOMEM;
}
adata->bin_buf = page_address(fw_page);
adata->sha_dma_addr = page_to_phys(fw_page);
if (adata->sha_dma_addr > 0xFFFFFFFFULL) {
dev_err(sdev->dev,
"FW staging buffer at phys=0x%llx exceeds 4 GB\n",
(u64)adata->sha_dma_addr);
__free_pages(fw_page, order);
adata->bin_buf = NULL;
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return -ENOMEM;
}
memcpy(adata->bin_buf, sdev->basefw.fw->data, sdev->basefw.fw->size);
adata->fw_bin_size = sdev->basefw.fw->size;
if (adata->fw_bin_size <= ACP_IMAGE_HEADER_SIZE) {
dev_err(sdev->dev, "signed FW too small: %u\n", adata->fw_bin_size);
ret = -EINVAL;
goto free_bin;
}
/*
* SizeFWSigned (header[0x14]) is the size of the signed payload
* including the ASP signature trailer. ASP strips the ACP image
* header (0x100 bytes) but preserves the signature, so the raw
* binary deposited in carveout has size = SizeFWSigned and the
* SHA DMA length must equal SizeFWSigned.
*/
size_fw_signed = get_unaligned_le32(adata->bin_buf + ACP_IMAGE_HDR_SIZE_FW_SIGNED_OFF);
if (size_fw_signed <= ACP_ASP_SIGNATURE_LENGTH ||
size_fw_signed > adata->fw_bin_size - ACP_IMAGE_HEADER_SIZE) {
dev_err(sdev->dev,
"invalid SizeFWSigned 0x%x in carveout firmware header\n",
size_fw_signed);
ret = -EINVAL;
goto free_bin;
}
adata->fw_code_raw_size = size_fw_signed;
vi_payload = acp7x_alloc_asp_payload(sdev, &vi_phys);
if (!vi_payload) {
ret = -ENOMEM;
goto free_bin;
}
vi_payload->cookie = ASP_MBOX_COOKIE;
vi_payload->dest_offset = 0;
/*
* ASP bypasses the CPU IOMMU and accesses memory via the SoC
* fabric directly, so it must be given a real CPU physical
* address for the staging buffer (not an IOMMU/DMA-translated
* address). Use virt_to_phys(bin_buf) which returns the real
* CPU physical address, same as for mailbox payload buffers.
*/
vi_payload->src_phys_addr = (u64)virt_to_phys(adata->bin_buf);
vi_payload->fw_image_size = adata->fw_bin_size;
adata->asp_mbox_buf = vi_payload;
adata->asp_mbox_buf_phys = vi_phys;
dev_dbg(sdev->dev, "sending VALIDATE_IMAGE(0x01): src=0x%llx size=0x%x dest_offset=0x%llx phys=0x%llx\n",
vi_payload->src_phys_addr, vi_payload->fw_image_size,
vi_payload->dest_offset, (u64)adata->asp_mbox_buf_phys);
ret = acp7x_asp_send_cmd(sdev, ASP_MBOX_CMD_VALIDATE_IMAGE);
/* Read result before freeing payload */
if (!ret && !vi_payload->status) {
dest = vi_payload->carveout_dest_addr;
if (dest < adata->asp_carveout_base ||
dest - adata->asp_carveout_base + adata->fw_code_raw_size >
adata->asp_carveout_size) {
dev_err(sdev->dev,
"VALIDATE_IMAGE: dest 0x%llx outside carveout window\n",
dest);
ret = -EIO;
} else {
adata->fw_code_carveout_addr = dest;
}
} else if (!ret && vi_payload->status) {
ret = -EIO;
}
adata->asp_mbox_buf = NULL;
adata->asp_mbox_buf_phys = 0;
acp7x_free_asp_payload(vi_payload);
if (ret) {
if (ret == -EIO)
dev_err(sdev->dev, "ASP VALIDATE_IMAGE failed\n");
goto free_bin;
}
dev_dbg(sdev->dev, "ASP VALIDATE_IMAGE: raw binary at carveout 0x%llx size 0x%x\n",
adata->fw_code_carveout_addr, adata->fw_code_raw_size);
/* DDR staging buffer is no longer needed - raw binary is in carveout */
free_pages((unsigned long)adata->bin_buf, get_order(dma_size));
adata->bin_buf = NULL;
load_data_binary:
fw_filename = kasprintf(GFP_KERNEL, "%s/%s",
plat_data->fw_filename_prefix, adata->fw_data_bin);
if (!fw_filename) {
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return -ENOMEM;
}
ret = request_firmware(&adata->fw_dbin, fw_filename, sdev->dev);
kfree(fw_filename);
if (ret < 0) {
dev_err(sdev->dev, "request_firmware %s failed: %d\n",
adata->fw_data_bin, ret);
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return ret;
}
ret = snd_sof_dsp_block_write(sdev, SOF_FW_BLK_TYPE_SRAM, 0,
(void *)adata->fw_dbin->data,
adata->fw_dbin->size);
release_firmware(adata->fw_dbin);
adata->fw_dbin = NULL;
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return ret;
free_bin:
free_pages((unsigned long)adata->bin_buf, get_order(dma_size));
adata->bin_buf = NULL;
release_firmware(sdev->basefw.fw);
sdev->basefw.fw = NULL;
return ret;
}
EXPORT_SYMBOL_NS(acp7x_load_firmware_carveout, "SND_SOC_SOF_AMD_COMMON");