static int register_pmem(void)
{
int result;
struct audproc_buffer_data buffer;
result = get_pmem_file(acdb_data.pmem_fd, &acdb_data.paddr,
&acdb_data.kvaddr, &acdb_data.pmem_len,
&acdb_data.file);
if (result != 0) {
acdb_data.pmem_fd = 0;
pr_err("%s: Could not register PMEM!!!\n", __func__);
goto done;
}
pr_debug("AUDIO_REGISTER_PMEM done! paddr = 0x%lx, "
"kvaddr = 0x%lx, len = x%lx\n", acdb_data.paddr,
acdb_data.kvaddr, acdb_data.pmem_len);
get_audproc_buffer_data(&buffer);
result = adm_memory_map_regions(buffer.phys_addr, 0,
buffer.buf_size,
NUM_AUDPROC_BUFFERS);
if (result < 0)
pr_err("Audcal mmap did not work!\n");
goto done;
done:
return result;
}
int adm_map_rtac_block(struct rtac_cal_block_data *cal_block)
{
int result = 0;
pr_debug("%s\n", __func__);
if (cal_block == NULL) {
pr_err("%s: cal_block is NULL!\n",
__func__);
result = -EINVAL;
goto done;
}
if (cal_block->cal_data.paddr == 0) {
pr_debug("%s: No address to map!\n",
__func__);
result = -EINVAL;
goto done;
}
if (cal_block->map_data.map_size == 0) {
pr_debug("%s: map size is 0!\n",
__func__);
result = -EINVAL;
goto done;
}
/* valid port ID needed for callback use primary I2S */
atomic_set(&this_adm.mem_map_cal_index, ADM_RTAC);
result = adm_memory_map_regions(PRIMARY_I2S_RX,
&cal_block->cal_data.paddr, 0,
&cal_block->map_data.map_size, 1);
if (result < 0) {
pr_err("%s: RTAC mmap did not work! addr = 0x%x, size = %d\n",
__func__, cal_block->cal_data.paddr,
cal_block->map_data.map_size);
goto done;
}
cal_block->map_data.map_handle = atomic_read(
&this_adm.mem_map_cal_handles[ADM_RTAC]);
done:
return result;
}
static void send_adm_cal(int port_id, int path)
{
int result = 0;
s32 acdb_path;
struct acdb_cal_block aud_cal;
int flag = 0;
int index = afe_get_port_index(port_id);
pr_debug("%s\n", __func__);
/* Maps audio_dev_ctrl path definition to ACDB definition */
acdb_path = path - 1;
pr_debug("%s: Sending audproc cal\n", __func__);
get_audproc_cal(acdb_path, &aud_cal);
/* map & cache buffers used */
if (((mem_addr_audproc[acdb_path].cal_paddr != aud_cal.cal_paddr) &&
(aud_cal.cal_size > 0)) ||
(aud_cal.cal_size > mem_addr_audproc[acdb_path].cal_size)) {
if (mem_addr_audproc[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(
&mem_addr_audproc[acdb_path].cal_paddr,
&mem_addr_audproc[acdb_path].cal_size, 1);
result = adm_memory_map_regions(&aud_cal.cal_paddr, 0,
&aud_cal.cal_size, 1);
if (result < 0)
pr_err("ADM audproc mmap did not work! path = %d, "
"addr = 0x%x, size = %d\n", acdb_path,
aud_cal.cal_paddr, aud_cal.cal_size);
else
mem_addr_audproc[acdb_path] = aud_cal;
}
if (this_adm.prev_index != index) {
if (!send_adm_cal_block(port_id, &aud_cal))
pr_debug("%s: Audproc cal sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audproc cal not sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
this_adm.prev_index = index;
flag = 1;
}
pr_debug("%s: Sending audvol cal\n", __func__);
get_audvol_cal(acdb_path, &aud_cal);
/* map & cache buffers used */
if (((mem_addr_audvol[acdb_path].cal_paddr != aud_cal.cal_paddr) &&
(aud_cal.cal_size > 0)) ||
(aud_cal.cal_size > mem_addr_audvol[acdb_path].cal_size)) {
if (mem_addr_audvol[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(
&mem_addr_audvol[acdb_path].cal_paddr,
&mem_addr_audvol[acdb_path].cal_size, 1);
result = adm_memory_map_regions(&aud_cal.cal_paddr, 0,
&aud_cal.cal_size, 1);
if (result < 0)
pr_err("ADM audvol mmap did not work! path = %d, "
"addr = 0x%x, size = %d\n", acdb_path,
aud_cal.cal_paddr, aud_cal.cal_size);
else
mem_addr_audvol[acdb_path] = aud_cal;
}
if ((this_adm.prev_index == index) && (flag == 1)) {
if (!send_adm_cal_block(port_id, &aud_cal))
pr_debug("%s: Audvol cal sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audvol cal not sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
}
}
static void send_adm_cal(int port_id, int path)
{
int result = 0;
s32 acdb_path;
struct acdb_cal_block aud_cal;
pr_debug("%s\n", __func__);
acdb_path = path - 1;
pr_debug("%s: Sending audproc cal\n", __func__);
get_audproc_cal(acdb_path, &aud_cal);
if (((mem_addr_audproc[acdb_path].cal_paddr != aud_cal.cal_paddr) &&
(aud_cal.cal_size > 0)) ||
(aud_cal.cal_size > mem_addr_audproc[acdb_path].cal_size)) {
if (mem_addr_audproc[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(
&mem_addr_audproc[acdb_path].cal_paddr,
&mem_addr_audproc[acdb_path].cal_size, 1);
result = adm_memory_map_regions(&aud_cal.cal_paddr, 0,
&aud_cal.cal_size, 1);
if (result < 0)
pr_err("ADM audproc mmap did not work! path = %d, "
"addr = 0x%x, size = %d\n", acdb_path,
aud_cal.cal_paddr, aud_cal.cal_size);
else
mem_addr_audproc[acdb_path] = aud_cal;
}
if (!send_adm_cal_block(port_id, &aud_cal))
pr_debug("%s: Audproc cal sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audproc cal not sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
pr_debug("%s: Sending audvol cal\n", __func__);
get_audvol_cal(acdb_path, &aud_cal);
if (((mem_addr_audvol[acdb_path].cal_paddr != aud_cal.cal_paddr) &&
(aud_cal.cal_size > 0)) ||
(aud_cal.cal_size > mem_addr_audvol[acdb_path].cal_size)) {
if (mem_addr_audvol[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(
&mem_addr_audvol[acdb_path].cal_paddr,
&mem_addr_audvol[acdb_path].cal_size, 1);
result = adm_memory_map_regions(&aud_cal.cal_paddr, 0,
&aud_cal.cal_size, 1);
if (result < 0)
pr_err("ADM audvol mmap did not work! path = %d, "
"addr = 0x%x, size = %d\n", acdb_path,
aud_cal.cal_paddr, aud_cal.cal_size);
else
mem_addr_audvol[acdb_path] = aud_cal;
}
if (!send_adm_cal_block(port_id, &aud_cal))
pr_debug("%s: Audvol cal sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audvol cal not sent for port id: %d, path %d\n",
__func__, port_id, acdb_path);
}
static void send_adm_cal(int port_id, int path, int perf_mode)
{
int result = 0;
s32 acdb_path;
struct acdb_cal_block aud_cal;
int size = 4096;
pr_debug("%s\n", __func__);
/* Maps audio_dev_ctrl path definition to ACDB definition */
acdb_path = path - 1;
pr_debug("%s: Sending audproc cal\n", __func__);
get_audproc_cal(acdb_path, &aud_cal);
/* map & cache buffers used */
atomic_set(&this_adm.mem_map_cal_index, acdb_path);
if (((this_adm.mem_addr_audproc[acdb_path].cal_paddr !=
aud_cal.cal_paddr) && (aud_cal.cal_size > 0)) ||
(aud_cal.cal_size >
this_adm.mem_addr_audproc[acdb_path].cal_size)) {
if (this_adm.mem_addr_audproc[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(GLOBAL_CFG);
result = adm_memory_map_regions(GLOBAL_CFG,
&aud_cal.cal_paddr,
0, &size, 1);
if (result < 0) {
pr_err("ADM audproc mmap did not work! path = %d, addr = 0x%x, size = %d\n",
acdb_path, aud_cal.cal_paddr,
aud_cal.cal_size);
} else {
this_adm.mem_addr_audproc[acdb_path].cal_paddr =
aud_cal.cal_paddr;
this_adm.mem_addr_audproc[acdb_path].cal_size = size;
}
}
if (!send_adm_cal_block(port_id, &aud_cal, perf_mode))
pr_debug("%s: Audproc cal sent for port id: %#x, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audproc cal not sent for port id: %#x, path %d\n",
__func__, port_id, acdb_path);
pr_debug("%s: Sending audvol cal\n", __func__);
get_audvol_cal(acdb_path, &aud_cal);
/* map & cache buffers used */
atomic_set(&this_adm.mem_map_cal_index,
(acdb_path + MAX_AUDPROC_TYPES));
if (((this_adm.mem_addr_audvol[acdb_path].cal_paddr !=
aud_cal.cal_paddr) && (aud_cal.cal_size > 0)) ||
(aud_cal.cal_size >
this_adm.mem_addr_audvol[acdb_path].cal_size)) {
if (this_adm.mem_addr_audvol[acdb_path].cal_paddr != 0)
adm_memory_unmap_regions(GLOBAL_CFG);
result = adm_memory_map_regions(GLOBAL_CFG, &aud_cal.cal_paddr,
0, &size, 1);
if (result < 0) {
pr_err("ADM audvol mmap did not work! path = %d, addr = 0x%x, size = %d\n",
acdb_path, aud_cal.cal_paddr,
aud_cal.cal_size);
} else {
this_adm.mem_addr_audvol[acdb_path].cal_paddr =
aud_cal.cal_paddr;
this_adm.mem_addr_audvol[acdb_path].cal_size = size;
}
}
if (!send_adm_cal_block(port_id, &aud_cal, perf_mode))
pr_debug("%s: Audvol cal sent for port id: %#x, path %d\n",
__func__, port_id, acdb_path);
else
pr_debug("%s: Audvol cal not sent for port id: %#x, path %d\n",
__func__, port_id, acdb_path);
}
void send_adm_custom_topology(int port_id)
{
struct acdb_cal_block cal_block;
struct cmd_set_topologies adm_top;
int index;
int result;
int size = 4096;
get_adm_custom_topology(&cal_block);
if (cal_block.cal_size == 0) {
pr_debug("%s: no cal to send addr= 0x%x\n",
__func__, cal_block.cal_paddr);
goto done;
}
index = afe_get_port_index(port_id);
if (index < 0 || index >= AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d portid %#x\n",
__func__, index, port_id);
goto done;
}
if (this_adm.set_custom_topology) {
/* specific index 4 for adm topology memory */
atomic_set(&this_adm.mem_map_cal_index, ADM_CUSTOM_TOP_CAL);
/* Only call this once */
this_adm.set_custom_topology = 0;
result = adm_memory_map_regions(GLOBAL_CFG,
&cal_block.cal_paddr, 0, &size, 1);
if (result < 0) {
pr_err("%s: mmap did not work! addr = 0x%x, size = %d\n",
__func__, cal_block.cal_paddr,
cal_block.cal_size);
goto done;
}
}
adm_top.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(20), APR_PKT_VER);
adm_top.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
sizeof(adm_top));
adm_top.hdr.src_svc = APR_SVC_ADM;
adm_top.hdr.src_domain = APR_DOMAIN_APPS;
adm_top.hdr.src_port = port_id;
adm_top.hdr.dest_svc = APR_SVC_ADM;
adm_top.hdr.dest_domain = APR_DOMAIN_ADSP;
adm_top.hdr.dest_port = atomic_read(&this_adm.copp_id[index]);
adm_top.hdr.token = port_id;
adm_top.hdr.opcode = ADM_CMD_ADD_TOPOLOGIES;
adm_top.payload_addr_lsw = cal_block.cal_paddr;
adm_top.payload_addr_msw = 0;
adm_top.mem_map_handle =
atomic_read(&this_adm.mem_map_cal_handles[ADM_CUSTOM_TOP_CAL]);
adm_top.payload_size = cal_block.cal_size;
atomic_set(&this_adm.copp_stat[index], 0);
pr_debug("%s: Sending ADM_CMD_ADD_TOPOLOGIES payload = 0x%x, size = %d\n",
__func__, adm_top.payload_addr_lsw,
adm_top.payload_size);
result = apr_send_pkt(this_adm.apr, (uint32_t *)&adm_top);
if (result < 0) {
pr_err("%s: Set topologies failed port = 0x%x payload = 0x%x\n",
__func__, port_id, cal_block.cal_paddr);
goto done;
}
/* Wait for the callback */
result = wait_event_timeout(this_adm.wait[index],
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!result) {
pr_err("%s: Set topologies timed out port = 0x%x, payload = 0x%x\n",
__func__, port_id, cal_block.cal_paddr);
goto done;
}
done:
return;
}
