From 08bb73698a5af9f4e6fc33cefb97ae7b58401054 Mon Sep 17 00:00:00 2001 From: Banajit Goswami Date: Fri, 3 Nov 2017 22:48:23 -0700 Subject: [PATCH] dsp: update MSM Audio ION wrappers to align with upstream Between Linux-4.9 and Linux-4.14, upstream has updated the ION APIs significantly to make ION ready to bring out of staging folder. This has changed the way ION and dma_buf APIs used to work together for allocating, mapping and deallocating ION buffers. Update MSM Audio ION wrapper functions used by audio drivers to reflect these ION API changes as per upstream ION. Change-Id: I63097e147a397aa3a538f69ac88b6fb10871c3dc Signed-off-by: Banajit Goswami --- asoc/msm-pcm-host-voice-v2.c | 33 +- asoc/msm-pcm-q6-noirq.c | 11 +- dsp/audio_cal_utils.c | 20 +- dsp/codecs/audio_utils_aio.c | 31 +- dsp/codecs/audio_utils_aio.h | 5 +- dsp/msm-dts-srs-tm-config.c | 16 +- dsp/msm_audio_ion.c | 1010 ++++++++++++++------------------- dsp/q6adm.c | 32 +- dsp/q6afe.c | 19 +- dsp/q6asm.c | 64 +-- dsp/q6lsm.c | 23 +- dsp/q6usm.c | 21 +- dsp/q6usm.h | 14 +- dsp/q6voice.c | 106 ++-- dsp/rtac.c | 30 +- include/dsp/audio_cal_utils.h | 5 +- include/dsp/msm_audio_ion.h | 30 +- include/dsp/q6afe-v2.h | 5 +- include/dsp/q6asm-v2.h | 5 +- include/dsp/q6lsm.h | 8 +- include/dsp/q6voice.h | 17 +- include/dsp/rtac.h | 5 +- 22 files changed, 592 insertions(+), 918 deletions(-) diff --git a/asoc/msm-pcm-host-voice-v2.c b/asoc/msm-pcm-host-voice-v2.c index fd771df5d3d4..440228e0689d 100644 --- a/asoc/msm-pcm-host-voice-v2.c +++ b/asoc/msm-pcm-host-voice-v2.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -119,7 +119,7 @@ struct session { struct tap_point rx_tap_point; phys_addr_t sess_paddr; void *sess_kvaddr; - struct ion_handle *ion_handle; + struct dma_buf *dma_buf; struct mem_map_table tp_mem_table; }; @@ -145,7 +145,6 @@ struct hpcm_drv { struct mutex lock; struct session session[MAX_SESSION]; struct mixer_conf mixer_conf; - struct ion_client *ion_client; struct start_cmd start_cmd; }; @@ -452,19 +451,12 @@ static void hpcm_free_allocated_mem(struct hpcm_drv *prtd) paddr = sess->sess_paddr; if (paddr) { - msm_audio_ion_free(prtd->ion_client, sess->ion_handle); - prtd->ion_client = NULL; - sess->ion_handle = NULL; - msm_audio_ion_free(sess->tp_mem_table.client, - sess->tp_mem_table.handle); - sess->tp_mem_table.client = NULL; - sess->tp_mem_table.handle = NULL; + msm_audio_ion_free(sess->dma_buf); + sess->dma_buf = NULL; + msm_audio_ion_free(sess->tp_mem_table.dma_buf); + sess->tp_mem_table.dma_buf = NULL; sess->sess_paddr = 0; sess->sess_kvaddr = 0; - sess->ion_handle = 0; - prtd->ion_client = 0; - sess->tp_mem_table.client = 0; - sess->tp_mem_table.handle = 0; txtp->capture_dai_data.vocpcm_ion_buffer.paddr = 0; txtp->capture_dai_data.vocpcm_ion_buffer.kvaddr = 0; @@ -531,9 +523,7 @@ static int hpcm_allocate_shared_memory(struct hpcm_drv *prtd) txtp = &sess->tx_tap_point; rxtp = &sess->rx_tap_point; - result = msm_audio_ion_alloc("host_pcm_buffer", - &prtd->ion_client, - &sess->ion_handle, + result = msm_audio_ion_alloc(&sess->dma_buf, VHPCM_BLOCK_SIZE, &sess->sess_paddr, &mem_len, @@ -549,9 +539,7 @@ static int hpcm_allocate_shared_memory(struct hpcm_drv *prtd) pr_debug("%s: Host PCM memory block allocated\n", __func__); /* Allocate mem_map_table for tap point */ - result = msm_audio_ion_alloc("host_pcm_table", - &sess->tp_mem_table.client, - &sess->tp_mem_table.handle, + result = msm_audio_ion_alloc(&sess->tp_mem_table.dma_buf, sizeof(struct vss_imemory_table_t), &sess->tp_mem_table.phys, &len, @@ -560,9 +548,8 @@ static int hpcm_allocate_shared_memory(struct hpcm_drv *prtd) if (result) { pr_err("%s: msm_audio_ion_alloc error, rc = %d\n", __func__, result); - msm_audio_ion_free(prtd->ion_client, sess->ion_handle); - prtd->ion_client = NULL; - sess->ion_handle = NULL; + msm_audio_ion_free(sess->dma_buf); + sess->dma_buf = NULL; sess->sess_paddr = 0; sess->sess_kvaddr = 0; ret = -ENOMEM; diff --git a/asoc/msm-pcm-q6-noirq.c b/asoc/msm-pcm-q6-noirq.c index dbc6d33a65be..34dc4bbdd118 100644 --- a/asoc/msm-pcm-q6-noirq.c +++ b/asoc/msm-pcm-q6-noirq.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2016-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -20,6 +20,7 @@ #include #include #include +#include #include #include @@ -451,7 +452,13 @@ static int msm_pcm_mmap_fd(struct snd_pcm_substream *substream, apd = prtd->audio_client->port; ab = &(apd[dir].buf[0]); - mmap_fd->fd = ion_share_dma_buf_fd(ab->client, ab->handle); + /* + * Passing O_CLOEXEC as flag passed to fd, to be in sync with + * previous implimentation. + * This was the flag used by previous internal wrapper API, which + * used to call dma_buf_fd internally. + */ + mmap_fd->fd = dma_buf_fd(ab->dma_buf, O_CLOEXEC); if (mmap_fd->fd >= 0) { mmap_fd->dir = dir; mmap_fd->actual_size = ab->actual_size; diff --git a/dsp/audio_cal_utils.c b/dsp/audio_cal_utils.c index ad1dc3d35ce3..95794796c4f1 100644 --- a/dsp/audio_cal_utils.c +++ b/dsp/audio_cal_utils.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -442,11 +442,9 @@ static void delete_cal_block(struct cal_block_data *cal_block) cal_block->client_info = NULL; kfree(cal_block->cal_info); cal_block->cal_info = NULL; - if (cal_block->map_data.ion_client != NULL) { - msm_audio_ion_free(cal_block->map_data.ion_client, - cal_block->map_data.ion_handle); - cal_block->map_data.ion_client = NULL; - cal_block->map_data.ion_handle = NULL; + if (cal_block->map_data.dma_buf != NULL) { + msm_audio_ion_free(cal_block->map_data.dma_buf); + cal_block->map_data.dma_buf = NULL; } kfree(cal_block); done: @@ -604,9 +602,7 @@ static int cal_block_ion_alloc(struct cal_block_data *cal_block) goto done; } - ret = msm_audio_ion_import("audio_cal_client", - &cal_block->map_data.ion_client, - &cal_block->map_data.ion_handle, + ret = msm_audio_ion_import(&cal_block->map_data.dma_buf, cal_block->map_data.ion_map_handle, NULL, 0, &cal_block->cal_data.paddr, @@ -736,10 +732,8 @@ static int realloc_memory(struct cal_block_data *cal_block) { int ret = 0; - msm_audio_ion_free(cal_block->map_data.ion_client, - cal_block->map_data.ion_handle); - cal_block->map_data.ion_client = NULL; - cal_block->map_data.ion_handle = NULL; + msm_audio_ion_free(cal_block->map_data.dma_buf); + cal_block->map_data.dma_buf = NULL; cal_block->cal_data.size = 0; ret = cal_block_ion_alloc(cal_block); diff --git a/dsp/codecs/audio_utils_aio.c b/dsp/codecs/audio_utils_aio.c index e8f22e79f8cb..7f332f4f7aa6 100644 --- a/dsp/codecs/audio_utils_aio.c +++ b/dsp/codecs/audio_utils_aio.c @@ -1,6 +1,6 @@ /* Copyright (C) 2008 Google, Inc. * Copyright (C) 2008 HTC Corporation - * Copyright (c) 2009-2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2009-2018, The Linux Foundation. All rights reserved. * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and @@ -420,7 +420,7 @@ void audio_aio_reset_ion_region(struct q6audio_aio *audio) list_for_each_safe(ptr, next, &audio->ion_region_queue) { region = list_entry(ptr, struct audio_aio_ion_region, list); list_del(®ion->list); - msm_audio_ion_free_legacy(audio->client, region->handle); + msm_audio_ion_free(region->dma_buf); kfree(region); } } @@ -614,7 +614,6 @@ int audio_aio_release(struct inode *inode, struct file *file) audio_aio_disable(audio); audio_aio_unmap_ion_region(audio); audio_aio_reset_ion_region(audio); - msm_audio_ion_client_destroy(audio->client); audio->event_abort = 1; wake_up(&audio->event_wait); audio_aio_reset_event_queue(audio); @@ -960,11 +959,11 @@ static int audio_aio_ion_check(struct q6audio_aio *audio, static int audio_aio_ion_add(struct q6audio_aio *audio, struct msm_audio_ion_info *info) { - ion_phys_addr_t paddr = 0; + dma_addr_t paddr = 0; size_t len = 0; struct audio_aio_ion_region *region; int rc = -EINVAL; - struct ion_handle *handle = NULL; + struct dma_buf *dma_buf = NULL; unsigned long ionflag; void *kvaddr = NULL; @@ -976,8 +975,7 @@ static int audio_aio_ion_add(struct q6audio_aio *audio, goto end; } - rc = msm_audio_ion_import_legacy("Audio_Dec_Client", audio->client, - &handle, info->fd, &ionflag, + rc = msm_audio_ion_import(&dma_buf, info->fd, &ionflag, 0, &paddr, &len, &kvaddr); if (rc) { pr_err("%s: msm audio ion alloc failed\n", __func__); @@ -990,7 +988,7 @@ static int audio_aio_ion_add(struct q6audio_aio *audio, goto ion_error; } - region->handle = handle; + region->dma_buf = dma_buf; region->vaddr = info->vaddr; region->fd = info->fd; region->paddr = paddr; @@ -1012,7 +1010,7 @@ static int audio_aio_ion_add(struct q6audio_aio *audio, mmap_error: list_del(®ion->list); ion_error: - msm_audio_ion_free_legacy(audio->client, handle); + msm_audio_ion_free(dma_buf); import_error: kfree(region); end: @@ -1049,8 +1047,7 @@ static int audio_aio_ion_remove(struct q6audio_aio *audio, __func__, audio); list_del(®ion->list); - msm_audio_ion_free_legacy(audio->client, - region->handle); + msm_audio_ion_free(region->dma_buf); kfree(region); rc = 0; break; @@ -1378,22 +1375,12 @@ int audio_aio_open(struct q6audio_aio *audio, struct file *file) goto cleanup; } } - audio->client = msm_audio_ion_client_create("Audio_Dec_Client"); - if (IS_ERR_OR_NULL(audio->client)) { - pr_err("Unable to create ION client\n"); - rc = -ENOMEM; - goto cleanup; - } - pr_debug("Ion client create in audio_aio_open %pK", audio->client); rc = register_volume_listener(audio); if (rc < 0) - goto ion_cleanup; + goto cleanup; return 0; -ion_cleanup: - msm_audio_ion_client_destroy(audio->client); - audio->client = NULL; cleanup: list_for_each_safe(ptr, next, &audio->free_event_queue) { e_node = list_first_entry(&audio->free_event_queue, diff --git a/dsp/codecs/audio_utils_aio.h b/dsp/codecs/audio_utils_aio.h index e44f9d9c642a..1993f6047ef1 100644 --- a/dsp/codecs/audio_utils_aio.h +++ b/dsp/codecs/audio_utils_aio.h @@ -1,6 +1,6 @@ /* Copyright (C) 2008 Google, Inc. * Copyright (C) 2008 HTC Corporation - * Copyright (c) 2009-2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2009-2018, The Linux Foundation. All rights reserved. * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and @@ -119,7 +119,7 @@ struct ws_mgr { struct audio_aio_ion_region { struct list_head list; - struct ion_handle *handle; + struct dma_buf *dma_buf; int fd; void *vaddr; phys_addr_t paddr; @@ -182,7 +182,6 @@ struct q6audio_aio { struct list_head free_event_queue; struct list_head event_queue; struct list_head ion_region_queue; /* protected by lock */ - struct ion_client *client; struct audio_aio_drv_operations drv_ops; union msm_audio_event_payload eos_write_payload; uint32_t device_events; diff --git a/dsp/msm-dts-srs-tm-config.c b/dsp/msm-dts-srs-tm-config.c index cd3da4d642d9..fff98b57287c 100644 --- a/dsp/msm-dts-srs-tm-config.c +++ b/dsp/msm-dts-srs-tm-config.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2014, 2016-2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2014, 2016-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -25,8 +25,7 @@ static int srs_port_id[AFE_MAX_PORTS] = {-1}; static int srs_copp_idx[AFE_MAX_PORTS] = {-1}; static union srs_trumedia_params_u msm_srs_trumedia_params; -static struct ion_client *ion_client; -static struct ion_handle *ion_handle; +struct dma_buf *dma_buf; static struct param_outband po; static atomic_t ref_cnt; #define ION_MEM_SIZE (8 * 1024) @@ -299,13 +298,13 @@ static int reg_ion_mem(void) { int rc; - rc = msm_audio_ion_alloc("SRS_TRUMEDIA", &ion_client, &ion_handle, - ION_MEM_SIZE, &po.paddr, (size_t *)&po.size, + rc = msm_audio_ion_alloc(&dma_buf, ION_MEM_SIZE, + &po.paddr, (size_t *)&po.size, &po.kvaddr); if (rc != 0) pr_err("%s: failed to allocate memory.\n", __func__); - pr_debug("%s: exited ion_client = %pK, ion_handle = %pK, phys_addr = %lu, length = %d, vaddr = %pK, rc = 0x%x\n", - __func__, ion_client, ion_handle, (long)po.paddr, + pr_debug("%s: exited dma_buf = %pK, phys_addr = %lu, length = %d, vaddr = %pK, rc = 0x%x\n", + __func__, dma_buf, (long)po.paddr, (unsigned int)po.size, po.kvaddr, rc); return rc; } @@ -323,7 +322,8 @@ void msm_dts_srs_tm_ion_memmap(struct param_outband *po_) static void unreg_ion_mem(void) { - msm_audio_ion_free(ion_client, ion_handle); + msm_audio_ion_free(dma_buf); + dma_buf = NULL; po.kvaddr = NULL; po.paddr = 0; po.size = 0; diff --git a/dsp/msm_audio_ion.c b/dsp/msm_audio_ion.c index 113829057aff..c0879218515b 100644 --- a/dsp/msm_audio_ion.c +++ b/dsp/msm_audio_ion.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -23,9 +23,10 @@ #include #include #include -#include #include #include +#include +#include #include #include @@ -40,7 +41,6 @@ #define MSM_AUDIO_SMMU_SID_OFFSET 32 struct msm_audio_ion_private { - bool smmu_enabled; bool audioheap_enabled; struct device *cb_dev; struct dma_iommu_mapping *mapping; @@ -52,9 +52,8 @@ struct msm_audio_ion_private { }; struct msm_audio_alloc_data { - struct ion_client *client; - struct ion_handle *handle; size_t len; + void *vaddr; struct dma_buf *dma_buf; struct dma_buf_attachment *attach; struct sg_table *table; @@ -63,17 +62,6 @@ struct msm_audio_alloc_data { static struct msm_audio_ion_private msm_audio_ion_data = {0,}; -static int msm_audio_ion_get_phys(struct ion_client *client, - struct ion_handle *handle, - ion_phys_addr_t *addr, size_t *len); - -static int msm_audio_dma_buf_map(struct ion_client *client, - struct ion_handle *handle, - ion_phys_addr_t *addr, size_t *len); - -static int msm_audio_dma_buf_unmap(struct ion_client *client, - struct ion_handle *handle); - static void msm_audio_ion_add_allocation( struct msm_audio_ion_private *msm_audio_ion_data, struct msm_audio_alloc_data *alloc_data) @@ -89,196 +77,408 @@ static void msm_audio_ion_add_allocation( mutex_unlock(&(msm_audio_ion_data->list_mutex)); } +static int msm_audio_dma_buf_map(struct dma_buf *dma_buf, + dma_addr_t *addr, size_t *len) +{ + + struct msm_audio_alloc_data *alloc_data; + struct device *cb_dev; + int rc = 0; + + cb_dev = msm_audio_ion_data.cb_dev; + + /* Data required per buffer mapping */ + alloc_data = kzalloc(sizeof(*alloc_data), GFP_KERNEL); + if (!alloc_data) + return -ENOMEM; + + alloc_data->dma_buf = dma_buf; + alloc_data->len = dma_buf->size; + *len = dma_buf->size; + + /* Attach the dma_buf to context bank device */ + alloc_data->attach = dma_buf_attach(alloc_data->dma_buf, + cb_dev); + if (IS_ERR(alloc_data->attach)) { + rc = PTR_ERR(alloc_data->attach); + dev_err(cb_dev, + "%s: Fail to attach dma_buf to CB, rc = %d\n", + __func__, rc); + goto err_attach; + } + + /* + * Get the scatter-gather list. + * There is no info as this is a write buffer or + * read buffer, hence the request is bi-directional + * to accommodate both read and write mappings. + */ + alloc_data->table = dma_buf_map_attachment(alloc_data->attach, + DMA_BIDIRECTIONAL); + if (IS_ERR(alloc_data->table)) { + rc = PTR_ERR(alloc_data->table); + dev_err(cb_dev, + "%s: Fail to map attachment, rc = %d\n", + __func__, rc); + goto err_map_attach; + } + + /* physical address from mapping */ + *addr = MSM_AUDIO_ION_PHYS_ADDR(alloc_data); + + msm_audio_ion_add_allocation(&msm_audio_ion_data, + alloc_data); + return rc; + +err_map_attach: + dma_buf_detach(alloc_data->dma_buf, + alloc_data->attach); +err_attach: + kfree(alloc_data); + + return rc; +} + +static int msm_audio_dma_buf_unmap(struct dma_buf *dma_buf) +{ + int rc = 0; + struct msm_audio_alloc_data *alloc_data = NULL; + struct list_head *ptr, *next; + struct device *cb_dev = msm_audio_ion_data.cb_dev; + bool found = false; + + /* + * Though list_for_each_safe is delete safe, lock + * should be explicitly acquired to avoid race condition + * on adding elements to the list. + */ + mutex_lock(&(msm_audio_ion_data.list_mutex)); + list_for_each_safe(ptr, next, + &(msm_audio_ion_data.alloc_list)) { + + alloc_data = list_entry(ptr, struct msm_audio_alloc_data, + list); + + if (alloc_data->dma_buf == dma_buf) { + found = true; + dma_buf_unmap_attachment(alloc_data->attach, + alloc_data->table, + DMA_BIDIRECTIONAL); + + dma_buf_detach(alloc_data->dma_buf, + alloc_data->attach); + + dma_buf_put(alloc_data->dma_buf); + + list_del(&(alloc_data->list)); + kfree(alloc_data); + break; + } + } + mutex_unlock(&(msm_audio_ion_data.list_mutex)); + + if (!found) { + dev_err(cb_dev, + "%s: cannot find allocation, dma_buf %pK", + __func__, dma_buf); + rc = -EINVAL; + } + + return rc; +} + +static int msm_audio_ion_get_phys(struct dma_buf *dma_buf, + dma_addr_t *addr, size_t *len) +{ + int rc = 0; + + rc = msm_audio_dma_buf_map(dma_buf, addr, len); + if (rc) { + pr_err("%s: failed to map DMA buf, err = %d\n", + __func__, rc); + goto err; + } + /* Append the SMMU SID information to the IOVA address */ + *addr |= msm_audio_ion_data.smmu_sid_bits; + + pr_debug("phys=%pK, len=%zd, rc=%d\n", &(*addr), *len, rc); +err: + return rc; +} + +static void *msm_audio_ion_map_kernel(struct dma_buf *dma_buf) +{ + int i = 0; + int rc = 0; + void *addr = NULL; + unsigned int pg_cnt = 0; + struct msm_audio_alloc_data *alloc_data = NULL; + + rc = dma_buf_begin_cpu_access(dma_buf, DMA_BIDIRECTIONAL); + if (rc) { + pr_err("%s: kmap dma_buf_begin_cpu_access fail\n", __func__); + goto exit; + } + + pg_cnt = dma_buf->size / PAGE_SIZE; + if (dma_buf->size % PAGE_SIZE) + pg_cnt++; + + if (pg_cnt == 0) { + pr_err("%s: Page count is NULL\n", __func__); + goto exit; + } + + /* Map the first page, and store the address to addr */ + addr = dma_buf_kmap(dma_buf, 0); + if (!addr) { + pr_err("%s: mapping kernel buffer failed for page 0\n", + __func__); + goto exit; + } + /* Map remaining pages */ + for (i = 1; i < pg_cnt; i++) { + if (!dma_buf_kmap(dma_buf, i)) { + pr_err("%s: mapping kernel buffer failed for page %d\n", + __func__, i); + goto err; + } + } + + /* + * TBD: remove the below section once new API + * for mapping kernel virtual address is available. + */ + mutex_lock(&(msm_audio_ion_data.list_mutex)); + list_for_each_entry(alloc_data, &(msm_audio_ion_data.alloc_list), + list) { + if (alloc_data->dma_buf == dma_buf) { + alloc_data->vaddr = addr; + break; + } + } + mutex_unlock(&(msm_audio_ion_data.list_mutex)); + + return addr; + +err: + for (; i > 0; i--) + dma_buf_kunmap(dma_buf, i - 1, addr); + addr = NULL; +exit: + return addr; +} + +static void msm_audio_ion_unmap_kernel(struct dma_buf *dma_buf) +{ + int i, rc = 0; + unsigned int pg_cnt = 0; + void *vaddr = NULL; + struct msm_audio_alloc_data *alloc_data = NULL; + struct device *cb_dev = msm_audio_ion_data.cb_dev; + + /* + * TBD: remove the below section once new API + * for unmapping kernel virtual address is available. + */ + mutex_lock(&(msm_audio_ion_data.list_mutex)); + list_for_each_entry(alloc_data, &(msm_audio_ion_data.alloc_list), + list) { + if (alloc_data->dma_buf == dma_buf) { + vaddr = alloc_data->vaddr; + break; + } + } + mutex_unlock(&(msm_audio_ion_data.list_mutex)); + + if (!vaddr) { + dev_err(cb_dev, + "%s: cannot find allocation for dma_buf %pK", + __func__, dma_buf); + goto err; + } + + pg_cnt = dma_buf->size / PAGE_SIZE; + if (dma_buf->size % PAGE_SIZE) + pg_cnt++; + + for (i = 0; i < pg_cnt; i++) + dma_buf_kunmap(dma_buf, i, vaddr); + + rc = dma_buf_end_cpu_access(dma_buf, DMA_BIDIRECTIONAL); + if (rc) { + dev_err(cb_dev, "%s: kmap dma_buf_end_cpu_access fail\n", + __func__); + goto err; + } + +err: + return; +} + +static int msm_audio_ion_map_buf(struct dma_buf *dma_buf, dma_addr_t *paddr, + size_t *plen, void *vaddr) +{ + int rc = 0; + + rc = msm_audio_ion_get_phys(dma_buf, paddr, plen); + if (rc) { + pr_err("%s: ION Get Physical for AUDIO failed, rc = %d\n", + __func__, rc); + goto err; + } + + vaddr = msm_audio_ion_map_kernel(dma_buf); + if (IS_ERR_OR_NULL((void *)vaddr)) { + pr_err("%s: ION memory mapping for AUDIO failed\n", __func__); + rc = -ENOMEM; + goto err; + } + +err: + return rc; +} + /** * msm_audio_ion_alloc - * Allocs ION memory for given client name * - * @name: Name of audio ION client - * @client: ION client to be assigned - * @handle: ION handle to be assigned + * @dma_buf: dma_buf for the ION memory * @bufsz: buffer size * @paddr: Physical address to be assigned with allocated region - * @pa_len: length of allocated region to be assigned + * @plen: length of allocated region to be assigned * vaddr: virtual address to be assigned * * Returns 0 on success or error on failure */ -int msm_audio_ion_alloc(const char *name, struct ion_client **client, - struct ion_handle **handle, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr) +int msm_audio_ion_alloc(struct dma_buf **dma_buf, size_t bufsz, + dma_addr_t *paddr, size_t *plen, void **vaddr) { int rc = -EINVAL; unsigned long err_ion_ptr = 0; - if ((msm_audio_ion_data.smmu_enabled == true) && - !(msm_audio_ion_data.device_status & MSM_AUDIO_ION_PROBED)) { + if (!(msm_audio_ion_data.device_status & MSM_AUDIO_ION_PROBED)) { pr_debug("%s:probe is not done, deferred\n", __func__); return -EPROBE_DEFER; } - if (!name || !client || !handle || !paddr || !vaddr - || !bufsz || !pa_len) { + if (!dma_buf || !paddr || !vaddr || !bufsz || !plen) { pr_err("%s: Invalid params\n", __func__); return -EINVAL; } - *client = msm_audio_ion_client_create(name); - if (IS_ERR_OR_NULL((void *)(*client))) { - pr_err("%s: ION create client for AUDIO failed\n", __func__); + + *dma_buf = ion_alloc(bufsz, ION_HEAP(ION_SYSTEM_HEAP_ID), 0); + if (IS_ERR_OR_NULL((void *)(*dma_buf))) { + if (IS_ERR((void *)(*dma_buf))) + err_ion_ptr = PTR_ERR((int *)(*dma_buf)); + pr_err("%s:ION alloc fail err ptr=%ld\n", + __func__, err_ion_ptr); + rc = -ENOMEM; goto err; } - *handle = ion_alloc(*client, bufsz, SZ_4K, - ION_HEAP(ION_AUDIO_HEAP_ID), 0); - if (IS_ERR_OR_NULL((void *) (*handle))) { - if (msm_audio_ion_data.smmu_enabled == true) { - pr_debug("system heap is used"); - msm_audio_ion_data.audioheap_enabled = 0; - *handle = ion_alloc(*client, bufsz, SZ_4K, - ION_HEAP(ION_SYSTEM_HEAP_ID), 0); - } - if (IS_ERR_OR_NULL((void *) (*handle))) { - if (IS_ERR((void *)(*handle))) - err_ion_ptr = PTR_ERR((int *)(*handle)); - pr_err("%s:ION alloc fail err ptr=%ld, smmu_enabled=%d\n", - __func__, err_ion_ptr, msm_audio_ion_data.smmu_enabled); - rc = -ENOMEM; - goto err_ion_client; - } - } else { - pr_debug("audio heap is used"); - msm_audio_ion_data.audioheap_enabled = 1; - } - - rc = msm_audio_ion_get_phys(*client, *handle, paddr, pa_len); + rc = msm_audio_ion_map_buf(*dma_buf, paddr, plen, *vaddr); if (rc) { - pr_err("%s: ION Get Physical for AUDIO failed, rc = %d\n", - __func__, rc); - goto err_ion_handle; - } - - *vaddr = ion_map_kernel(*client, *handle); - if (IS_ERR_OR_NULL((void *)*vaddr)) { - pr_err("%s: ION memory mapping for AUDIO failed\n", __func__); - goto err_ion_handle; + pr_err("%s: failed to map ION buf, rc = %d\n", __func__, rc); + goto err_dma_buf; } pr_debug("%s: mapped address = %pK, size=%zd\n", __func__, *vaddr, bufsz); - if (bufsz != 0) { - pr_debug("%s: memset to 0 %pK %zd\n", __func__, *vaddr, bufsz); - memset((void *)*vaddr, 0, bufsz); - } + memset((void *)*vaddr, 0, bufsz); return rc; -err_ion_handle: - ion_free(*client, *handle); -err_ion_client: - msm_audio_ion_client_destroy(*client); - *handle = NULL; - *client = NULL; +err_dma_buf: + dma_buf_put(*dma_buf); err: return rc; } EXPORT_SYMBOL(msm_audio_ion_alloc); -int msm_audio_ion_import(const char *name, struct ion_client **client, - struct ion_handle **handle, int fd, +/** + * msm_audio_ion_import- + * Import ION buffer with given file descriptor + * + * @dma_buf: dma_buf for the ION memory + * @fd: file descriptor for the ION memory + * @ionflag: flags associated with ION buffer + * @bufsz: buffer size + * @paddr: Physical address to be assigned with allocated region + * @plen: length of allocated region to be assigned + * vaddr: virtual address to be assigned + * + * Returns 0 on success or error on failure + */ +int msm_audio_ion_import(struct dma_buf **dma_buf, int fd, unsigned long *ionflag, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr) + dma_addr_t *paddr, size_t *plen, void **vaddr) { int rc = 0; - if ((msm_audio_ion_data.smmu_enabled == true) && - !(msm_audio_ion_data.device_status & MSM_AUDIO_ION_PROBED)) { + if (!(msm_audio_ion_data.device_status & MSM_AUDIO_ION_PROBED)) { pr_debug("%s:probe is not done, deferred\n", __func__); return -EPROBE_DEFER; } - if (!name || !client || !handle || !paddr || !vaddr || !pa_len) { + if (!dma_buf || !paddr || !vaddr || !plen) { pr_err("%s: Invalid params\n", __func__); rc = -EINVAL; goto err; } - *client = msm_audio_ion_client_create(name); - if (IS_ERR_OR_NULL((void *)(*client))) { - pr_err("%s: ION create client for AUDIO failed\n", __func__); + /* bufsz should be 0 and fd shouldn't be 0 as of now */ + *dma_buf = dma_buf_get(fd); + pr_debug("%s: dma_buf =%pK, fd=%d\n", __func__, *dma_buf, fd); + if (IS_ERR_OR_NULL((void *)(*dma_buf))) { + pr_err("%s: dma_buf_get failed\n", __func__); rc = -EINVAL; goto err; } - /* name should be audio_acdb_client or Audio_Dec_Client, - * bufsz should be 0 and fd shouldn't be 0 as of now - */ - *handle = ion_import_dma_buf_fd(*client, fd); - pr_debug("%s: DMA Buf name=%s, fd=%d handle=%pK\n", __func__, - name, fd, *handle); - if (IS_ERR_OR_NULL((void *) (*handle))) { - pr_err("%s: ion import dma buffer failed\n", - __func__); - rc = -EINVAL; - goto err_destroy_client; - } - if (ionflag != NULL) { - rc = ion_handle_get_flags(*client, *handle, ionflag); - if (rc) { - pr_err("%s: could not get flags for the handle\n", - __func__); - goto err_ion_handle; - } + pr_err("%s: could not get flags for the dma_buf\n", + __func__); + rc = -EOPNOTSUPP; + goto err_ion_flag; } - rc = msm_audio_ion_get_phys(*client, *handle, paddr, pa_len); + rc = msm_audio_ion_map_buf(*dma_buf, paddr, plen, *vaddr); if (rc) { - pr_err("%s: ION Get Physical for AUDIO failed, rc = %d\n", - __func__, rc); - goto err_ion_handle; - } - - *vaddr = ion_map_kernel(*client, *handle); - if (IS_ERR_OR_NULL((void *)*vaddr)) { - pr_err("%s: ION memory mapping for AUDIO failed\n", __func__); - rc = -ENOMEM; - goto err_ion_handle; + pr_err("%s: failed to map ION buf, rc = %d\n", __func__, rc); + goto err_ion_flag; } pr_debug("%s: mapped address = %pK, size=%zd\n", __func__, *vaddr, bufsz); return 0; -err_ion_handle: - ion_free(*client, *handle); -err_destroy_client: - msm_audio_ion_client_destroy(*client); - *client = NULL; - *handle = NULL; +err_ion_flag: + dma_buf_put(*dma_buf); err: + *dma_buf = NULL; return rc; } +EXPORT_SYMBOL(msm_audio_ion_import); /** * msm_audio_ion_free - * fress ION memory for given client and handle * - * @client: ION client - * @handle: ION handle + * @dma_buf: dma_buf for the ION memory * * Returns 0 on success or error on failure */ -int msm_audio_ion_free(struct ion_client *client, struct ion_handle *handle) +int msm_audio_ion_free(struct dma_buf *dma_buf) { - if (!client || !handle) { - pr_err("%s Invalid params\n", __func__); + if (!dma_buf) { + pr_err("%s: dma_buf invalid\n", __func__); return -EINVAL; } - if (msm_audio_ion_data.smmu_enabled) - msm_audio_dma_buf_unmap(client, handle); - ion_unmap_kernel(client, handle); + msm_audio_ion_unmap_kernel(dma_buf); + + msm_audio_dma_buf_unmap(dma_buf); - ion_free(client, handle); - msm_audio_ion_client_destroy(client); return 0; } EXPORT_SYMBOL(msm_audio_ion_free); @@ -287,35 +487,42 @@ EXPORT_SYMBOL(msm_audio_ion_free); * msm_audio_ion_mmap - * Audio ION memory map * - * @ab: audio buf pointer + * @abuff: audio buf pointer * @vma: virtual mem area * * Returns 0 on success or error on failure */ -int msm_audio_ion_mmap(struct audio_buffer *ab, +int msm_audio_ion_mmap(struct audio_buffer *abuff, struct vm_area_struct *vma) { + struct msm_audio_alloc_data *alloc_data = NULL; struct sg_table *table; unsigned long addr = vma->vm_start; unsigned long offset = vma->vm_pgoff * PAGE_SIZE; struct scatterlist *sg; unsigned int i; struct page *page; - int ret; + int ret = 0; + bool found = false; + struct device *cb_dev = msm_audio_ion_data.cb_dev; - pr_debug("%s\n", __func__); + mutex_lock(&(msm_audio_ion_data.list_mutex)); + list_for_each_entry(alloc_data, &(msm_audio_ion_data.alloc_list), + list) { + if (alloc_data->dma_buf == abuff->dma_buf) { + found = true; + table = alloc_data->table; + break; + } + } + mutex_unlock(&(msm_audio_ion_data.list_mutex)); - table = ion_sg_table(ab->client, ab->handle); - - if (IS_ERR(table)) { - pr_err("%s: Unable to get sg_table from ion: %ld\n", - __func__, PTR_ERR(table)); - return PTR_ERR(table); - } else if (!table) { - pr_err("%s: sg_list is NULL\n", __func__); + if (!found) { + dev_err(cb_dev, + "%s: cannot find allocation, dma_buf %pK", + __func__, abuff->dma_buf); return -EINVAL; } - /* uncached */ vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); @@ -354,383 +561,29 @@ int msm_audio_ion_mmap(struct audio_buffer *ab, return 0; } } else { - ion_phys_addr_t phys_addr; - size_t phys_len; - size_t va_len = 0; - pr_debug("%s: page is NULL\n", __func__); - ret = ion_phys(ab->client, ab->handle, &phys_addr, &phys_len); - if (ret) { - pr_err("%s: Unable to get phys address from ION buffer: %d\n" - , __func__, ret); - return ret; - } - pr_debug("phys=%pKK len=%zd\n", &phys_addr, phys_len); - pr_debug("vma=%pK, vm_start=%x vm_end=%x vm_pgoff=%ld vm_page_prot=%lu\n", - vma, (unsigned int)vma->vm_start, - (unsigned int)vma->vm_end, vma->vm_pgoff, - (unsigned long)pgprot_val(vma->vm_page_prot)); - va_len = vma->vm_end - vma->vm_start; - if ((offset > phys_len) || (va_len > phys_len-offset)) { - pr_err("wrong offset size %ld, lens= %zd, va_len=%zd\n", - offset, phys_len, va_len); - return -EINVAL; - } - ret = remap_pfn_range(vma, vma->vm_start, - __phys_to_pfn(phys_addr) + vma->vm_pgoff, - vma->vm_end - vma->vm_start, - vma->vm_page_prot); + ret = -EINVAL; } - return 0; + + return ret; } EXPORT_SYMBOL(msm_audio_ion_mmap); - -bool msm_audio_ion_is_smmu_available(void) -{ - return msm_audio_ion_data.smmu_enabled; -} - -/* move to static section again */ -struct ion_client *msm_audio_ion_client_create(const char *name) -{ - struct ion_client *pclient = NULL; - - pclient = msm_ion_client_create(name); - return pclient; -} -EXPORT_SYMBOL(msm_audio_ion_client_create); - /** - * msm_audio_ion_client_destroy - - * Removes ION client handle + * msm_audio_populate_upper_32_bits - + * retrieve upper 32bits of 64bit address * - * @client: ION client + * @pa: 64bit physical address * */ -void msm_audio_ion_client_destroy(struct ion_client *client) +u32 msm_audio_populate_upper_32_bits(dma_addr_t pa) { - pr_debug("%s: client = %pK smmu_enabled = %d\n", __func__, - client, msm_audio_ion_data.smmu_enabled); - - ion_client_destroy(client); -} -EXPORT_SYMBOL(msm_audio_ion_client_destroy); - -/** - * msm_audio_ion_import_legacy - - * Alloc ION memory for given size - * - * @name: ION client name - * @client: ION client - * @handle: ION handle to be updated - * @fd: ION fd - * @ionflag: Flags for ION handle - * @bufsz: buffer size - * @paddr: pointer to be updated with physical address of allocated ION memory - * @pa_len: pointer to be updated with size of physical memory - * @vaddr: pointer to be updated with virtual address - * - * Returns 0 on success or error on failure - */ -int msm_audio_ion_import_legacy(const char *name, struct ion_client *client, - struct ion_handle **handle, int fd, - unsigned long *ionflag, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr) -{ - int rc = 0; - - if (!name || !client || !handle || !paddr || !vaddr || !pa_len) { - pr_err("%s: Invalid params\n", __func__); - rc = -EINVAL; - goto err; - } - /* client is already created for legacy and given - * name should be audio_acdb_client or Audio_Dec_Client, - * bufsz should be 0 and fd shouldn't be 0 as of now - */ - *handle = ion_import_dma_buf_fd(client, fd); - pr_debug("%s: DMA Buf name=%s, fd=%d handle=%pK\n", __func__, - name, fd, *handle); - if (IS_ERR_OR_NULL((void *)(*handle))) { - pr_err("%s: ion import dma buffer failed\n", - __func__); - rc = -EINVAL; - goto err; - } - - if (ionflag != NULL) { - rc = ion_handle_get_flags(client, *handle, ionflag); - if (rc) { - pr_err("%s: could not get flags for the handle\n", - __func__); - rc = -EINVAL; - goto err_ion_handle; - } - } - - rc = msm_audio_ion_get_phys(client, *handle, paddr, pa_len); - if (rc) { - pr_err("%s: ION Get Physical for AUDIO failed, rc = %d\n", - __func__, rc); - rc = -EINVAL; - goto err_ion_handle; - } - - /*Need to add condition SMMU enable or not */ - *vaddr = ion_map_kernel(client, *handle); - if (IS_ERR_OR_NULL((void *)*vaddr)) { - pr_err("%s: ION memory mapping for AUDIO failed\n", __func__); - rc = -EINVAL; - goto err_ion_handle; - } - - if (bufsz != 0) - memset((void *)*vaddr, 0, bufsz); - - return 0; - -err_ion_handle: - ion_free(client, *handle); -err: - return rc; -} -EXPORT_SYMBOL(msm_audio_ion_import_legacy); - -/** - * msm_audio_ion_free_legacy - - * Frees ION memory for given handle - * - * @client: ION client - * @handle: ION handle - * - */ -int msm_audio_ion_free_legacy(struct ion_client *client, - struct ion_handle *handle) -{ - if (msm_audio_ion_data.smmu_enabled) - msm_audio_dma_buf_unmap(client, handle); - - ion_unmap_kernel(client, handle); - - ion_free(client, handle); - /* no client_destrody in legacy*/ - return 0; -} -EXPORT_SYMBOL(msm_audio_ion_free_legacy); - -int msm_audio_ion_cache_operations(struct audio_buffer *abuff, int cache_op) -{ - unsigned long ionflag = 0; - int rc = 0; - int msm_cache_ops = 0; - - if (!abuff) { - pr_err("%s: Invalid params: %pK\n", __func__, abuff); - return -EINVAL; - } - rc = ion_handle_get_flags(abuff->client, abuff->handle, - &ionflag); - if (rc) { - pr_err("ion_handle_get_flags failed: %d\n", rc); - goto cache_op_failed; - } - - /* has to be CACHED */ - if (ION_IS_CACHED(ionflag)) { - /* ION_IOC_INV_CACHES or ION_IOC_CLEAN_CACHES */ - msm_cache_ops = cache_op; - rc = msm_ion_do_cache_op(abuff->client, - abuff->handle, - (unsigned long *) abuff->data, - (unsigned long)abuff->size, - msm_cache_ops); - if (rc) { - pr_err("cache operation failed %d\n", rc); - goto cache_op_failed; - } - } -cache_op_failed: - return rc; -} - - -static int msm_audio_dma_buf_map(struct ion_client *client, - struct ion_handle *handle, - ion_phys_addr_t *addr, size_t *len) -{ - - struct msm_audio_alloc_data *alloc_data; - struct device *cb_dev; - int rc = 0; - - cb_dev = msm_audio_ion_data.cb_dev; - - /* Data required per buffer mapping */ - alloc_data = kzalloc(sizeof(*alloc_data), GFP_KERNEL); - if (!alloc_data) - return -ENOMEM; - - /* Get the ION handle size */ - ion_handle_get_size(client, handle, len); - - alloc_data->client = client; - alloc_data->handle = handle; - alloc_data->len = *len; - - /* Get the dma_buf handle from ion_handle */ - alloc_data->dma_buf = ion_share_dma_buf(client, handle); - if (IS_ERR(alloc_data->dma_buf)) { - rc = PTR_ERR(alloc_data->dma_buf); - dev_err(cb_dev, - "%s: Fail to get dma_buf handle, rc = %d\n", - __func__, rc); - goto err_dma_buf; - } - - /* Attach the dma_buf to context bank device */ - alloc_data->attach = dma_buf_attach(alloc_data->dma_buf, - cb_dev); - if (IS_ERR(alloc_data->attach)) { - rc = PTR_ERR(alloc_data->attach); - dev_err(cb_dev, - "%s: Fail to attach dma_buf to CB, rc = %d\n", - __func__, rc); - goto err_attach; - } - - /* - * Get the scatter-gather list. - * There is no info as this is a write buffer or - * read buffer, hence the request is bi-directional - * to accommodate both read and write mappings. - */ - alloc_data->table = dma_buf_map_attachment(alloc_data->attach, - DMA_BIDIRECTIONAL); - if (IS_ERR(alloc_data->table)) { - rc = PTR_ERR(alloc_data->table); - dev_err(cb_dev, - "%s: Fail to map attachment, rc = %d\n", - __func__, rc); - goto err_map_attach; - } - - rc = dma_map_sg(cb_dev, alloc_data->table->sgl, - alloc_data->table->nents, - DMA_BIDIRECTIONAL); - if (rc != alloc_data->table->nents) { - dev_err(cb_dev, - "%s: Fail to map SG, rc = %d, nents = %d\n", - __func__, rc, alloc_data->table->nents); - goto err_map_sg; - } - /* Make sure not to return rc from dma_map_sg, as it can be nonzero */ - rc = 0; - - /* physical address from mapping */ - *addr = MSM_AUDIO_ION_PHYS_ADDR(alloc_data); - - msm_audio_ion_add_allocation(&msm_audio_ion_data, - alloc_data); - return rc; - -err_map_sg: - dma_buf_unmap_attachment(alloc_data->attach, - alloc_data->table, - DMA_BIDIRECTIONAL); -err_map_attach: - dma_buf_detach(alloc_data->dma_buf, - alloc_data->attach); -err_attach: - dma_buf_put(alloc_data->dma_buf); - -err_dma_buf: - kfree(alloc_data); - - return rc; -} - -static int msm_audio_dma_buf_unmap(struct ion_client *client, - struct ion_handle *handle) -{ - int rc = 0; - struct msm_audio_alloc_data *alloc_data = NULL; - struct list_head *ptr, *next; - struct device *cb_dev = msm_audio_ion_data.cb_dev; - bool found = false; - - /* - * Though list_for_each_safe is delete safe, lock - * should be explicitly acquired to avoid race condition - * on adding elements to the list. - */ - mutex_lock(&(msm_audio_ion_data.list_mutex)); - list_for_each_safe(ptr, next, - &(msm_audio_ion_data.alloc_list)) { - - alloc_data = list_entry(ptr, struct msm_audio_alloc_data, - list); - - if (alloc_data->handle == handle && - alloc_data->client == client) { - found = true; - dma_unmap_sg(cb_dev, - alloc_data->table->sgl, - alloc_data->table->nents, - DMA_BIDIRECTIONAL); - - dma_buf_unmap_attachment(alloc_data->attach, - alloc_data->table, - DMA_BIDIRECTIONAL); - - dma_buf_detach(alloc_data->dma_buf, - alloc_data->attach); - - dma_buf_put(alloc_data->dma_buf); - - list_del(&(alloc_data->list)); - kfree(alloc_data); - break; - } - } - mutex_unlock(&(msm_audio_ion_data.list_mutex)); - - if (!found) { - dev_err(cb_dev, - "%s: cannot find allocation, ion_handle %pK, ion_client %pK", - __func__, handle, client); - rc = -EINVAL; - } - - return rc; -} - -static int msm_audio_ion_get_phys(struct ion_client *client, - struct ion_handle *handle, - ion_phys_addr_t *addr, size_t *len) -{ - int rc = 0; - - pr_debug("%s: smmu_enabled = %d\n", __func__, - msm_audio_ion_data.smmu_enabled); - - if (msm_audio_ion_data.smmu_enabled) { - rc = msm_audio_dma_buf_map(client, handle, addr, len); - if (rc) { - pr_err("%s: failed to map DMA buf, err = %d\n", - __func__, rc); - goto err; - } - /* Append the SMMU SID information to the IOVA address */ - *addr |= msm_audio_ion_data.smmu_sid_bits; - } else { - rc = ion_phys(client, handle, addr, len); - } - - pr_debug("phys=%pK, len=%zd, rc=%d\n", &(*addr), *len, rc); -err: - return rc; + if (sizeof(dma_addr_t) == sizeof(u32)) + return upper_32_bits(msm_audio_ion_data.smmu_sid_bits); + else + return upper_32_bits(pa); } +EXPORT_SYMBOL(msm_audio_populate_upper_32_bits); static int msm_audio_smmu_init(struct device *dev) { @@ -768,115 +621,75 @@ static const struct of_device_id msm_audio_ion_dt_match[] = { }; MODULE_DEVICE_TABLE(of, msm_audio_ion_dt_match); - -u32 msm_audio_ion_get_smmu_sid_mode32(void) -{ - if (msm_audio_ion_data.smmu_enabled) - return upper_32_bits(msm_audio_ion_data.smmu_sid_bits); - else - return 0; -} - -/** - * msm_audio_populate_upper_32_bits - - * retrieve upper 32bits of 64bit address - * - * @pa: 64bit physical address - * - */ -u32 msm_audio_populate_upper_32_bits(ion_phys_addr_t pa) -{ - if (sizeof(ion_phys_addr_t) == sizeof(u32)) - return msm_audio_ion_get_smmu_sid_mode32(); - else - return upper_32_bits(pa); -} -EXPORT_SYMBOL(msm_audio_populate_upper_32_bits); - static int msm_audio_ion_probe(struct platform_device *pdev) { int rc = 0; - const char *msm_audio_ion_dt = "qcom,smmu-enabled"; const char *msm_audio_ion_smmu = "qcom,smmu-version"; const char *msm_audio_ion_smmu_sid_mask = "qcom,smmu-sid-mask"; - bool smmu_enabled; enum apr_subsys_state q6_state; struct device *dev = &pdev->dev; + u64 smmu_sid = 0; + u64 smmu_sid_mask = 0; + struct of_phandle_args iommuspec; if (dev->of_node == NULL) { dev_err(dev, "%s: device tree is not found\n", __func__); - msm_audio_ion_data.smmu_enabled = 0; return 0; } - smmu_enabled = of_property_read_bool(dev->of_node, - msm_audio_ion_dt); - msm_audio_ion_data.smmu_enabled = smmu_enabled; - - if (smmu_enabled) { - rc = of_property_read_u32(dev->of_node, - msm_audio_ion_smmu, - &msm_audio_ion_data.smmu_version); - if (rc) { - dev_err(dev, - "%s: qcom,smmu_version missing in DT node\n", - __func__); - return rc; - } - dev_dbg(dev, "%s: SMMU version is (%d)", __func__, - msm_audio_ion_data.smmu_version); - q6_state = apr_get_q6_state(); - if (q6_state == APR_SUBSYS_DOWN) { - dev_dbg(dev, - "defering %s, adsp_state %d\n", - __func__, q6_state); - return -EPROBE_DEFER; - } - dev_dbg(dev, "%s: adsp is ready\n", __func__); + rc = of_property_read_u32(dev->of_node, + msm_audio_ion_smmu, + &msm_audio_ion_data.smmu_version); + if (rc) { + dev_err(dev, + "%s: qcom,smmu_version missing in DT node\n", + __func__); + return rc; } - - dev_dbg(dev, "%s: SMMU is %s\n", __func__, - (smmu_enabled) ? "Enabled" : "Disabled"); - - if (smmu_enabled) { - u64 smmu_sid = 0; - u64 smmu_sid_mask = 0; - struct of_phandle_args iommuspec; - - /* Get SMMU SID information from Devicetree */ - rc = of_property_read_u64(dev->of_node, - msm_audio_ion_smmu_sid_mask, - &smmu_sid_mask); - if (rc) { - dev_err(dev, - "%s: qcom,smmu-sid-mask missing in DT node, using default\n", - __func__); - smmu_sid_mask = 0xFFFFFFFFFFFFFFFF; - } - rc = of_parse_phandle_with_args(dev->of_node, "iommus", - "#iommu-cells", 0, &iommuspec); - if (rc) - dev_err(dev, "%s: could not get smmu SID, ret = %d\n", - __func__, rc); - else - smmu_sid = (iommuspec.args[0] & smmu_sid_mask); - - msm_audio_ion_data.smmu_sid_bits = - smmu_sid << MSM_AUDIO_SMMU_SID_OFFSET; - - if (msm_audio_ion_data.smmu_version == 0x2) { - rc = msm_audio_smmu_init(dev); - } else { - dev_err(dev, "%s: smmu version invalid %d\n", - __func__, msm_audio_ion_data.smmu_version); - rc = -EINVAL; - } - if (rc) - dev_err(dev, "%s: smmu init failed, err = %d\n", - __func__, rc); + dev_dbg(dev, "%s: SMMU version is (%d)", __func__, + msm_audio_ion_data.smmu_version); + q6_state = apr_get_q6_state(); + if (q6_state == APR_SUBSYS_DOWN) { + dev_dbg(dev, + "defering %s, adsp_state %d\n", + __func__, q6_state); + return -EPROBE_DEFER; } + dev_dbg(dev, "%s: adsp is ready\n", __func__); + + /* Get SMMU SID information from Devicetree */ + rc = of_property_read_u64(dev->of_node, + msm_audio_ion_smmu_sid_mask, + &smmu_sid_mask); + if (rc) { + dev_err(dev, + "%s: qcom,smmu-sid-mask missing in DT node, using default\n", + __func__); + smmu_sid_mask = 0xFFFFFFFFFFFFFFFF; + } + rc = of_parse_phandle_with_args(dev->of_node, "iommus", + "#iommu-cells", 0, &iommuspec); + if (rc) + dev_err(dev, "%s: could not get smmu SID, ret = %d\n", + __func__, rc); + else + smmu_sid = (iommuspec.args[0] & smmu_sid_mask); + + msm_audio_ion_data.smmu_sid_bits = + smmu_sid << MSM_AUDIO_SMMU_SID_OFFSET; + + if (msm_audio_ion_data.smmu_version == 0x2) { + rc = msm_audio_smmu_init(dev); + } else { + dev_err(dev, "%s: smmu version invalid %d\n", + __func__, msm_audio_ion_data.smmu_version); + rc = -EINVAL; + } + if (rc) + dev_err(dev, "%s: smmu init failed, err = %d\n", + __func__, rc); if (!rc) msm_audio_ion_data.device_status |= MSM_AUDIO_ION_PROBED; @@ -897,7 +710,6 @@ static int msm_audio_ion_remove(struct platform_device *pdev) arm_iommu_release_mapping(mapping); } - msm_audio_ion_data.smmu_enabled = 0; msm_audio_ion_data.device_status = 0; return 0; } diff --git a/dsp/q6adm.c b/dsp/q6adm.c index 514af254db99..c5dd85c7cda0 100644 --- a/dsp/q6adm.c +++ b/dsp/q6adm.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -74,8 +74,7 @@ struct adm_copp { }; struct source_tracking_data { - struct ion_client *ion_client; - struct ion_handle *ion_handle; + struct dma_buf *dma_buf; struct param_outband memmap; int apr_cmd_status; }; @@ -1501,10 +1500,8 @@ static int32_t adm_callback(struct apr_client_data *data, void *priv) */ if (this_adm.sourceTrackingData.memmap.paddr != 0) { msm_audio_ion_free( - this_adm.sourceTrackingData.ion_client, - this_adm.sourceTrackingData.ion_handle); - this_adm.sourceTrackingData.ion_client = NULL; - this_adm.sourceTrackingData.ion_handle = NULL; + this_adm.sourceTrackingData.dma_buf); + this_adm.sourceTrackingData.dma_buf = NULL; this_adm.sourceTrackingData.memmap.size = 0; this_adm.sourceTrackingData.memmap.kvaddr = NULL; @@ -1919,7 +1916,7 @@ static int remap_cal_data(struct cal_block_data *cal_block, int cal_index) { int ret = 0; - if (cal_block->map_data.ion_client == NULL) { + if (cal_block->map_data.dma_buf == NULL) { pr_err("%s: No ION allocation for cal index %d!\n", __func__, cal_index); ret = -EINVAL; @@ -3223,10 +3220,8 @@ int adm_close(int port_id, int perf_mode, int copp_idx) __func__, ret); } msm_audio_ion_free( - this_adm.sourceTrackingData.ion_client, - this_adm.sourceTrackingData.ion_handle); - this_adm.sourceTrackingData.ion_client = NULL; - this_adm.sourceTrackingData.ion_handle = NULL; + this_adm.sourceTrackingData.dma_buf); + this_adm.sourceTrackingData.dma_buf = NULL; this_adm.sourceTrackingData.memmap.size = 0; this_adm.sourceTrackingData.memmap.kvaddr = NULL; this_adm.sourceTrackingData.memmap.paddr = 0; @@ -5033,9 +5028,7 @@ static int adm_source_tracking_alloc_map_memory(void) pr_debug("%s: Enter\n", __func__); - ret = msm_audio_ion_alloc("SOURCE_TRACKING", - &this_adm.sourceTrackingData.ion_client, - &this_adm.sourceTrackingData.ion_handle, + ret = msm_audio_ion_alloc(&this_adm.sourceTrackingData.dma_buf, AUD_PROC_BLOCK_SIZE, &this_adm.sourceTrackingData.memmap.paddr, &this_adm.sourceTrackingData.memmap.size, @@ -5058,10 +5051,8 @@ static int adm_source_tracking_alloc_map_memory(void) (void *)this_adm.sourceTrackingData.memmap.paddr, (uint32_t)this_adm.sourceTrackingData.memmap.size); - msm_audio_ion_free(this_adm.sourceTrackingData.ion_client, - this_adm.sourceTrackingData.ion_handle); - this_adm.sourceTrackingData.ion_client = NULL; - this_adm.sourceTrackingData.ion_handle = NULL; + msm_audio_ion_free(this_adm.sourceTrackingData.dma_buf); + this_adm.sourceTrackingData.dma_buf = NULL; this_adm.sourceTrackingData.memmap.size = 0; this_adm.sourceTrackingData.memmap.kvaddr = NULL; this_adm.sourceTrackingData.memmap.paddr = 0; @@ -5263,8 +5254,7 @@ int __init adm_init(void) if (adm_init_cal_data()) pr_err("%s: could not init cal data!\n", __func__); - this_adm.sourceTrackingData.ion_client = NULL; - this_adm.sourceTrackingData.ion_handle = NULL; + this_adm.sourceTrackingData.dma_buf = NULL; this_adm.sourceTrackingData.memmap.size = 0; this_adm.sourceTrackingData.memmap.kvaddr = NULL; this_adm.sourceTrackingData.memmap.paddr = 0; diff --git a/dsp/q6afe.c b/dsp/q6afe.c index 391a7f776551..f926efbdc16b 100644 --- a/dsp/q6afe.c +++ b/dsp/q6afe.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -1515,7 +1515,7 @@ static int remap_cal_data(struct cal_block_data *cal_block, int cal_index) { int ret = 0; - if (cal_block->map_data.ion_client == NULL) { + if (cal_block->map_data.dma_buf == NULL) { pr_err("%s: No ION allocation for cal index %d!\n", __func__, cal_index); ret = -EINVAL; @@ -4502,8 +4502,8 @@ int q6afe_audio_client_buf_alloc_contiguous(unsigned int dir, ac->port[dir].buf = buf; - rc = msm_audio_ion_alloc("afe_client", &buf[0].client, - &buf[0].handle, bufsz*bufcnt, + rc = msm_audio_ion_alloc(&buf[0].dma_buf, + bufsz * bufcnt, &buf[0].phys, &len, &buf[0].data); if (rc) { @@ -4777,16 +4777,13 @@ int q6afe_audio_client_buf_free_contiguous(unsigned int dir, cnt = port->max_buf_cnt - 1; if (port->buf[0].data) { - pr_debug("%s: data[%pK]phys[%pK][%pK] , client[%pK] handle[%pK]\n", + pr_debug("%s: data[%pK], phys[%pK], dma_buf[%pK]\n", __func__, port->buf[0].data, &port->buf[0].phys, - &port->buf[0].phys, - port->buf[0].client, - port->buf[0].handle); - msm_audio_ion_free(port->buf[0].client, port->buf[0].handle); - port->buf[0].client = NULL; - port->buf[0].handle = NULL; + port->buf[0].dma_buf); + msm_audio_ion_free(port->buf[0].dma_buf); + port->buf[0].dma_buf = NULL; } while (cnt >= 0) { diff --git a/dsp/q6asm.c b/dsp/q6asm.c index caf7df1dce6f..4f61fbec5df2 100644 --- a/dsp/q6asm.c +++ b/dsp/q6asm.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * Author: Brian Swetland * * This software is licensed under the terms of the GNU General Public @@ -661,7 +661,7 @@ static int remap_cal_data(int32_t cal_type, struct cal_block_data *cal_block) { int ret = 0; - if (cal_block->map_data.ion_client == NULL) { + if (cal_block->map_data.dma_buf == NULL) { pr_err("%s: No ION allocation for cal type %d!\n", __func__, cal_type); ret = -EINVAL; @@ -982,11 +982,9 @@ int q6asm_audio_client_buf_free(unsigned int dir, if (port->buf[cnt].data) { if (!rc || atomic_read(&ac->reset)) msm_audio_ion_free( - port->buf[cnt].client, - port->buf[cnt].handle); + port->buf[cnt].dma_buf); - port->buf[cnt].client = NULL; - port->buf[cnt].handle = NULL; + port->buf[cnt].dma_buf = NULL; port->buf[cnt].data = NULL; port->buf[cnt].phys = 0; --(port->max_buf_cnt); @@ -1033,18 +1031,14 @@ int q6asm_audio_client_buf_free_contiguous(unsigned int dir, } if (port->buf[0].data) { - pr_debug("%s: data[%pK]phys[%pK][%pK] , client[%pK] handle[%pK]\n", + pr_debug("%s: data[%pK], phys[%pK], dma_buf[%pK]\n", __func__, port->buf[0].data, &port->buf[0].phys, - &port->buf[0].phys, - port->buf[0].client, - port->buf[0].handle); + port->buf[0].dma_buf); if (!rc || atomic_read(&ac->reset)) - msm_audio_ion_free(port->buf[0].client, - port->buf[0].handle); - port->buf[0].client = NULL; - port->buf[0].handle = NULL; + msm_audio_ion_free(port->buf[0].dma_buf); + port->buf[0].dma_buf = NULL; } while (cnt >= 0) { @@ -1438,10 +1432,10 @@ int q6asm_audio_client_buf_alloc(unsigned int dir, while (cnt < bufcnt) { if (bufsz > 0) { if (!buf[cnt].data) { - rc = msm_audio_ion_alloc("asm_client", - &buf[cnt].client, &buf[cnt].handle, + rc = msm_audio_ion_alloc( + &buf[cnt].dma_buf, bufsz, - (ion_phys_addr_t *)&buf[cnt].phys, + &buf[cnt].phys, &len, &buf[cnt].data); if (rc) { @@ -1544,9 +1538,9 @@ int q6asm_audio_client_buf_alloc_contiguous(unsigned int dir, /* The size to allocate should be multiple of 4K bytes */ bytes_to_alloc = PAGE_ALIGN(bytes_to_alloc); - rc = msm_audio_ion_alloc("asm_client", &buf[0].client, &buf[0].handle, + rc = msm_audio_ion_alloc(&buf[0].dma_buf, bytes_to_alloc, - (ion_phys_addr_t *)&buf[0].phys, &len, + &buf[0].phys, &len, &buf[0].data); if (rc) { pr_err("%s: Audio ION alloc is failed, rc = %d\n", @@ -3615,9 +3609,9 @@ int q6asm_set_shared_circ_buff(struct audio_client *ac, bytes_to_alloc = bufsz * bufcnt; bytes_to_alloc = PAGE_ALIGN(bytes_to_alloc); - rc = msm_audio_ion_alloc("audio_client", &buf_circ->client, - &buf_circ->handle, bytes_to_alloc, - (ion_phys_addr_t *)&buf_circ->phys, + rc = msm_audio_ion_alloc(&buf_circ->dma_buf, + bytes_to_alloc, + &buf_circ->phys, &len, &buf_circ->data); if (rc) { @@ -3669,9 +3663,9 @@ int q6asm_set_shared_pos_buff(struct audio_client *ac, bytes_to_alloc = PAGE_ALIGN(bytes_to_alloc); - rc = msm_audio_ion_alloc("audio_client", &buf_pos->client, - &buf_pos->handle, bytes_to_alloc, - (ion_phys_addr_t *)&buf_pos->phys, &len, + rc = msm_audio_ion_alloc(&buf_pos->dma_buf, + bytes_to_alloc, + &buf_pos->phys, &len, &buf_pos->data); if (rc) { @@ -3900,18 +3894,15 @@ int q6asm_shared_io_free(struct audio_client *ac, int dir) port = &ac->port[dir]; mutex_lock(&ac->cmd_lock); if (port->buf && port->buf->data) { - msm_audio_ion_free(port->buf->client, port->buf->handle); - port->buf->client = NULL; - port->buf->handle = NULL; + msm_audio_ion_free(port->buf->dma_buf); + port->buf->dma_buf = NULL; port->max_buf_cnt = 0; kfree(port->buf); port->buf = NULL; } if (ac->shared_pos_buf.data) { - msm_audio_ion_free(ac->shared_pos_buf.client, - ac->shared_pos_buf.handle); - ac->shared_pos_buf.client = NULL; - ac->shared_pos_buf.handle = NULL; + msm_audio_ion_free(ac->shared_pos_buf.dma_buf); + ac->shared_pos_buf.dma_buf = NULL; } mutex_unlock(&ac->cmd_lock); return 0; @@ -7764,9 +7755,8 @@ EXPORT_SYMBOL(q6asm_set_aptx_dec_bt_addr); */ int q6asm_send_ion_fd(struct audio_client *ac, int fd) { - struct ion_client *client; - struct ion_handle *handle; - ion_phys_addr_t paddr; + struct dma_buf *dma_buf; + dma_addr_t paddr; size_t pa_len = 0; void *vaddr; int ret; @@ -7784,9 +7774,7 @@ int q6asm_send_ion_fd(struct audio_client *ac, int fd) goto fail_cmd; } - ret = msm_audio_ion_import("audio_mem_client", - &client, - &handle, + ret = msm_audio_ion_import(&dma_buf, fd, NULL, 0, diff --git a/dsp/q6lsm.c b/dsp/q6lsm.c index 2a98dc719965..0dd6dbddce23 100644 --- a/dsp/q6lsm.c +++ b/dsp/q6lsm.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2017, Linux Foundation. All rights reserved. + * Copyright (c) 2013-2018, Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -1413,10 +1413,8 @@ int q6lsm_snd_model_buf_free(struct lsm_client *client) __func__, rc); if (client->sound_model.data) { - msm_audio_ion_free(client->sound_model.client, - client->sound_model.handle); - client->sound_model.client = NULL; - client->sound_model.handle = NULL; + msm_audio_ion_free(client->sound_model.dma_buf); + client->sound_model.dma_buf = NULL; client->sound_model.data = NULL; client->sound_model.phys = 0; client->lsm_cal_phy_addr = 0; @@ -1594,9 +1592,7 @@ int q6lsm_snd_model_buf_alloc(struct lsm_client *client, size_t len, cal_block->cal_data.size); pr_debug("%s: Pad zeros sound model %zd Total mem %zd\n", __func__, pad_zero, total_mem); - rc = msm_audio_ion_alloc("lsm_client", - &client->sound_model.client, - &client->sound_model.handle, + rc = msm_audio_ion_alloc(&client->sound_model.dma_buf, total_mem, &client->sound_model.phys, &len, @@ -2138,9 +2134,7 @@ int q6lsm_lab_buffer_alloc(struct lsm_client *client, bool alloc) client->hw_params.period_count); return -ENOMEM; } - ret = msm_audio_ion_alloc("lsm_lab", - &client->lab_buffer[0].client, - &client->lab_buffer[0].handle, + ret = msm_audio_ion_alloc(&client->lab_buffer[0].dma_buf, allocate_size, &client->lab_buffer[0].phys, &len, &client->lab_buffer[0].data); @@ -2155,8 +2149,7 @@ int q6lsm_lab_buffer_alloc(struct lsm_client *client, bool alloc) pr_err("%s: memory map filed ret %d size %zd\n", __func__, ret, len); msm_audio_ion_free( - client->lab_buffer[0].client, - client->lab_buffer[0].handle); + client->lab_buffer[0].dma_buf); } } if (ret) { @@ -2187,9 +2180,7 @@ int q6lsm_lab_buffer_alloc(struct lsm_client *client, bool alloc) ret = q6lsm_memory_unmap_regions(client, client->lab_buffer[0].mem_map_handle); if (!ret) - msm_audio_ion_free( - client->lab_buffer[0].client, - client->lab_buffer[0].handle); + msm_audio_ion_free(client->lab_buffer[0].dma_buf); else pr_err("%s: unmap failed not freeing memory\n", __func__); diff --git a/dsp/q6usm.c b/dsp/q6usm.c index 1ed74a9c2b1d..3c335a841995 100644 --- a/dsp/q6usm.c +++ b/dsp/q6usm.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -209,14 +209,13 @@ static int q6usm_us_client_buf_free(unsigned int dir, pr_debug("%s: data[%pK]phys[%llx][%pK]\n", __func__, (void *)port->data, (u64)port->phys, (void *)&port->phys); - msm_audio_ion_free(port->client, port->handle); + msm_audio_ion_free(port->dma_buf); port->data = NULL; port->phys = 0; port->buf_size = 0; port->buf_cnt = 0; - port->client = NULL; - port->handle = NULL; + port->dma_buf = NULL; mutex_unlock(&usc->cmd_lock); return rc; @@ -250,13 +249,12 @@ int q6usm_us_param_buf_free(unsigned int dir, (void *)port->param_buf, (u64)port->param_phys, (void *)&port->param_phys); - msm_audio_ion_free(port->param_client, port->param_handle); + msm_audio_ion_free(port->param_dma_buf); port->param_buf = NULL; port->param_phys = 0; port->param_buf_size = 0; - port->param_client = NULL; - port->param_handle = NULL; + port->param_dma_buf = NULL; mutex_unlock(&usc->cmd_lock); return rc; @@ -398,8 +396,7 @@ int q6usm_us_client_buf_alloc(unsigned int dir, /* The size to allocate should be multiple of 4K bytes */ size = PAGE_ALIGN(size); - rc = msm_audio_ion_alloc("ultrasound_client", - &port->client, &port->handle, + rc = msm_audio_ion_alloc(&port->dma_buf, size, &port->phys, &len, &port->data); @@ -464,8 +461,7 @@ int q6usm_us_param_buf_alloc(unsigned int dir, /* The size to allocate should be multiple of 4K bytes */ size = PAGE_ALIGN(size); - rc = msm_audio_ion_alloc("ultrasound_client", - &port->param_client, &port->param_handle, + rc = msm_audio_ion_alloc(&port->param_dma_buf, size, &port->param_phys, &len, &port->param_buf); @@ -725,8 +721,7 @@ uint32_t q6usm_get_virtual_address(int dir, ab.used = 1; ab.size = size; ab.actual_size = size; - ab.handle = port->handle; - ab.client = port->client; + ab.dma_buf = port->dma_buf; ret = msm_audio_ion_mmap(&ab, vms); diff --git a/dsp/q6usm.h b/dsp/q6usm.h index fa2cd627c91d..ba4f9a9a84a7 100644 --- a/dsp/q6usm.h +++ b/dsp/q6usm.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -63,10 +63,8 @@ struct us_port_data { /* read or write locks */ struct mutex lock; spinlock_t dsp_lock; - /* ION memory handle */ - struct ion_handle *handle; - /* ION memory client */ - struct ion_client *client; + /* ION dma_buf memory */ + struct dma_buf *dma_buf; /* extended parameters, related to q6 variants */ void *ext; /* physical address of parameter buffer */ @@ -77,10 +75,8 @@ struct us_port_data { uint32_t param_buf_size; /* parameter buffer memory handle */ void *param_buf_mem_handle; - /* ION memory handle for parameter buffer */ - struct ion_handle *param_handle; - /* ION memory client for parameter buffer */ - struct ion_client *param_client; + /* ION dma_buf memory for parameter buffer */ + struct dma_buf *param_dma_buf; }; struct us_client { diff --git a/dsp/q6voice.c b/dsp/q6voice.c index d5f280e3b0af..e26d156b57d3 100644 --- a/dsp/q6voice.c +++ b/dsp/q6voice.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -1944,8 +1944,7 @@ static int is_cal_memory_allocated(void) { bool ret; - if (common.cal_mem_map_table.client != NULL && - common.cal_mem_map_table.handle != NULL) + if (common.cal_mem_map_table.dma_buf != NULL) ret = true; else ret = false; @@ -1958,18 +1957,15 @@ static int free_cal_map_table(void) { int ret = 0; - if ((common.cal_mem_map_table.client == NULL) || - (common.cal_mem_map_table.handle == NULL)) + if (common.cal_mem_map_table.dma_buf == NULL) goto done; - ret = msm_audio_ion_free(common.cal_mem_map_table.client, - common.cal_mem_map_table.handle); + ret = msm_audio_ion_free(common.cal_mem_map_table.dma_buf); if (ret < 0) pr_err("%s: msm_audio_ion_free failed:\n", __func__); done: - common.cal_mem_map_table.client = NULL; - common.cal_mem_map_table.handle = NULL; + common.cal_mem_map_table.dma_buf = NULL; return ret; } @@ -1977,8 +1973,7 @@ static int is_rtac_memory_allocated(void) { bool ret; - if (common.rtac_mem_map_table.client != NULL && - common.rtac_mem_map_table.handle != NULL) + if (common.rtac_mem_map_table.dma_buf != NULL) ret = true; else ret = false; @@ -1990,18 +1985,15 @@ static int free_rtac_map_table(void) { int ret = 0; - if ((common.rtac_mem_map_table.client == NULL) || - (common.rtac_mem_map_table.handle == NULL)) + if (common.rtac_mem_map_table.dma_buf == NULL) goto done; - ret = msm_audio_ion_free(common.rtac_mem_map_table.client, - common.rtac_mem_map_table.handle); + ret = msm_audio_ion_free(common.rtac_mem_map_table.dma_buf); if (ret < 0) pr_err("%s: msm_audio_ion_free failed:\n", __func__); done: - common.rtac_mem_map_table.client = NULL; - common.rtac_mem_map_table.handle = NULL; + common.rtac_mem_map_table.dma_buf = NULL; return ret; } @@ -2021,8 +2013,7 @@ static int is_voip_memory_allocated(void) } mutex_lock(&common.common_lock); - if (v->shmem_info.sh_buf.client != NULL && - v->shmem_info.sh_buf.handle != NULL) + if (v->shmem_info.sh_buf.dma_buf != NULL) ret = true; else ret = false; @@ -3575,7 +3566,7 @@ static int remap_cal_data(struct cal_block_data *cal_block, pr_debug("%s\n", __func__); - if (cal_block->map_data.ion_client == NULL) { + if (cal_block->map_data.dma_buf == NULL) { pr_err("%s: No ION allocation for session_id %d!\n", __func__, session_id); ret = -EINVAL; @@ -7257,12 +7248,9 @@ static int32_t qdsp_mvm_callback(struct apr_client_data *data, void *priv) /* Free the ION memory and clear handles for Source Tracking */ if (is_source_tracking_shared_memomry_allocated()) { msm_audio_ion_free( - common.source_tracking_sh_mem.sh_mem_block.client, - common.source_tracking_sh_mem.sh_mem_block.handle); + common.source_tracking_sh_mem.sh_mem_block.dma_buf); common.source_tracking_sh_mem.mem_handle = 0; - common.source_tracking_sh_mem.sh_mem_block.client = - NULL; - common.source_tracking_sh_mem.sh_mem_block.handle = + common.source_tracking_sh_mem.sh_mem_block.dma_buf = NULL; } /* clean up srvcc rec flag */ @@ -7465,12 +7453,9 @@ static int32_t qdsp_cvs_callback(struct apr_client_data *data, void *priv) /* Free the ION memory and clear handles for Source Tracking */ if (is_source_tracking_shared_memomry_allocated()) { msm_audio_ion_free( - common.source_tracking_sh_mem.sh_mem_block.client, - common.source_tracking_sh_mem.sh_mem_block.handle); + common.source_tracking_sh_mem.sh_mem_block.dma_buf); common.source_tracking_sh_mem.mem_handle = 0; - common.source_tracking_sh_mem.sh_mem_block.client = - NULL; - common.source_tracking_sh_mem.sh_mem_block.handle = + common.source_tracking_sh_mem.sh_mem_block.dma_buf = NULL; } voc_set_error_state(data->reset_proc); @@ -7743,12 +7728,9 @@ static int32_t qdsp_cvp_callback(struct apr_client_data *data, void *priv) */ if (is_source_tracking_shared_memomry_allocated()) { msm_audio_ion_free( - common.source_tracking_sh_mem.sh_mem_block.client, - common.source_tracking_sh_mem.sh_mem_block.handle); + common.source_tracking_sh_mem.sh_mem_block.dma_buf); common.source_tracking_sh_mem.mem_handle = 0; - common.source_tracking_sh_mem.sh_mem_block.client = - NULL; - common.source_tracking_sh_mem.sh_mem_block.handle = + common.source_tracking_sh_mem.sh_mem_block.dma_buf = NULL; } voc_set_error_state(data->reset_proc); @@ -7958,10 +7940,8 @@ static int voice_free_oob_shared_mem(void) goto done; } - rc = msm_audio_ion_free(v->shmem_info.sh_buf.client, - v->shmem_info.sh_buf.handle); - v->shmem_info.sh_buf.client = NULL; - v->shmem_info.sh_buf.handle = NULL; + rc = msm_audio_ion_free(v->shmem_info.sh_buf.dma_buf); + v->shmem_info.sh_buf.dma_buf = NULL; if (rc < 0) { pr_err("%s: Error:%d freeing memory\n", __func__, rc); @@ -7975,8 +7955,7 @@ static int voice_free_oob_shared_mem(void) cnt++; } - v->shmem_info.sh_buf.client = NULL; - v->shmem_info.sh_buf.handle = NULL; + v->shmem_info.sh_buf.dma_buf = NULL; done: mutex_unlock(&common.common_lock); @@ -8003,9 +7982,8 @@ static int voice_alloc_oob_shared_mem(void) goto done; } - rc = msm_audio_ion_alloc("voip_client", &(v->shmem_info.sh_buf.client), - &(v->shmem_info.sh_buf.handle), - bufsz*bufcnt, + rc = msm_audio_ion_alloc(&(v->shmem_info.sh_buf.dma_buf), + bufsz * bufcnt, &phys, &len, &mem_addr); if (rc < 0) { @@ -8055,8 +8033,7 @@ static int voice_alloc_oob_mem_table(void) goto done; } - rc = msm_audio_ion_alloc("voip_client", &(v->shmem_info.memtbl.client), - &(v->shmem_info.memtbl.handle), + rc = msm_audio_ion_alloc(&(v->shmem_info.memtbl.dma_buf), sizeof(struct vss_imemory_table_t), &v->shmem_info.memtbl.phys, &len, @@ -8442,9 +8419,7 @@ static int voice_alloc_cal_mem_map_table(void) int ret = 0; size_t len; - ret = msm_audio_ion_alloc("voc_cal", - &(common.cal_mem_map_table.client), - &(common.cal_mem_map_table.handle), + ret = msm_audio_ion_alloc(&(common.cal_mem_map_table.dma_buf), sizeof(struct vss_imemory_table_t), &common.cal_mem_map_table.phys, &len, @@ -8469,9 +8444,8 @@ static int voice_alloc_rtac_mem_map_table(void) int ret = 0; size_t len; - ret = msm_audio_ion_alloc("voc_rtac_cal", - &(common.rtac_mem_map_table.client), - &(common.rtac_mem_map_table.handle), + ret = msm_audio_ion_alloc( + &(common.rtac_mem_map_table.dma_buf), sizeof(struct vss_imemory_table_t), &common.rtac_mem_map_table.phys, &len, @@ -9181,8 +9155,7 @@ static int is_source_tracking_shared_memomry_allocated(void) pr_debug("%s: Enter\n", __func__); - if (common.source_tracking_sh_mem.sh_mem_block.client != NULL && - common.source_tracking_sh_mem.sh_mem_block.handle != NULL) + if (common.source_tracking_sh_mem.sh_mem_block.dma_buf != NULL) ret = true; else ret = false; @@ -9198,9 +9171,8 @@ static int voice_alloc_source_tracking_shared_memory(void) pr_debug("%s: Enter\n", __func__); - ret = msm_audio_ion_alloc("source_tracking_sh_mem_block", - &(common.source_tracking_sh_mem.sh_mem_block.client), - &(common.source_tracking_sh_mem.sh_mem_block.handle), + ret = msm_audio_ion_alloc( + &(common.source_tracking_sh_mem.sh_mem_block.dma_buf), BUFFER_BLOCK_SIZE, &(common.source_tracking_sh_mem.sh_mem_block.phys), (size_t *)&(common.source_tracking_sh_mem.sh_mem_block.size), @@ -9221,9 +9193,8 @@ static int voice_alloc_source_tracking_shared_memory(void) (void *)(common.source_tracking_sh_mem.sh_mem_block.data), (size_t)(common.source_tracking_sh_mem.sh_mem_block.size)); - ret = msm_audio_ion_alloc("source_tracking_sh_mem_table", - &(common.source_tracking_sh_mem.sh_mem_table.client), - &(common.source_tracking_sh_mem.sh_mem_table.handle), + ret = msm_audio_ion_alloc( + &(common.source_tracking_sh_mem.sh_mem_table.dma_buf), sizeof(struct vss_imemory_table_t), &(common.source_tracking_sh_mem.sh_mem_table.phys), (size_t *)&(common.source_tracking_sh_mem.sh_mem_table.size), @@ -9233,10 +9204,8 @@ static int voice_alloc_source_tracking_shared_memory(void) __func__, ret); ret = msm_audio_ion_free( - common.source_tracking_sh_mem.sh_mem_block.client, - common.source_tracking_sh_mem.sh_mem_block.handle); - common.source_tracking_sh_mem.sh_mem_block.client = NULL; - common.source_tracking_sh_mem.sh_mem_block.handle = NULL; + common.source_tracking_sh_mem.sh_mem_block.dma_buf); + common.source_tracking_sh_mem.sh_mem_block.dma_buf = NULL; if (ret < 0) pr_err("%s: Error:%d freeing memory\n", __func__, ret); @@ -9312,13 +9281,11 @@ static int voice_unmap_and_free_source_tracking_shared_memory( } } - if ((common.source_tracking_sh_mem.sh_mem_block.client == NULL) || - (common.source_tracking_sh_mem.sh_mem_block.handle == NULL)) + if (common.source_tracking_sh_mem.sh_mem_block.dma_buf == NULL) goto done; ret = msm_audio_ion_free( - common.source_tracking_sh_mem.sh_mem_block.client, - common.source_tracking_sh_mem.sh_mem_block.handle); + common.source_tracking_sh_mem.sh_mem_block.dma_buf); if (ret < 0) { pr_err("%s: Error:%d freeing memory\n", __func__, ret); @@ -9328,8 +9295,7 @@ static int voice_unmap_and_free_source_tracking_shared_memory( done: common.source_tracking_sh_mem.mem_handle = 0; - common.source_tracking_sh_mem.sh_mem_block.client = NULL; - common.source_tracking_sh_mem.sh_mem_block.handle = NULL; + common.source_tracking_sh_mem.sh_mem_block.dma_buf = NULL; pr_debug("%s: Exit, ret=%d\n", __func__, ret); return ret; diff --git a/dsp/rtac.c b/dsp/rtac.c index 43c69ccab394..0785f5621f69 100644 --- a/dsp/rtac.c +++ b/dsp/rtac.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -41,13 +41,13 @@ struct rtac_cal_block_data rtac_cal[MAX_RTAC_BLOCKS] = { /* ADM_RTAC_CAL */ - {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} }, + {{RTAC_BUF_SIZE, 0, 0}, {0, 0, 0} }, /* ASM_RTAC_CAL */ - {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} }, + {{RTAC_BUF_SIZE, 0, 0}, {0, 0, 0} }, /* VOICE_RTAC_CAL */ - {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} }, + {{RTAC_BUF_SIZE, 0, 0}, {0, 0, 0} }, /* AFE_RTAC_CAL */ - {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} } + {{RTAC_BUF_SIZE, 0, 0}, {0, 0, 0} } }; struct rtac_common_data { @@ -164,9 +164,7 @@ int rtac_allocate_cal_buffer(uint32_t cal_type) goto done; } - result = msm_audio_ion_alloc("rtac_client", - &rtac_cal[cal_type].map_data.ion_client, - &rtac_cal[cal_type].map_data.ion_handle, + result = msm_audio_ion_alloc(&rtac_cal[cal_type].map_data.dma_buf, rtac_cal[cal_type].map_data.map_size, &rtac_cal[cal_type].cal_data.paddr, &len, @@ -199,14 +197,13 @@ int rtac_free_cal_buffer(uint32_t cal_type) goto done; } - if (rtac_cal[cal_type].map_data.ion_client == NULL) { + if (rtac_cal[cal_type].map_data.dma_buf == NULL) { pr_debug("%s: cal_type %d not allocated!\n", __func__, cal_type); goto done; } - result = msm_audio_ion_free(rtac_cal[cal_type].map_data.ion_client, - rtac_cal[cal_type].map_data.ion_handle); + result = msm_audio_ion_free(rtac_cal[cal_type].map_data.dma_buf); if (result < 0) { pr_err("%s: ION free for RTAC failed! cal_type %d, paddr 0x%pK\n", __func__, cal_type, &rtac_cal[cal_type].cal_data.paddr); @@ -214,8 +211,7 @@ int rtac_free_cal_buffer(uint32_t cal_type) } rtac_cal[cal_type].map_data.map_handle = 0; - rtac_cal[cal_type].map_data.ion_client = NULL; - rtac_cal[cal_type].map_data.ion_handle = NULL; + rtac_cal[cal_type].map_data.dma_buf = NULL; rtac_cal[cal_type].cal_data.size = 0; rtac_cal[cal_type].cal_data.kvaddr = 0; rtac_cal[cal_type].cal_data.paddr = 0; @@ -754,7 +750,7 @@ int send_adm_apr(void *buf, u32 opcode) pr_debug("%s\n", __func__); - if (rtac_cal[ADM_RTAC_CAL].map_data.ion_handle == NULL) { + if (rtac_cal[ADM_RTAC_CAL].map_data.dma_buf == NULL) { result = rtac_allocate_cal_buffer(ADM_RTAC_CAL); if (result < 0) { pr_err("%s: allocate buffer failed!", @@ -983,7 +979,7 @@ int send_rtac_asm_apr(void *buf, u32 opcode) pr_debug("%s\n", __func__); - if (rtac_cal[ASM_RTAC_CAL].map_data.ion_handle == NULL) { + if (rtac_cal[ASM_RTAC_CAL].map_data.dma_buf == NULL) { result = rtac_allocate_cal_buffer(ASM_RTAC_CAL); if (result < 0) { pr_err("%s: allocate buffer failed!", @@ -1232,7 +1228,7 @@ static int send_rtac_afe_apr(void *buf, uint32_t opcode) pr_debug("%s\n", __func__); - if (rtac_cal[AFE_RTAC_CAL].map_data.ion_handle == NULL) { + if (rtac_cal[AFE_RTAC_CAL].map_data.dma_buf == NULL) { result = rtac_allocate_cal_buffer(AFE_RTAC_CAL); if (result < 0) { pr_err("%s: allocate buffer failed! ret = %d\n", @@ -1482,7 +1478,7 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode) pr_debug("%s\n", __func__); - if (rtac_cal[VOICE_RTAC_CAL].map_data.ion_handle == NULL) { + if (rtac_cal[VOICE_RTAC_CAL].map_data.dma_buf == NULL) { result = rtac_allocate_cal_buffer(VOICE_RTAC_CAL); if (result < 0) { pr_err("%s: allocate buffer failed!", diff --git a/include/dsp/audio_cal_utils.h b/include/dsp/audio_cal_utils.h index e12d8c1a9890..a4aa4e45d200 100644 --- a/include/dsp/audio_cal_utils.h +++ b/include/dsp/audio_cal_utils.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2014, 2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -28,8 +28,7 @@ struct mem_map_data { size_t map_size; int32_t q6map_handle; int32_t ion_map_handle; - struct ion_client *ion_client; - struct ion_handle *ion_handle; + struct dma_buf *dma_buf; }; struct cal_block_data { diff --git a/include/dsp/msm_audio_ion.h b/include/dsp/msm_audio_ion.h index 8a2fb6e34b99..a4cd3867774b 100644 --- a/include/dsp/msm_audio_ion.h +++ b/include/dsp/msm_audio_ion.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. + * Copyright (c) 2013-2015, 2017-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -18,28 +18,14 @@ #include -int msm_audio_ion_alloc(const char *name, struct ion_client **client, - struct ion_handle **handle, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr); +int msm_audio_ion_alloc(struct dma_buf **dma_buf, size_t bufsz, + dma_addr_t *paddr, size_t *pa_len, void **vaddr); -int msm_audio_ion_import(const char *name, struct ion_client **client, - struct ion_handle **handle, int fd, +int msm_audio_ion_import(struct dma_buf **dma_buf, int fd, unsigned long *ionflag, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr); -int msm_audio_ion_free(struct ion_client *client, struct ion_handle *handle); -int msm_audio_ion_mmap(struct audio_buffer *substream, - struct vm_area_struct *vma); + dma_addr_t *paddr, size_t *pa_len, void **vaddr); +int msm_audio_ion_free(struct dma_buf *dma_buf); +int msm_audio_ion_mmap(struct audio_buffer *abuff, struct vm_area_struct *vma); -bool msm_audio_ion_is_smmu_available(void); -int msm_audio_ion_cache_operations(struct audio_buffer *abuff, int cache_op); - -struct ion_client *msm_audio_ion_client_create(const char *name); -void msm_audio_ion_client_destroy(struct ion_client *client); -int msm_audio_ion_import_legacy(const char *name, struct ion_client *client, - struct ion_handle **handle, int fd, - unsigned long *ionflag, size_t bufsz, - ion_phys_addr_t *paddr, size_t *pa_len, void **vaddr); -int msm_audio_ion_free_legacy(struct ion_client *client, - struct ion_handle *handle); -u32 msm_audio_populate_upper_32_bits(ion_phys_addr_t pa); +u32 msm_audio_populate_upper_32_bits(dma_addr_t pa); #endif /* _LINUX_MSM_AUDIO_ION_H */ diff --git a/include/dsp/q6afe-v2.h b/include/dsp/q6afe-v2.h index 6fb9c442ec30..ade124952236 100644 --- a/include/dsp/q6afe-v2.h +++ b/include/dsp/q6afe-v2.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -246,8 +246,7 @@ struct afe_audio_buffer { uint32_t used; uint32_t size;/* size of buffer */ uint32_t actual_size; /* actual number of bytes read by DSP */ - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; }; struct afe_audio_port_data { diff --git a/include/dsp/q6asm-v2.h b/include/dsp/q6asm-v2.h index 157c243185b6..27b360f376c5 100644 --- a/include/dsp/q6asm-v2.h +++ b/include/dsp/q6asm-v2.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -165,8 +165,7 @@ struct audio_buffer { uint32_t used; uint32_t size;/* size of buffer */ uint32_t actual_size; /* actual number of bytes read by DSP */ - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; }; struct audio_aio_write_param { diff --git a/include/dsp/q6lsm.h b/include/dsp/q6lsm.h index efce3a6d2076..9050a7ca86c6 100644 --- a/include/dsp/q6lsm.h +++ b/include/dsp/q6lsm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -33,8 +33,7 @@ struct lsm_sound_model { void *data; size_t size; /* size of buffer */ uint32_t actual_size; /* actual number of bytes read by DSP */ - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; uint32_t mem_map_handle; }; @@ -48,8 +47,7 @@ struct lsm_lab_buffer { dma_addr_t phys; void *data; size_t size; - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; uint32_t mem_map_handle; }; diff --git a/include/dsp/q6voice.h b/include/dsp/q6voice.h index a41a2db8f868..5dfdccf84420 100644 --- a/include/dsp/q6voice.h +++ b/include/dsp/q6voice.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -156,8 +156,7 @@ struct mem_buffer { }; struct share_mem_buf { - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; struct mem_buffer buf[NUM_OF_BUFFERS]; }; @@ -165,8 +164,7 @@ struct mem_map_table { dma_addr_t phys; void *data; size_t size; /* size of buffer */ - struct ion_handle *handle; - struct ion_client *client; + struct dma_buf *dma_buf; }; /* Common */ @@ -1874,12 +1872,6 @@ struct voice_data { struct voice_rec_route_state rec_route_state; }; -struct cal_mem { - struct ion_handle *handle; - uint32_t phy; - void *buf; -}; - #define MAX_VOC_SESSIONS 8 struct common_data { @@ -1909,9 +1901,6 @@ struct common_data { uint32_t voice_host_pcm_mem_handle; - struct cal_mem cvp_cal; - struct cal_mem cvs_cal; - struct mutex common_lock; struct mvs_driver_info mvs_info; diff --git a/include/dsp/rtac.h b/include/dsp/rtac.h index f8c5556c5455..05dd82a7fcab 100644 --- a/include/dsp/rtac.h +++ b/include/dsp/rtac.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2013-2015, 2017, The Linux Foundation. All rights reserved. + * Copyright (c) 2011, 2013-2015, 2017-2018, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -38,8 +38,7 @@ enum { struct rtac_cal_mem_map_data { uint32_t map_size; uint32_t map_handle; - struct ion_client *ion_client; - struct ion_handle *ion_handle; + struct dma_buf *dma_buf; }; struct rtac_cal_data {