#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"
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;
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;
}
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;
}
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;
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");
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;
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;
}
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++;
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;
ret = acp7x_configure_carveout_pte(sdev);
if (ret)
return ret;
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;
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;
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;
}
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;
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);
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);
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"