Merge "diag: Change implementation of diag log masks"
diff --git a/arch/arm/boot/dts/dsi-panel-ssd2080m-720p-video.dtsi b/arch/arm/boot/dts/dsi-panel-ssd2080m-720p-video.dtsi
index bb8389f..b510e6b 100644
--- a/arch/arm/boot/dts/dsi-panel-ssd2080m-720p-video.dtsi
+++ b/arch/arm/boot/dts/dsi-panel-ssd2080m-720p-video.dtsi
@@ -30,9 +30,9 @@
qcom,mdss-dsi-h-back-porch = <24>;
qcom,mdss-dsi-h-pulse-width = <14>;
qcom,mdss-dsi-h-sync-skew = <0>;
- qcom,mdss-dsi-v-back-porch = <15>;
- qcom,mdss-dsi-v-front-porch = <12>;
- qcom,mdss-dsi-v-pulse-width = <10>;
+ qcom,mdss-dsi-v-back-porch = <14>;
+ qcom,mdss-dsi-v-front-porch = <11>;
+ qcom,mdss-dsi-v-pulse-width = <2>;
qcom,mdss-dsi-h-left-border = <0>;
qcom,mdss-dsi-h-right-border = <0>;
qcom,mdss-dsi-v-top-border = <0>;
diff --git a/arch/arm/boot/dts/msm8974pro-pm8941.dtsi b/arch/arm/boot/dts/msm8974pro-pm8941.dtsi
index 0f37584..2c06c3c 100644
--- a/arch/arm/boot/dts/msm8974pro-pm8941.dtsi
+++ b/arch/arm/boot/dts/msm8974pro-pm8941.dtsi
@@ -38,18 +38,22 @@
&krait0_vreg {
regulator-max-microvolt = <1120000>;
+ qcom,ldo-delta-voltage = <25000>;
};
&krait1_vreg {
regulator-max-microvolt = <1120000>;
+ qcom,ldo-delta-voltage = <25000>;
};
&krait2_vreg {
regulator-max-microvolt = <1120000>;
+ qcom,ldo-delta-voltage = <25000>;
};
&krait3_vreg {
regulator-max-microvolt = <1120000>;
+ qcom,ldo-delta-voltage = <25000>;
};
&tspp {
diff --git a/arch/arm/boot/dts/msm8974pro-pma8084-regulator.dtsi b/arch/arm/boot/dts/msm8974pro-pma8084-regulator.dtsi
index df00f8a..00e3b8b 100644
--- a/arch/arm/boot/dts/msm8974pro-pma8084-regulator.dtsi
+++ b/arch/arm/boot/dts/msm8974pro-pma8084-regulator.dtsi
@@ -494,7 +494,7 @@
qcom,retention-voltage = <675000>;
qcom,ldo-default-voltage = <750000>;
qcom,ldo-threshold-voltage = <850000>;
- qcom,ldo-delta-voltage = <50000>;
+ qcom,ldo-delta-voltage = <25000>;
qcom,cpu-num = <0>;
};
@@ -510,7 +510,7 @@
qcom,retention-voltage = <675000>;
qcom,ldo-default-voltage = <750000>;
qcom,ldo-threshold-voltage = <850000>;
- qcom,ldo-delta-voltage = <50000>;
+ qcom,ldo-delta-voltage = <25000>;
qcom,cpu-num = <1>;
};
@@ -526,7 +526,7 @@
qcom,retention-voltage = <675000>;
qcom,ldo-default-voltage = <750000>;
qcom,ldo-threshold-voltage = <850000>;
- qcom,ldo-delta-voltage = <50000>;
+ qcom,ldo-delta-voltage = <25000>;
qcom,cpu-num = <2>;
};
@@ -542,7 +542,7 @@
qcom,retention-voltage = <675000>;
qcom,ldo-default-voltage = <750000>;
qcom,ldo-threshold-voltage = <850000>;
- qcom,ldo-delta-voltage = <50000>;
+ qcom,ldo-delta-voltage = <25000>;
qcom,cpu-num = <3>;
};
};
diff --git a/arch/arm/configs/msm8226-perf_defconfig b/arch/arm/configs/msm8226-perf_defconfig
index 7d7bf46..818e052 100644
--- a/arch/arm/configs/msm8226-perf_defconfig
+++ b/arch/arm/configs/msm8226-perf_defconfig
@@ -25,6 +25,7 @@
CONFIG_PANIC_TIMEOUT=5
CONFIG_KALLSYMS_ALL=y
CONFIG_EMBEDDED=y
+# CONFIG_SLUB_DEBUG is not set
CONFIG_PROFILING=y
CONFIG_OPROFILE=m
CONFIG_KPROBES=y
diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c
index fb1caea..ea0195d 100644
--- a/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c
+++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp_util.c
@@ -623,6 +623,12 @@
goto reg_cfg_failed;
}
+ if (!proc_cmd->cmd_len) {
+ pr_err("%s: Passed cmd_len as 0\n", __func__);
+ rc = -EINVAL;
+ goto cfg_data_failed;
+ }
+
cfg_data = kzalloc(proc_cmd->cmd_len, GFP_KERNEL);
if (!cfg_data) {
pr_err("%s: cfg_data alloc failed\n", __func__);
diff --git a/drivers/media/platform/msm/camera_v2/pproc/cpp/msm_cpp.c b/drivers/media/platform/msm/camera_v2/pproc/cpp/msm_cpp.c
index 8b8d23b..4938a8c 100644
--- a/drivers/media/platform/msm/camera_v2/pproc/cpp/msm_cpp.c
+++ b/drivers/media/platform/msm/camera_v2/pproc/cpp/msm_cpp.c
@@ -1712,6 +1712,7 @@
struct cpp_device *cpp_dev = v4l2_get_subdevdata(sd);
struct msm_camera_v4l2_ioctl_t *ioctl_ptr = arg;
struct msm_cpp_frame_info_t inst_info;
+ memset(&inst_info, 0, sizeof(struct msm_cpp_frame_info_t));
for (i = 0; i < MAX_ACTIVE_CPP_INSTANCE; i++) {
if (cpp_dev->cpp_subscribe_list[i].vfh == vfh) {
inst_info.inst_id = i;
diff --git a/drivers/media/platform/msm/vidc/hfi_response_handler.c b/drivers/media/platform/msm/vidc/hfi_response_handler.c
index abdb039..3fd5d3a 100644
--- a/drivers/media/platform/msm/vidc/hfi_response_handler.c
+++ b/drivers/media/platform/msm/vidc/hfi_response_handler.c
@@ -1183,42 +1183,78 @@
callback(SESSION_GET_SEQ_HDR_DONE, &data_done);
}
-void hfi_process_sys_property_info(
- struct hfi_property_sys_image_version_info_type *pkt)
+static void hfi_process_sys_get_prop_image_version(
+ struct hfi_msg_sys_property_info_packet *pkt)
{
int i = 0;
u32 smem_block_size = 0;
u8 *smem_table_ptr;
char version[256];
+ const u32 version_string_size = 128;
const u32 smem_image_index_venus = 14 * 128;
+ u8 *str_image_version;
+ int req_bytes;
- if (!pkt || !pkt->string_size) {
+ req_bytes = pkt->size - sizeof(*pkt);
+ if (req_bytes < version_string_size ||
+ !pkt->rg_property_data[1] ||
+ pkt->num_properties > 1) {
+ dprintk(VIDC_ERR,
+ "hfi_process_sys_get_prop_image_version:bad_pkt: %d",
+ req_bytes);
+ return;
+ }
+ str_image_version = (u8 *)&pkt->rg_property_data[1];
+ /*
+ * The version string returned by firmware includes null
+ * characters at the start and in between. Replace the null
+ * characters with space, to print the version info.
+ */
+ for (i = 0; i < version_string_size; i++) {
+ if (str_image_version[i] != '\0')
+ version[i] = str_image_version[i];
+ else
+ version[i] = ' ';
+ }
+ version[i] = '\0';
+ dprintk(VIDC_DBG, "F/W version: %s\n", version);
+
+ smem_table_ptr = smem_get_entry(SMEM_IMAGE_VERSION_TABLE,
+ &smem_block_size);
+ if (smem_table_ptr &&
+ ((smem_image_index_venus +
+ version_string_size) <= smem_block_size))
+ memcpy(smem_table_ptr + smem_image_index_venus,
+ str_image_version, version_string_size);
+}
+
+static void hfi_process_sys_property_info(
+ struct hfi_msg_sys_property_info_packet *pkt)
+{
+ if (!pkt) {
dprintk(VIDC_ERR, "%s: invalid param\n", __func__);
return;
}
-
- if (pkt->string_size < sizeof(version)) {
- /*
- * The version string returned by firmware includes null
- * characters at the start and in between. Replace the null
- * characters with space, to print the version info.
- */
- for (i = 0; i < pkt->string_size; i++) {
- if (pkt->str_image_version[i] != '\0')
- version[i] = pkt->str_image_version[i];
- else
- version[i] = ' ';
- }
- version[i] = '\0';
- dprintk(VIDC_DBG, "F/W version: %s\n", version);
+ if (pkt->size < sizeof(*pkt)) {
+ dprintk(VIDC_ERR,
+ "hfi_process_sys_property_info: bad_pkt_size\n");
+ return;
+ }
+ if (pkt->num_properties == 0) {
+ dprintk(VIDC_ERR,
+ "hfi_process_sys_property_info: no_properties\n");
+ return;
}
- smem_table_ptr = smem_get_entry(SMEM_IMAGE_VERSION_TABLE,
- &smem_block_size);
- if (smem_table_ptr &&
- ((smem_image_index_venus + 128) <= smem_block_size))
- memcpy(smem_table_ptr + smem_image_index_venus,
- (u8 *)pkt->str_image_version, 128);
+ switch (pkt->rg_property_data[0]) {
+ case HFI_PROPERTY_SYS_IMAGE_VERSION:
+ hfi_process_sys_get_prop_image_version(pkt);
+ break;
+ default:
+ dprintk(VIDC_ERR,
+ "hfi_process_sys_property_info:unknown_prop_id: %d\n",
+ pkt->rg_property_data[0]);
+ }
}
u32 hfi_process_msg_packet(
@@ -1263,7 +1299,7 @@
break;
case HFI_MSG_SYS_PROPERTY_INFO:
hfi_process_sys_property_info(
- (struct hfi_property_sys_image_version_info_type *)
+ (struct hfi_msg_sys_property_info_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_SESSION_END_DONE:
diff --git a/drivers/media/platform/msm/vidc/msm_vdec.c b/drivers/media/platform/msm/vidc/msm_vdec.c
index 502d4bc..efa195e 100644
--- a/drivers/media/platform/msm/vidc/msm_vdec.c
+++ b/drivers/media/platform/msm/vidc/msm_vdec.c
@@ -1820,7 +1820,7 @@
int msm_vdec_ctrl_init(struct msm_vidc_inst *inst)
{
int idx = 0;
- struct v4l2_ctrl_config ctrl_cfg;
+ struct v4l2_ctrl_config ctrl_cfg = {0};
int ret_val = 0;
ret_val = v4l2_ctrl_handler_init(&inst->ctrl_handler, NUM_CTRLS);
diff --git a/drivers/media/platform/msm/vidc/msm_venc.c b/drivers/media/platform/msm/vidc/msm_venc.c
index f9b5519..c0bf32c 100644
--- a/drivers/media/platform/msm/vidc/msm_venc.c
+++ b/drivers/media/platform/msm/vidc/msm_venc.c
@@ -2662,7 +2662,7 @@
{
int idx = 0;
- struct v4l2_ctrl_config ctrl_cfg;
+ struct v4l2_ctrl_config ctrl_cfg = {0};
int ret_val = 0;
ret_val = v4l2_ctrl_handler_init(&inst->ctrl_handler, NUM_CTRLS);
if (ret_val) {
diff --git a/drivers/media/platform/msm/vidc/q6_hfi.c b/drivers/media/platform/msm/vidc/q6_hfi.c
index 7c99ec3..8e91f34 100644
--- a/drivers/media/platform/msm/vidc/q6_hfi.c
+++ b/drivers/media/platform/msm/vidc/q6_hfi.c
@@ -560,17 +560,28 @@
dprintk(VIDC_ERR, "session_init: failed to create packet");
goto err_session_init;
}
+ /*
+ * Add session id to the list entry and then send the apr pkt.
+ * This will avoid scenarios where apr_send_pkt is taking more
+ * time and Q6 is returning an ack even before the session id
+ * gets added to the session list.
+ */
+ mutex_lock(&dev->session_lock);
+ list_add_tail(&new_session->list, &dev->sess_head);
+ mutex_unlock(&dev->session_lock);
rc = apr_send_pkt(dev->apr, (uint32_t *)&apr);
if (rc != apr.hdr.pkt_size) {
dprintk(VIDC_ERR, "%s: apr_send_pkt failed rc: %d",
__func__, rc);
+ /* Delete the session id as the send pkt is not successful */
+ mutex_lock(&dev->session_lock);
+ list_del(&new_session->list);
+ mutex_unlock(&dev->session_lock);
rc = -EBADE;
goto err_session_init;
}
- mutex_lock(&dev->session_lock);
- list_add_tail(&new_session->list, &dev->sess_head);
- mutex_unlock(&dev->session_lock);
+
return new_session;
err_session_init:
diff --git a/drivers/staging/zram/zram_drv.c b/drivers/staging/zram/zram_drv.c
index 44949d2..91d94b5 100644
--- a/drivers/staging/zram/zram_drv.c
+++ b/drivers/staging/zram/zram_drv.c
@@ -440,6 +440,14 @@
goto out;
}
+ /*
+ * zram_slot_free_notify could miss free so that let's
+ * double check.
+ */
+ if (unlikely(meta->table[index].handle ||
+ zram_test_flag(meta, index, ZRAM_ZERO)))
+ zram_free_page(zram, index);
+
ret = lzo1x_1_compress(uncmem, PAGE_SIZE, src, &clen,
meta->compress_workmem);
@@ -505,6 +513,20 @@
return ret;
}
+static void handle_pending_slot_free(struct zram *zram)
+{
+ struct zram_slot_free *free_rq;
+
+ spin_lock(&zram->slot_free_lock);
+ while (zram->slot_free_rq) {
+ free_rq = zram->slot_free_rq;
+ zram->slot_free_rq = free_rq->next;
+ zram_free_page(zram, free_rq->index);
+ kfree(free_rq);
+ }
+ spin_unlock(&zram->slot_free_lock);
+}
+
static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
int offset, struct bio *bio, int rw)
{
@@ -512,10 +534,12 @@
if (rw == READ) {
down_read(&zram->lock);
+ handle_pending_slot_free(zram);
ret = zram_bvec_read(zram, bvec, index, offset, bio);
up_read(&zram->lock);
} else {
down_write(&zram->lock);
+ handle_pending_slot_free(zram);
ret = zram_bvec_write(zram, bvec, index, offset);
up_write(&zram->lock);
}
@@ -523,11 +547,13 @@
return ret;
}
-static void zram_reset_device(struct zram *zram)
+static void zram_reset_device(struct zram *zram, bool reset_capacity)
{
size_t index;
struct zram_meta *meta;
+ flush_work(&zram->free_work);
+
down_write(&zram->init_lock);
if (!zram->init_done) {
up_write(&zram->init_lock);
@@ -552,7 +578,8 @@
memset(&zram->stats, 0, sizeof(zram->stats));
zram->disksize = 0;
- set_capacity(zram->disk, 0);
+ if (reset_capacity)
+ set_capacity(zram->disk, 0);
up_write(&zram->init_lock);
}
@@ -636,7 +663,7 @@
if (bdev)
fsync_bdev(bdev);
- zram_reset_device(zram);
+ zram_reset_device(zram, true);
return len;
}
@@ -721,16 +748,40 @@
bio_io_error(bio);
}
+static void zram_slot_free(struct work_struct *work)
+{
+ struct zram *zram;
+
+ zram = container_of(work, struct zram, free_work);
+ down_write(&zram->lock);
+ handle_pending_slot_free(zram);
+ up_write(&zram->lock);
+}
+
+static void add_slot_free(struct zram *zram, struct zram_slot_free *free_rq)
+{
+ spin_lock(&zram->slot_free_lock);
+ free_rq->next = zram->slot_free_rq;
+ zram->slot_free_rq = free_rq;
+ spin_unlock(&zram->slot_free_lock);
+}
+
static void zram_slot_free_notify(struct block_device *bdev,
unsigned long index)
{
struct zram *zram;
+ struct zram_slot_free *free_rq;
zram = bdev->bd_disk->private_data;
- down_write(&zram->lock);
- zram_free_page(zram, index);
- up_write(&zram->lock);
atomic64_inc(&zram->stats.notify_free);
+
+ free_rq = kmalloc(sizeof(struct zram_slot_free), GFP_ATOMIC);
+ if (!free_rq)
+ return;
+
+ free_rq->index = index;
+ add_slot_free(zram, free_rq);
+ schedule_work(&zram->free_work);
}
static const struct block_device_operations zram_devops = {
@@ -777,6 +828,10 @@
init_rwsem(&zram->lock);
init_rwsem(&zram->init_lock);
+ INIT_WORK(&zram->free_work, zram_slot_free);
+ spin_lock_init(&zram->slot_free_lock);
+ zram->slot_free_rq = NULL;
+
zram->queue = blk_alloc_queue(GFP_KERNEL);
if (!zram->queue) {
pr_err("Error allocating disk queue for device %d\n",
@@ -903,10 +958,12 @@
for (i = 0; i < num_devices; i++) {
zram = &zram_devices[i];
- get_disk(zram->disk);
destroy_device(zram);
- zram_reset_device(zram);
- put_disk(zram->disk);
+ /*
+ * Shouldn't access zram->disk after destroy_device
+ * because destroy_device already released zram->disk.
+ */
+ zram_reset_device(zram, false);
}
unregister_blkdev(zram_major, "zram");
diff --git a/drivers/staging/zram/zram_drv.h b/drivers/staging/zram/zram_drv.h
index 9e57bfb..97a3acf 100644
--- a/drivers/staging/zram/zram_drv.h
+++ b/drivers/staging/zram/zram_drv.h
@@ -94,11 +94,20 @@
struct zs_pool *mem_pool;
};
+struct zram_slot_free {
+ unsigned long index;
+ struct zram_slot_free *next;
+};
+
struct zram {
struct zram_meta *meta;
struct rw_semaphore lock; /* protect compression buffers, table,
* 32bit stat counters against concurrent
* notifications, reads and writes */
+
+ struct work_struct free_work; /* handle pending free request */
+ struct zram_slot_free *slot_free_rq; /* list head of free request */
+
struct request_queue *queue;
struct gendisk *disk;
int init_done;
@@ -109,6 +118,7 @@
* we can store in a disk.
*/
u64 disksize; /* bytes */
+ spinlock_t slot_free_lock;
struct zram_stats stats;
};
diff --git a/drivers/video/msm/mdss/dsi_host_v2.c b/drivers/video/msm/mdss/dsi_host_v2.c
index e416a55..7d57f64 100644
--- a/drivers/video/msm/mdss/dsi_host_v2.c
+++ b/drivers/video/msm/mdss/dsi_host_v2.c
@@ -77,7 +77,7 @@
if (status) {
MIPI_OUTP(ctrl_base + DSI_ACK_ERR_STATUS, status);
- pr_debug("%s: status=%x\n", __func__, status);
+ pr_err("%s: status=%x\n", __func__, status);
}
}
@@ -88,7 +88,7 @@
status = MIPI_INP(ctrl_base + DSI_TIMEOUT_STATUS);
if (status & 0x0111) {
MIPI_OUTP(ctrl_base + DSI_TIMEOUT_STATUS, status);
- pr_debug("%s: status=%x\n", __func__, status);
+ pr_err("%s: status=%x\n", __func__, status);
}
}
@@ -100,7 +100,7 @@
if (status & 0x011111) {
MIPI_OUTP(ctrl_base + DSI_DLN0_PHY_ERR, status);
- pr_debug("%s: status=%x\n", __func__, status);
+ pr_err("%s: status=%x\n", __func__, status);
}
}
@@ -112,7 +112,7 @@
if (status & 0x44444489) {
MIPI_OUTP(ctrl_base + DSI_FIFO_STATUS, status);
- pr_debug("%s: status=%x\n", __func__, status);
+ pr_err("%s: status=%x\n", __func__, status);
}
}
@@ -124,7 +124,7 @@
if (status & 0x80000000) {
MIPI_OUTP(ctrl_base + DSI_STATUS, status);
- pr_debug("%s: status=%x\n", __func__, status);
+ pr_err("%s: status=%x\n", __func__, status);
}
}
diff --git a/drivers/video/msm/mdss/mdp3.c b/drivers/video/msm/mdss/mdp3.c
index 638fcb3..fe8c528 100644
--- a/drivers/video/msm/mdss/mdp3.c
+++ b/drivers/video/msm/mdss/mdp3.c
@@ -1859,6 +1859,52 @@
mdp3_res->underrun_cnt);
}
+static ssize_t mdp3_show_capabilities(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ size_t len = PAGE_SIZE;
+ int cnt = 0;
+
+#define SPRINT(fmt, ...) \
+ (cnt += scnprintf(buf + cnt, len - cnt, fmt, ##__VA_ARGS__))
+
+ SPRINT("mdp_version=3\n");
+ SPRINT("hw_rev=%d\n", 304);
+ SPRINT("dma_pipes=%d\n", 1);
+ SPRINT("\n");
+
+ return cnt;
+}
+
+static DEVICE_ATTR(caps, S_IRUGO, mdp3_show_capabilities, NULL);
+
+static struct attribute *mdp3_fs_attrs[] = {
+ &dev_attr_caps.attr,
+ NULL
+};
+
+static struct attribute_group mdp3_fs_attr_group = {
+ .attrs = mdp3_fs_attrs
+};
+
+static int mdp3_register_sysfs(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ int rc;
+
+ rc = sysfs_create_group(&dev->kobj, &mdp3_fs_attr_group);
+
+ return rc;
+}
+
+int mdp3_create_sysfs_link(struct device *dev)
+{
+ int rc;
+ rc = sysfs_create_link_nowarn(&dev->kobj,
+ &mdp3_res->pdev->dev.kobj, "mdp");
+
+ return rc;
+}
static int mdp3_probe(struct platform_device *pdev)
{
@@ -1918,6 +1964,10 @@
goto probe_done;
}
+ rc = mdp3_register_sysfs(pdev);
+ if (rc)
+ pr_err("unable to register mdp sysfs nodes\n");
+
rc = mdss_fb_register_mdp_instance(&mdp3_interface);
if (rc)
pr_err("unable to register mdp instance\n");
diff --git a/drivers/video/msm/mdss/mdp3.h b/drivers/video/msm/mdss/mdp3.h
index 4480c20..e66b5ac 100644
--- a/drivers/video/msm/mdss/mdp3.h
+++ b/drivers/video/msm/mdss/mdp3.h
@@ -186,6 +186,7 @@
void mdp3_free(void);
int mdp3_parse_dt_splash(struct msm_fb_data_type *mfd);
void mdp3_release_splash_memory(void);
+int mdp3_create_sysfs_link(struct device *dev);
#define MDP3_REG_WRITE(addr, val) writel_relaxed(val, mdp3_res->mdp_base + addr)
#define MDP3_REG_READ(addr) readl_relaxed(mdp3_res->mdp_base + addr)
diff --git a/drivers/video/msm/mdss/mdp3_ctrl.c b/drivers/video/msm/mdss/mdp3_ctrl.c
index e92e178..994e3e0 100644
--- a/drivers/video/msm/mdss/mdp3_ctrl.c
+++ b/drivers/video/msm/mdss/mdp3_ctrl.c
@@ -1355,7 +1355,7 @@
int rc = -EINVAL;
struct mdp3_session_data *mdp3_session;
struct msmfb_metadata metadata;
- struct mdp_overlay req;
+ struct mdp_overlay *req = NULL;
struct msmfb_overlay_data ov_data;
int val;
@@ -1363,6 +1363,8 @@
if (!mdp3_session)
return -ENODEV;
+ req = &mdp3_session->req_overlay;
+
if (!mdp3_session->status && cmd != MSMFB_METADATA_GET) {
pr_err("mdp3_ctrl_ioctl_handler, display off!\n");
return -EPERM;
@@ -1402,23 +1404,23 @@
rc = copy_to_user(argp, &metadata, sizeof(metadata));
break;
case MSMFB_OVERLAY_GET:
- rc = copy_from_user(&req, argp, sizeof(req));
+ rc = copy_from_user(req, argp, sizeof(*req));
if (!rc) {
- rc = mdp3_overlay_get(mfd, &req);
+ rc = mdp3_overlay_get(mfd, req);
if (!IS_ERR_VALUE(rc))
- rc = copy_to_user(argp, &req, sizeof(req));
+ rc = copy_to_user(argp, req, sizeof(*req));
}
if (rc)
pr_err("OVERLAY_GET failed (%d)\n", rc);
break;
case MSMFB_OVERLAY_SET:
- rc = copy_from_user(&req, argp, sizeof(req));
+ rc = copy_from_user(req, argp, sizeof(*req));
if (!rc) {
- rc = mdp3_overlay_set(mfd, &req);
+ rc = mdp3_overlay_set(mfd, req);
if (!IS_ERR_VALUE(rc))
- rc = copy_to_user(argp, &req, sizeof(req));
+ rc = copy_to_user(argp, req, sizeof(*req));
}
if (rc)
pr_err("OVERLAY_SET failed (%d)\n", rc);
@@ -1525,6 +1527,10 @@
goto init_done;
}
+ rc = mdp3_create_sysfs_link(dev);
+ if (rc)
+ pr_warn("problem creating link to mdp sysfs\n");
+
kobject_uevent(&dev->kobj, KOBJ_ADD);
pr_debug("vsync kobject_uevent(KOBJ_ADD)\n");
diff --git a/drivers/video/msm/mdss/mdp3_ctrl.h b/drivers/video/msm/mdss/mdp3_ctrl.h
index 7c4f6ac..66ed3d5 100644
--- a/drivers/video/msm/mdss/mdp3_ctrl.h
+++ b/drivers/video/msm/mdss/mdp3_ctrl.h
@@ -45,6 +45,7 @@
int vsync_period;
struct sysfs_dirent *vsync_event_sd;
struct mdp_overlay overlay;
+ struct mdp_overlay req_overlay;
struct mdp3_buffer_queue bufq_in;
struct mdp3_buffer_queue bufq_out;
int histo_status;
diff --git a/drivers/video/msm/mdss/mdss_fb.c b/drivers/video/msm/mdss/mdss_fb.c
index 971351b..047c0f0 100644
--- a/drivers/video/msm/mdss/mdss_fb.c
+++ b/drivers/video/msm/mdss/mdss_fb.c
@@ -1969,7 +1969,8 @@
return -EINVAL;
mfd = (struct msm_fb_data_type *)info->par;
mdss_fb_power_setting_idle(mfd);
- if ((cmd != MSMFB_VSYNC_CTRL) && (cmd != MSMFB_OVERLAY_VSYNC_CTRL))
+ if ((cmd != MSMFB_VSYNC_CTRL) && (cmd != MSMFB_OVERLAY_VSYNC_CTRL) &&
+ (cmd != MSMFB_ASYNC_BLIT) && (cmd != MSMFB_BLIT))
mdss_fb_pan_idle(mfd);
switch (cmd) {
diff --git a/drivers/video/msm/mdss/mdss_hdmi_edid.c b/drivers/video/msm/mdss/mdss_hdmi_edid.c
index cf0c287..5174cab 100644
--- a/drivers/video/msm/mdss/mdss_hdmi_edid.c
+++ b/drivers/video/msm/mdss/mdss_hdmi_edid.c
@@ -16,6 +16,13 @@
#include "mdss_hdmi_edid.h"
#define DBC_START_OFFSET 4
+
+/*
+ * As per CEA-861-E specification 7.5.2, there can be
+ * upto 31 bytes following any tag (data block type).
+ */
+#define MAX_DATA_BLOCK_SIZE 31
+
#define HDMI_VSDB_3D_EVF_DATA_OFFSET(vsd) \
(!((vsd)[8] & BIT(7)) ? 9 : (!((vsd)[8] & BIT(6)) ? 11 : 13))
@@ -32,6 +39,19 @@
/* Support for first 5 EDID blocks */
#define MAX_EDID_BLOCK_SIZE (0x80 * 5)
+#define BUFF_SIZE_3D 128
+
+enum data_block_types {
+ RESERVED,
+ AUDIO_DATA_BLOCK,
+ VIDEO_DATA_BLOCK,
+ VENDOR_SPECIFIC_DATA_BLOCK,
+ SPEAKER_ALLOCATION_DATA_BLOCK,
+ VESA_DTC_DATA_BLOCK,
+ RESERVED2,
+ USE_EXTENDED_TAG
+};
+
struct hdmi_edid_sink_data {
u32 disp_mode_list[HDMI_VFRMT_MAX];
u32 disp_3d_mode_list[HDMI_VFRMT_MAX];
@@ -524,7 +544,8 @@
}
/* A Tage code of 7 identifies extended data blocks */
- etag = hdmi_edid_find_block(in_buf, start_offset, 7, &len);
+ etag = hdmi_edid_find_block(in_buf, start_offset, USE_EXTENDED_TAG,
+ &len);
while (etag != NULL) {
/* The extended data block should at least be 2 bytes long */
@@ -570,7 +591,8 @@
/* There could be more that one extended data block */
start_offset = etag - in_buf + len + 1;
- etag = hdmi_edid_find_block(in_buf, start_offset, 7, &len);
+ etag = hdmi_edid_find_block(in_buf, start_offset,
+ USE_EXTENDED_TAG, &len);
}
} /* hdmi_edid_extract_extended_data_blocks */
@@ -585,11 +607,12 @@
return;
}
- vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 3, &len);
+ vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET,
+ VENDOR_SPECIFIC_DATA_BLOCK, &len);
edid_ctrl->present_3d = 0;
- if (vsd == NULL || len < 9) {
- DEV_DBG("%s: blk-id 3 not found or not long enough\n",
+ if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) {
+ DEV_DBG("%s: No/Invalid vendor Specific Data Block\n",
__func__);
return;
}
@@ -616,9 +639,13 @@
return;
}
- adb = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 1, &len);
- if ((adb == NULL) || (len > MAX_AUDIO_DATA_BLOCK_SIZE))
+ adb = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, AUDIO_DATA_BLOCK,
+ &len);
+ if ((adb == NULL) || (len > MAX_AUDIO_DATA_BLOCK_SIZE)) {
+ DEV_DBG("%s: No/Invalid Audio Data Block\n",
+ __func__);
return;
+ }
memcpy(edid_ctrl->audio_data_block, adb + 1, len);
edid_ctrl->adb_size = len;
@@ -644,9 +671,13 @@
return;
}
- sadb = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 4, &len);
- if ((sadb == NULL) || (len != MAX_SPKR_ALLOC_DATA_BLOCK_SIZE))
+ sadb = hdmi_edid_find_block(in_buf, DBC_START_OFFSET,
+ SPEAKER_ALLOCATION_DATA_BLOCK, &len);
+ if ((sadb == NULL) || (len != MAX_SPKR_ALLOC_DATA_BLOCK_SIZE)) {
+ DEV_DBG("%s: No/Invalid Speaker Allocation Data Block\n",
+ __func__);
return;
+ }
memcpy(edid_ctrl->spkr_alloc_data_block, sadb + 1, len);
edid_ctrl->sadb_size = len;
@@ -673,9 +704,11 @@
return;
}
- vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 3, &len);
+ vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET,
+ VENDOR_SPECIFIC_DATA_BLOCK, &len);
- if (vsd == NULL || len < 12 || !(vsd[8] & BIT(7))) {
+ if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE ||
+ !(vsd[8] & BIT(7))) {
edid_ctrl->video_latency = (u16)-1;
edid_ctrl->audio_latency = (u16)-1;
DEV_DBG("%s: EDID: No audio/video latency present\n", __func__);
@@ -699,9 +732,14 @@
return 0;
}
- vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 3, &len);
- if (vsd == NULL || len < 8)
+ vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET,
+ VENDOR_SPECIFIC_DATA_BLOCK, &len);
+
+ if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) {
+ DEV_DBG("%s: No/Invalid Vendor Specific Data Block\n",
+ __func__);
return 0;
+ }
DEV_DBG("%s: EDID: VSD PhyAddr=%04x, MaxTMDS=%dMHz\n", __func__,
((u32)vsd[4] << 8) + (u32)vsd[5], (u32)vsd[7] * 5);
@@ -898,11 +936,14 @@
u16 structure_all, structure_mask;
const u8 *vsd = num_of_cea_blocks ?
hdmi_edid_find_block(data_buf+0x80, DBC_START_OFFSET,
- 3, &len) : NULL;
+ VENDOR_SPECIFIC_DATA_BLOCK, &len) : NULL;
int i;
- if (!vsd)
+ if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) {
+ DEV_DBG("%s: No/Invalid Vendor Specific Data Block\n",
+ __func__);
return -ENXIO;
+ }
offset = HDMI_VSDB_3D_EVF_DATA_OFFSET(vsd);
if (offset >= len - 1)
@@ -1044,10 +1085,11 @@
return;
}
- vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, 3, &db_len);
+ vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET,
+ VENDOR_SPECIFIC_DATA_BLOCK, &db_len);
- if (vsd == NULL || db_len < 9) {
- DEV_DBG("%s: blk-id 3 not found or not long enough\n",
+ if (vsd == NULL || db_len == 0 || db_len > MAX_DATA_BLOCK_SIZE) {
+ DEV_DBG("%s: No/Invalid Vendor Specific Data Block\n",
__func__);
return;
}
@@ -1097,8 +1139,14 @@
edid_blk0 = &data_buf[0x0];
edid_blk1 = &data_buf[0x80];
svd = num_of_cea_blocks ?
- hdmi_edid_find_block(data_buf+0x80, DBC_START_OFFSET, 2,
- &len) : NULL;
+ hdmi_edid_find_block(data_buf+0x80, DBC_START_OFFSET,
+ VIDEO_DATA_BLOCK, &len) : NULL;
+
+ if (svd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) {
+ DEV_DBG("%s: No/Invalid Video Data Block\n",
+ __func__);
+ return;
+ }
sink_data = &edid_ctrl->sink_data;
diff --git a/drivers/video/msm/mdss/mdss_hdmi_hdcp.c b/drivers/video/msm/mdss/mdss_hdmi_hdcp.c
index 80b27ed..ca21b51 100644
--- a/drivers/video/msm/mdss/mdss_hdmi_hdcp.c
+++ b/drivers/video/msm/mdss/mdss_hdmi_hdcp.c
@@ -289,6 +289,10 @@
}
DEV_DBG("%s: %s: BCAPS=%02x\n", __func__, HDCP_STATE_NAME, bcaps);
+ /* receiver (0), repeater (1) */
+ hdcp_ctrl->current_tp.ds_type =
+ (bcaps & BIT(6)) >> 6 ? DS_REPEATER : DS_RECEIVER;
+
/*
* HDCP setup prior to enabling HDCP_CTRL.
* Setup seed values for random number An.
@@ -644,40 +648,12 @@
memset(ksv_fifo, 0,
sizeof(hdcp_ctrl->current_tp.ksv_list));
- /* Read BCAPS at offset 0x40 */
- memset(&ddc_data, 0, sizeof(ddc_data));
- ddc_data.dev_addr = 0x74;
- ddc_data.offset = 0x40;
- ddc_data.data_buf = &bcaps;
- ddc_data.data_len = 1;
- ddc_data.request_len = 1;
- ddc_data.retry = 5;
- ddc_data.what = "Bcaps";
- ddc_data.no_align = false;
- rc = hdmi_ddc_read(hdcp_ctrl->init_data.ddc_ctrl, &ddc_data);
- if (rc) {
- DEV_ERR("%s: %s: BCAPS read failed\n", __func__,
- HDCP_STATE_NAME);
- goto error;
- }
- DEV_DBG("%s: %s: BCAPS=%02x (%s)\n", __func__, HDCP_STATE_NAME, bcaps,
- (bcaps & BIT(6)) ? "repeater" : "no repeater");
-
- /* receiver (0), repeater (1) */
- hdcp_ctrl->current_tp.ds_type =
- (bcaps & BIT(6)) >> 6 ? DS_REPEATER : DS_RECEIVER;
-
- /* if REPEATER (Bit 6), perform Part2 Authentication */
- if (!(bcaps & BIT(6))) {
- DEV_INFO("%s: %s: auth part II skipped, no repeater\n",
- __func__, HDCP_STATE_NAME);
- return 0;
- }
-
- /* Wait until READY bit is set in BCAPS */
+ /*
+ * Wait until READY bit is set in BCAPS, as per HDCP specifications
+ * maximum permitted time to check for READY bit is five seconds.
+ */
timeout_count = 50;
- while (!(bcaps & BIT(5)) && timeout_count) {
- msleep(100);
+ do {
timeout_count--;
/* Read BCAPS at offset 0x40 */
memset(&ddc_data, 0, sizeof(ddc_data));
@@ -695,7 +671,8 @@
HDCP_STATE_NAME);
goto error;
}
- }
+ msleep(100);
+ } while (!(bcaps & BIT(5)) && timeout_count);
/* Read BSTATUS at offset 0x41 */
memset(&ddc_data, 0, sizeof(ddc_data));
@@ -976,11 +953,15 @@
goto error;
}
- rc = hdmi_hdcp_authentication_part2(hdcp_ctrl);
- if (rc) {
- DEV_DBG("%s: %s: HDCP Auth Part II failed\n", __func__,
- HDCP_STATE_NAME);
- goto error;
+ if (hdcp_ctrl->current_tp.ds_type == DS_REPEATER) {
+ rc = hdmi_hdcp_authentication_part2(hdcp_ctrl);
+ if (rc) {
+ DEV_DBG("%s: %s: HDCP Auth Part II failed\n", __func__,
+ HDCP_STATE_NAME);
+ goto error;
+ }
+ } else {
+ DEV_INFO("%s: Downstream device is not a repeater\n", __func__);
}
/* Disabling software DDC before going into part3 to make sure
* there is no Arbitration between software and hardware for DDC */
diff --git a/drivers/video/msm/mdss/mdss_hdmi_tx.c b/drivers/video/msm/mdss/mdss_hdmi_tx.c
index e46e361..abb72ad 100644
--- a/drivers/video/msm/mdss/mdss_hdmi_tx.c
+++ b/drivers/video/msm/mdss/mdss_hdmi_tx.c
@@ -2456,6 +2456,10 @@
mutex_unlock(&hdmi_ctrl->mutex);
DEV_INFO("%s: HDMI Core: OFF\n", __func__);
+
+ if (hdmi_ctrl->hdmi_tx_hpd_done)
+ hdmi_ctrl->hdmi_tx_hpd_done(
+ hdmi_ctrl->downstream_data);
} /* hdmi_tx_power_off_work */
static int hdmi_tx_power_off(struct mdss_panel_data *panel_data)
@@ -2558,6 +2562,9 @@
hdmi_tx_hpd_polarity_setup(hdmi_ctrl, HPD_DISCONNECT_POLARITY);
+ if (hdmi_ctrl->hdmi_tx_hpd_done)
+ hdmi_ctrl->hdmi_tx_hpd_done(hdmi_ctrl->downstream_data);
+
return 0;
} /* hdmi_tx_power_on */
diff --git a/drivers/video/msm/mdss/mdss_hdmi_tx.h b/drivers/video/msm/mdss/mdss_hdmi_tx.h
index fd95582..c4d0326 100644
--- a/drivers/video/msm/mdss/mdss_hdmi_tx.h
+++ b/drivers/video/msm/mdss/mdss_hdmi_tx.h
@@ -84,6 +84,9 @@
struct hdmi_tx_ddc_ctrl ddc_ctrl;
+ void (*hdmi_tx_hpd_done) (void *data);
+ void *downstream_data;
+
void *feature_data[HDMI_TX_FEAT_MAX];
};
diff --git a/drivers/video/msm/mdss/mdss_mdp_ctl.c b/drivers/video/msm/mdss/mdss_mdp_ctl.c
index 4f9045e..aa7c4dd 100644
--- a/drivers/video/msm/mdss/mdss_mdp_ctl.c
+++ b/drivers/video/msm/mdss/mdss_mdp_ctl.c
@@ -1560,9 +1560,17 @@
struct mdss_mdp_mixer *mdss_mdp_mixer_get(struct mdss_mdp_ctl *ctl, int mux)
{
struct mdss_mdp_mixer *mixer = NULL;
- struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(ctl->mfd);
- if (!ctl)
+ struct mdss_overlay_private *mdp5_data = NULL;
+ if (!ctl || !ctl->mfd) {
+ pr_err("ctl not initialized\n");
return NULL;
+ }
+
+ mdp5_data = mfd_to_mdp5_data(ctl->mfd);
+ if (!mdp5_data) {
+ pr_err("ctl not initialized\n");
+ return NULL;
+ }
switch (mux) {
case MDSS_MDP_MIXER_MUX_DEFAULT:
diff --git a/drivers/video/msm/mdss/mdss_mdp_intf_video.c b/drivers/video/msm/mdss/mdss_mdp_intf_video.c
index 7c79ceb..bd1c3eb 100644
--- a/drivers/video/msm/mdss/mdss_mdp_intf_video.c
+++ b/drivers/video/msm/mdss/mdss_mdp_intf_video.c
@@ -294,6 +294,7 @@
struct mdss_mdp_video_ctx *ctx;
struct mdss_mdp_vsync_handler *tmp, *handle;
int rc;
+ u32 frame_rate = 0;
pr_debug("stop ctl=%d\n", ctl->num);
@@ -313,6 +314,14 @@
WARN(rc, "intf %d blank error (%d)\n", ctl->intf_num, rc);
mdp_video_write(ctx, MDSS_MDP_REG_INTF_TIMING_ENGINE_EN, 0);
+ /* wait for at least one VSYNC on HDMI intf for proper TG OFF */
+ if (MDSS_INTF_HDMI == ctx->intf_type) {
+ frame_rate = mdss_panel_get_framerate
+ (&(ctl->panel_data->panel_info));
+ if (!(frame_rate >= 24 && frame_rate <= 240))
+ frame_rate = 24;
+ msleep((1000/frame_rate) + 1);
+ }
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false);
ctx->timegen_en = false;
@@ -429,10 +438,9 @@
} else {
rc = 0;
}
-
- mdss_mdp_ctl_notify(ctl,
- rc ? MDP_NOTIFY_FRAME_TIMEOUT : MDP_NOTIFY_FRAME_DONE);
}
+ mdss_mdp_ctl_notify(ctl,
+ rc ? MDP_NOTIFY_FRAME_TIMEOUT : MDP_NOTIFY_FRAME_DONE);
if (ctx->wait_pending) {
ctx->wait_pending = 0;
diff --git a/mm/page_io.c b/mm/page_io.c
index dc76b4d..e60e43f 100644
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -1,3 +1,4 @@
+
/*
* linux/mm/page_io.c
*
@@ -18,6 +19,7 @@
#include <linux/bio.h>
#include <linux/swapops.h>
#include <linux/writeback.h>
+#include <linux/blkdev.h>
#include <asm/pgtable.h>
static struct bio *get_swap_bio(gfp_t gfp_flags,
@@ -78,9 +80,54 @@
imajor(bio->bi_bdev->bd_inode),
iminor(bio->bi_bdev->bd_inode),
(unsigned long long)bio->bi_sector);
- } else {
- SetPageUptodate(page);
+ goto out;
}
+
+ SetPageUptodate(page);
+
+ /*
+ * There is no guarantee that the page is in swap cache - the software
+ * suspend code (at least) uses end_swap_bio_read() against a non-
+ * swapcache page. So we must check PG_swapcache before proceeding with
+ * this optimization.
+ */
+ if (likely(PageSwapCache(page))) {
+ struct swap_info_struct *sis;
+
+ sis = page_swap_info(page);
+ if (sis->flags & SWP_BLKDEV) {
+ /*
+ * The swap subsystem performs lazy swap slot freeing,
+ * expecting that the page will be swapped out again.
+ * So we can avoid an unnecessary write if the page
+ * isn't redirtied.
+ * This is good for real swap storage because we can
+ * reduce unnecessary I/O and enhance wear-leveling
+ * if an SSD is used as the as swap device.
+ * But if in-memory swap device (eg zram) is used,
+ * this causes a duplicated copy between uncompressed
+ * data in VM-owned memory and compressed data in
+ * zram-owned memory. So let's free zram-owned memory
+ * and make the VM-owned decompressed page *dirty*,
+ * so the page should be swapped out somewhere again if
+ * we again wish to reclaim it.
+ */
+ struct gendisk *disk = sis->bdev->bd_disk;
+ if (disk->fops->swap_slot_free_notify) {
+ swp_entry_t entry;
+ unsigned long offset;
+
+ entry.val = page_private(page);
+ offset = swp_offset(entry);
+
+ SetPageDirty(page);
+ disk->fops->swap_slot_free_notify(sis->bdev,
+ offset);
+ }
+ }
+ }
+
+out:
unlock_page(page);
bio_put(bio);
}
diff --git a/sound/soc/msm/qdsp6v2/audio_acdb.c b/sound/soc/msm/qdsp6v2/audio_acdb.c
index 01422cf..8187616 100644
--- a/sound/soc/msm/qdsp6v2/audio_acdb.c
+++ b/sound/soc/msm/qdsp6v2/audio_acdb.c
@@ -38,64 +38,60 @@
#define MAX_HW_DELAY_ENTRIES 25
-struct sidetone_atomic_cal {
- atomic_t enable;
- atomic_t gain;
-};
-
-
struct acdb_data {
+ uint32_t usage_count;
+
struct mutex acdb_mutex;
/* ANC Cal */
- struct acdb_atomic_cal_block anc_cal;
+ struct acdb_cal_block anc_cal;
/* AANC Cal */
- struct acdb_atomic_cal_block aanc_cal;
+ struct acdb_cal_block aanc_cal;
/* LSM Cal */
- struct acdb_atomic_cal_block lsm_cal;
+ struct acdb_cal_block lsm_cal;
/* AudProc Cal */
- atomic_t asm_topology;
- atomic_t adm_topology[MAX_AUDPROC_TYPES];
- struct acdb_atomic_cal_block audproc_cal[MAX_AUDPROC_TYPES];
- struct acdb_atomic_cal_block audstrm_cal[MAX_AUDPROC_TYPES];
- struct acdb_atomic_cal_block audvol_cal[MAX_AUDPROC_TYPES];
+ uint32_t asm_topology;
+ uint32_t adm_topology[MAX_AUDPROC_TYPES];
+ struct acdb_cal_block audproc_cal[MAX_AUDPROC_TYPES];
+ struct acdb_cal_block audstrm_cal[MAX_AUDPROC_TYPES];
+ struct acdb_cal_block audvol_cal[MAX_AUDPROC_TYPES];
/* VocProc Cal */
- atomic_t voice_rx_topology;
- atomic_t voice_tx_topology;
- struct acdb_atomic_cal_block vocproc_cal;
- struct acdb_atomic_cal_block vocstrm_cal;
- struct acdb_atomic_cal_block vocvol_cal;
+ uint32_t voice_rx_topology;
+ uint32_t voice_tx_topology;
+ struct acdb_cal_block vocproc_cal;
+ struct acdb_cal_block vocstrm_cal;
+ struct acdb_cal_block vocvol_cal;
/* Voice Column data */
- struct acdb_atomic_cal_block vocproc_col_cal[MAX_VOCPROC_TYPES];
+ struct acdb_cal_block vocproc_col_cal[MAX_VOCPROC_TYPES];
uint32_t *col_data[MAX_VOCPROC_TYPES];
/* VocProc dev cfg cal*/
- struct acdb_atomic_cal_block vocproc_dev_cal;
+ struct acdb_cal_block vocproc_dev_cal;
/* Custom topology */
- struct acdb_atomic_cal_block adm_custom_topology;
- struct acdb_atomic_cal_block asm_custom_topology;
- atomic_t valid_adm_custom_top;
- atomic_t valid_asm_custom_top;
+ struct acdb_cal_block adm_custom_topology;
+ struct acdb_cal_block asm_custom_topology;
+ uint32_t valid_adm_custom_top;
+ uint32_t valid_asm_custom_top;
/* AFE cal */
- struct acdb_atomic_cal_block afe_cal[MAX_AUDPROC_TYPES];
+ struct acdb_cal_block afe_cal[MAX_AUDPROC_TYPES];
/* Sidetone Cal */
- struct sidetone_atomic_cal sidetone_cal;
+ struct sidetone_cal sidetone_cal;
/* Allocation information */
struct ion_client *ion_client;
struct ion_handle *ion_handle;
- atomic_t map_handle;
- atomic64_t paddr;
- atomic64_t kvaddr;
- atomic64_t mem_len;
+ uint32_t map_handle;
+ uint64_t paddr;
+ uint64_t kvaddr;
+ uint64_t mem_len;
/* Speaker protection */
struct msm_spk_prot_cfg spk_prot_cfg;
@@ -106,62 +102,63 @@
};
static struct acdb_data acdb_data;
-static atomic_t usage_count;
uint32_t get_voice_rx_topology(void)
{
- return atomic_read(&acdb_data.voice_rx_topology);
+ return acdb_data.voice_rx_topology;
}
void store_voice_rx_topology(uint32_t topology)
{
- atomic_set(&acdb_data.voice_rx_topology, topology);
+ acdb_data.voice_rx_topology = topology;
}
uint32_t get_voice_tx_topology(void)
{
- return atomic_read(&acdb_data.voice_tx_topology);
+ return acdb_data.voice_tx_topology;
}
void store_voice_tx_topology(uint32_t topology)
{
- atomic_set(&acdb_data.voice_tx_topology, topology);
+ acdb_data.voice_tx_topology = topology;
}
uint32_t get_adm_rx_topology(void)
{
- return atomic_read(&acdb_data.adm_topology[RX_CAL]);
+ return acdb_data.adm_topology[RX_CAL];
}
void store_adm_rx_topology(uint32_t topology)
{
- atomic_set(&acdb_data.adm_topology[RX_CAL], topology);
+ acdb_data.adm_topology[RX_CAL] = topology;
}
uint32_t get_adm_tx_topology(void)
{
- return atomic_read(&acdb_data.adm_topology[TX_CAL]);
+ return acdb_data.adm_topology[TX_CAL];
}
void store_adm_tx_topology(uint32_t topology)
{
- atomic_set(&acdb_data.adm_topology[TX_CAL], topology);
+ acdb_data.adm_topology[TX_CAL] = topology;
}
uint32_t get_asm_topology(void)
{
- return atomic_read(&acdb_data.asm_topology);
+ return acdb_data.asm_topology;
}
void store_asm_topology(uint32_t topology)
{
- atomic_set(&acdb_data.asm_topology, topology);
+ acdb_data.asm_topology = topology;
}
void reset_custom_topology_flags(void)
{
- atomic_set(&acdb_data.valid_adm_custom_top, 1);
- atomic_set(&acdb_data.valid_asm_custom_top, 1);
+ mutex_lock(&acdb_data.acdb_mutex);
+ acdb_data.valid_adm_custom_top = 1;
+ acdb_data.valid_asm_custom_top = 1;
+ mutex_unlock(&acdb_data.acdb_mutex);
}
int get_adm_custom_topology(struct acdb_cal_block *cal_block)
@@ -175,19 +172,19 @@
goto done;
}
+ mutex_lock(&acdb_data.acdb_mutex);
/* Only return allow one access after memory registered */
- if (atomic_read(&acdb_data.valid_adm_custom_top) == 0) {
+ if (acdb_data.valid_adm_custom_top == 0) {
cal_block->cal_size = 0;
- goto done;
+ goto unlock;
}
- atomic_set(&acdb_data.valid_adm_custom_top, 0);
+ acdb_data.valid_adm_custom_top = 0;
- cal_block->cal_size =
- atomic_read(&acdb_data.adm_custom_topology.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.adm_custom_topology.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.adm_custom_topology.cal_kvaddr);
+ cal_block->cal_size = acdb_data.adm_custom_topology.cal_size;
+ cal_block->cal_paddr = acdb_data.adm_custom_topology.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.adm_custom_topology.cal_kvaddr;
+unlock:
+ mutex_unlock(&acdb_data.acdb_mutex);
done:
return result;
}
@@ -197,21 +194,18 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.adm_custom_topology.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.adm_custom_topology.cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.adm_custom_topology.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
+ acdb_data.adm_custom_topology.cal_size = cal_block->cal_size;
+ acdb_data.adm_custom_topology.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.adm_custom_topology.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -227,19 +221,19 @@
goto done;
}
+ mutex_lock(&acdb_data.acdb_mutex);
/* Only return allow one access after memory registered */
- if (atomic_read(&acdb_data.valid_asm_custom_top) == 0) {
+ if (acdb_data.valid_asm_custom_top == 0) {
cal_block->cal_size = 0;
- goto done;
+ goto unlock;
}
- atomic_set(&acdb_data.valid_asm_custom_top, 0);
+ acdb_data.valid_asm_custom_top = 0;
- cal_block->cal_size =
- atomic_read(&acdb_data.asm_custom_topology.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.asm_custom_topology.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.asm_custom_topology.cal_kvaddr);
+ cal_block->cal_size = acdb_data.asm_custom_topology.cal_size;
+ cal_block->cal_paddr = acdb_data.asm_custom_topology.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.asm_custom_topology.cal_kvaddr;
+unlock:
+ mutex_unlock(&acdb_data.acdb_mutex);
done:
return result;
}
@@ -249,21 +243,18 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.asm_custom_topology.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.asm_custom_topology.cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.asm_custom_topology.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
+ acdb_data.asm_custom_topology.cal_size = cal_block->cal_size;
+ acdb_data.asm_custom_topology.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.asm_custom_topology.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -280,10 +271,8 @@
}
cal_block->cal_size = ACDB_TOTAL_VOICE_ALLOCATION;
- cal_block->cal_paddr =
- atomic_read(&acdb_data.vocproc_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.vocproc_cal.cal_kvaddr);
+ cal_block->cal_paddr = acdb_data.vocproc_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.vocproc_cal.cal_kvaddr;
done:
return result;
}
@@ -299,12 +288,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.aanc_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.aanc_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.aanc_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.aanc_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.aanc_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.aanc_cal.cal_kvaddr;
done:
return result;
}
@@ -314,20 +300,18 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.aanc_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.aanc_cal.cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.aanc_cal.cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.aanc_cal.cal_size = cal_block->cal_size;
+ acdb_data.aanc_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.aanc_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -343,12 +327,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.lsm_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.lsm_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.lsm_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.lsm_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.lsm_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.lsm_cal.cal_kvaddr;
done:
return result;
}
@@ -358,20 +339,18 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.lsm_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.lsm_cal.cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.lsm_cal.cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.lsm_cal.cal_size = cal_block->cal_size;
+ acdb_data.lsm_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.lsm_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -470,7 +449,6 @@
pr_debug("ACDB=> %s : Path = %d num_entries = %d\n",
__func__, path, delay.num_entries);
- mutex_lock(&acdb_data.acdb_mutex);
if (path == RX_CAL)
delay_dest = &acdb_data.hw_delay_rx;
else if (path == TX_CAL)
@@ -487,7 +465,6 @@
__func__, result, path);
result = -EFAULT;
}
- mutex_unlock(&acdb_data.acdb_mutex);
done:
return result;
}
@@ -503,12 +480,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.anc_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.anc_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.anc_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.anc_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.anc_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.anc_cal.cal_kvaddr;
done:
return result;
}
@@ -518,20 +492,18 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.anc_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.anc_cal.cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.anc_cal.cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.anc_cal.cal_size = cal_block->cal_size;
+ acdb_data.anc_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.anc_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -541,10 +513,9 @@
int result = 0;
pr_debug("%s, path = %d\n", __func__, path);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
@@ -555,12 +526,11 @@
goto done;
}
- atomic_set(&acdb_data.afe_cal[path].cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.afe_cal[path].cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.afe_cal[path].cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.afe_cal[path].cal_size = cal_block->cal_size;
+ acdb_data.afe_cal[path].cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.afe_cal[path].cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -582,12 +552,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.afe_cal[path].cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.afe_cal[path].cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.afe_cal[path].cal_kvaddr);
+ cal_block->cal_size = acdb_data.afe_cal[path].cal_size;
+ cal_block->cal_paddr = acdb_data.afe_cal[path].cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.afe_cal[path].cal_kvaddr;
done:
return result;
}
@@ -597,10 +564,9 @@
int result = 0;
pr_debug("%s, path = %d\n", __func__, path);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
@@ -611,12 +577,11 @@
goto done;
}
- atomic_set(&acdb_data.audproc_cal[path].cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.audproc_cal[path].cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.audproc_cal[path].cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.audproc_cal[path].cal_size = cal_block->cal_size;
+ acdb_data.audproc_cal[path].cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.audproc_cal[path].cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -638,12 +603,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.audproc_cal[path].cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.audproc_cal[path].cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.audproc_cal[path].cal_kvaddr);
+ cal_block->cal_size = acdb_data.audproc_cal[path].cal_size;
+ cal_block->cal_paddr = acdb_data.audproc_cal[path].cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.audproc_cal[path].cal_kvaddr;
done:
return result;
}
@@ -653,10 +615,9 @@
int result = 0;
pr_debug("%s, path = %d\n", __func__, path);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
@@ -667,12 +628,11 @@
goto done;
}
- atomic_set(&acdb_data.audstrm_cal[path].cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.audstrm_cal[path].cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.audstrm_cal[path].cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.audstrm_cal[path].cal_size = cal_block->cal_size;
+ acdb_data.audstrm_cal[path].cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.audstrm_cal[path].cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -694,12 +654,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.audstrm_cal[path].cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.audstrm_cal[path].cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.audstrm_cal[path].cal_kvaddr);
+ cal_block->cal_size = acdb_data.audstrm_cal[path].cal_size;
+ cal_block->cal_paddr = acdb_data.audstrm_cal[path].cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.audstrm_cal[path].cal_kvaddr;
done:
return result;
}
@@ -709,10 +666,9 @@
int result = 0;
pr_debug("%s, path = %d\n", __func__, path);
- if (cal_block->cal_offset > atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
result = -EINVAL;
goto done;
}
@@ -723,12 +679,11 @@
goto done;
}
- atomic_set(&acdb_data.audvol_cal[path].cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.audvol_cal[path].cal_paddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.audvol_cal[path].cal_kvaddr,
- cal_block->cal_offset + atomic64_read(&acdb_data.kvaddr));
+ acdb_data.audvol_cal[path].cal_size = cal_block->cal_size;
+ acdb_data.audvol_cal[path].cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.audvol_cal[path].cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -750,12 +705,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.audvol_cal[path].cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.audvol_cal[path].cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.audvol_cal[path].cal_kvaddr);
+ cal_block->cal_size = acdb_data.audvol_cal[path].cal_size;
+ cal_block->cal_paddr = acdb_data.audvol_cal[path].cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.audvol_cal[path].cal_kvaddr;
done:
return result;
}
@@ -767,21 +719,18 @@
pr_debug("%s,\n", __func__);
if (cal_size > MAX_COL_SIZE) {
- pr_err("%s: col size is to big %d\n", __func__,
- cal_size);
+ pr_err("%s: col size is to big %d\n", __func__, cal_size);
result = -EINVAL;
goto done;
}
if (copy_from_user(acdb_data.col_data[vocproc_type],
(void *)((uint8_t *)cal_block + sizeof(cal_size)),
cal_size)) {
- pr_err("%s: fail to copy col size %d\n",
- __func__, cal_size);
+ pr_err("%s: fail to copy col size %d\n", __func__, cal_size);
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.vocproc_col_cal[vocproc_type].cal_size,
- cal_size);
+ acdb_data.vocproc_col_cal[vocproc_type].cal_size = cal_size;
done:
return result;
}
@@ -798,12 +747,12 @@
goto done;
}
- cal_block->cal_size = atomic_read(&acdb_data.
- vocproc_col_cal[vocproc_type].cal_size);
- cal_block->cal_paddr = atomic_read(&acdb_data.
- vocproc_col_cal[vocproc_type].cal_paddr);
- cal_block->cal_kvaddr = atomic_read(&acdb_data.
- vocproc_col_cal[vocproc_type].cal_kvaddr);
+ cal_block->cal_size = acdb_data.
+ vocproc_col_cal[vocproc_type].cal_size;
+ cal_block->cal_paddr = acdb_data.
+ vocproc_col_cal[vocproc_type].cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.
+ vocproc_col_cal[vocproc_type].cal_kvaddr;
done:
return result;
}
@@ -815,24 +764,19 @@
if (cal_block->cal_offset >
- atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
- atomic_set(&acdb_data.vocproc_dev_cal.cal_size, 0);
+ acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
+ acdb_data.vocproc_dev_cal.cal_size = 0;
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.vocproc_dev_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.vocproc_dev_cal.cal_paddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.vocproc_dev_cal.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
-
+ acdb_data.vocproc_dev_cal.cal_size = cal_block->cal_size;
+ acdb_data.vocproc_dev_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.vocproc_dev_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -848,12 +792,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.vocproc_dev_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.vocproc_dev_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.vocproc_dev_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.vocproc_dev_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.vocproc_dev_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.vocproc_dev_cal.cal_kvaddr;
done:
return result;
}
@@ -866,24 +807,19 @@
pr_debug("%s,\n", __func__);
if (cal_block->cal_offset >
- atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
- atomic_set(&acdb_data.vocproc_cal.cal_size, 0);
+ acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
+ acdb_data.vocproc_cal.cal_size = 0;
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.vocproc_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.vocproc_cal.cal_paddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.vocproc_cal.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
-
+ acdb_data.vocproc_cal.cal_size = cal_block->cal_size;
+ acdb_data.vocproc_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.vocproc_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -899,12 +835,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.vocproc_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.vocproc_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.vocproc_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.vocproc_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.vocproc_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.vocproc_cal.cal_kvaddr;
done:
return result;
}
@@ -915,24 +848,19 @@
pr_debug("%s,\n", __func__);
if (cal_block->cal_offset >
- atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
- atomic_set(&acdb_data.vocstrm_cal.cal_size, 0);
+ acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
+ acdb_data.vocstrm_cal.cal_size = 0;
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.vocstrm_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.vocstrm_cal.cal_paddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.vocstrm_cal.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
-
+ acdb_data.vocstrm_cal.cal_size = cal_block->cal_size;
+ acdb_data.vocstrm_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.vocstrm_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -948,12 +876,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.vocstrm_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.vocstrm_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.vocstrm_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.vocstrm_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.vocstrm_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.vocstrm_cal.cal_kvaddr;
done:
return result;
}
@@ -963,25 +888,19 @@
int result = 0;
pr_debug("%s,\n", __func__);
- if (cal_block->cal_offset >
- atomic64_read(&acdb_data.mem_len)) {
- pr_err("%s: offset %d is > mem_len %ld\n",
- __func__, cal_block->cal_offset,
- (long)atomic64_read(&acdb_data.mem_len));
- atomic_set(&acdb_data.vocvol_cal.cal_size, 0);
+ if (cal_block->cal_offset > acdb_data.mem_len) {
+ pr_err("%s: offset %d is > mem_len %llu\n",
+ __func__, cal_block->cal_offset, acdb_data.mem_len);
+ acdb_data.vocvol_cal.cal_size = 0;
result = -EINVAL;
goto done;
}
- atomic_set(&acdb_data.vocvol_cal.cal_size,
- cal_block->cal_size);
- atomic_set(&acdb_data.vocvol_cal.cal_paddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.paddr));
- atomic_set(&acdb_data.vocvol_cal.cal_kvaddr,
- cal_block->cal_offset +
- atomic64_read(&acdb_data.kvaddr));
-
+ acdb_data.vocvol_cal.cal_size = cal_block->cal_size;
+ acdb_data.vocvol_cal.cal_paddr =
+ cal_block->cal_offset + acdb_data.paddr;
+ acdb_data.vocvol_cal.cal_kvaddr =
+ cal_block->cal_offset + acdb_data.kvaddr;
done:
return result;
}
@@ -997,12 +916,9 @@
goto done;
}
- cal_block->cal_size =
- atomic_read(&acdb_data.vocvol_cal.cal_size);
- cal_block->cal_paddr =
- atomic_read(&acdb_data.vocvol_cal.cal_paddr);
- cal_block->cal_kvaddr =
- atomic_read(&acdb_data.vocvol_cal.cal_kvaddr);
+ cal_block->cal_size = acdb_data.vocvol_cal.cal_size;
+ cal_block->cal_paddr = acdb_data.vocvol_cal.cal_paddr;
+ cal_block->cal_kvaddr = acdb_data.vocvol_cal.cal_kvaddr;
done:
return result;
}
@@ -1011,8 +927,8 @@
{
pr_debug("%s,\n", __func__);
- atomic_set(&acdb_data.sidetone_cal.enable, cal_data->enable);
- atomic_set(&acdb_data.sidetone_cal.gain, cal_data->gain);
+ acdb_data.sidetone_cal.enable = cal_data->enable;
+ acdb_data.sidetone_cal.gain = cal_data->gain;
}
int get_sidetone_cal(struct sidetone_cal *cal_data)
@@ -1026,8 +942,10 @@
goto done;
}
- cal_data->enable = atomic_read(&acdb_data.sidetone_cal.enable);
- cal_data->gain = atomic_read(&acdb_data.sidetone_cal.gain);
+ mutex_lock(&acdb_data.acdb_mutex);
+ cal_data->enable = acdb_data.sidetone_cal.enable;
+ cal_data->gain = acdb_data.sidetone_cal.gain;
+ mutex_unlock(&acdb_data.acdb_mutex);
done:
return result;
}
@@ -1111,14 +1029,15 @@
s32 result = 0;
pr_debug("%s\n", __func__);
- if (atomic64_read(&acdb_data.mem_len)) {
+ mutex_lock(&acdb_data.acdb_mutex);
+ if (acdb_data.mem_len)
pr_debug("%s: ACDB opened but memory allocated, using existing allocation!\n",
__func__);
- }
- atomic_set(&acdb_data.valid_adm_custom_top, 1);
- atomic_set(&acdb_data.valid_asm_custom_top, 1);
- atomic_inc(&usage_count);
+ acdb_data.valid_adm_custom_top = 1;
+ acdb_data.valid_asm_custom_top = 1;
+ acdb_data.usage_count++;
+ mutex_unlock(&acdb_data.acdb_mutex);
return result;
}
@@ -1195,30 +1114,31 @@
int i;
pr_debug("%s\n", __func__);
- mutex_lock(&acdb_data.acdb_mutex);
+ if (acdb_data.mem_len == 0)
+ goto done;
+
+ pr_debug("Remove existing memory\n");
+ acdb_data.mem_len = 0;
+
+ /* unmap all cal data */
+ result = unmap_cal_tables();
+ if (result < 0)
+ pr_err("%s: unmap_cal_tables failed, err = %d\n",
+ __func__, result);
+
+ msm_audio_ion_free(acdb_data.ion_client, acdb_data.ion_handle);
+ acdb_data.ion_client = NULL;
+ acdb_data.ion_handle = NULL;
+
+ for (i = 0; i < MAX_VOCPROC_TYPES; i++) {
+ kfree(acdb_data.col_data[i]);
+ acdb_data.col_data[i] = NULL;
+ }
+
kfree(acdb_data.hw_delay_tx.delay_info);
kfree(acdb_data.hw_delay_rx.delay_info);
-
- if (atomic64_read(&acdb_data.mem_len)) {
- /* unmap all cal data */
- result = unmap_cal_tables();
- if (result < 0)
- pr_err("%s: unmap_cal_tables failed, err = %d\n",
- __func__, result);
-
- atomic64_set(&acdb_data.mem_len, 0);
-
- for (i = 0; i < MAX_VOCPROC_TYPES; i++) {
- kfree(acdb_data.col_data[i]);
- acdb_data.col_data[i] = NULL;
- }
- msm_audio_ion_free(acdb_data.ion_client, acdb_data.ion_handle);
- acdb_data.ion_client = NULL;
- acdb_data.ion_handle = NULL;
- mutex_unlock(&acdb_data.acdb_mutex);
- }
- mutex_unlock(&acdb_data.acdb_mutex);
- return 0;
+done:
+ return result;
}
static int register_memory(void)
@@ -1231,42 +1151,38 @@
unsigned long mem_len;
pr_debug("%s\n", __func__);
- mutex_lock(&acdb_data.acdb_mutex);
- allocate_hw_delay_entries();
- for (i = 0; i < MAX_VOCPROC_TYPES; i++) {
- acdb_data.col_data[i] = kmalloc(MAX_COL_SIZE, GFP_KERNEL);
- atomic_set(&acdb_data.vocproc_col_cal[i].cal_kvaddr,
- (uint32_t)acdb_data.col_data[i]);
- }
-
result = msm_audio_ion_import("audio_acdb_client",
&acdb_data.ion_client,
&acdb_data.ion_handle,
- atomic_read(&acdb_data.map_handle),
+ acdb_data.map_handle,
NULL, 0,
&paddr, (size_t *)&mem_len, &kvptr);
if (result) {
pr_err("%s: audio ION alloc failed, rc = %d\n",
__func__, result);
- result = PTR_ERR(acdb_data.ion_client);
goto err_ion_handle;
}
- kvaddr = (unsigned long)kvptr;
- atomic64_set(&acdb_data.paddr, paddr);
- atomic64_set(&acdb_data.kvaddr, kvaddr);
- atomic64_set(&acdb_data.mem_len, mem_len);
- mutex_unlock(&acdb_data.acdb_mutex);
- pr_debug("%s done! paddr = 0x%lx, kvaddr = 0x%lx, len = x%lx\n",
- __func__,
- (long)atomic64_read(&acdb_data.paddr),
- (long)atomic64_read(&acdb_data.kvaddr),
- (long)atomic64_read(&acdb_data.mem_len));
+ allocate_hw_delay_entries();
+
+ for (i = 0; i < MAX_VOCPROC_TYPES; i++) {
+ acdb_data.col_data[i] = kmalloc(MAX_COL_SIZE, GFP_KERNEL);
+ acdb_data.vocproc_col_cal[i].cal_kvaddr =
+ (uint32_t)acdb_data.col_data[i];
+ }
+
+ kvaddr = (unsigned long)kvptr;
+ acdb_data.paddr = paddr;
+ acdb_data.kvaddr = kvaddr;
+ acdb_data.mem_len = mem_len;
+
+ pr_debug("%s done! paddr = 0x%llx, kvaddr = 0x%llx, len = 0x%llx\n",
+ __func__, acdb_data.paddr, acdb_data.kvaddr,
+ acdb_data.mem_len);
return result;
err_ion_handle:
- atomic64_set(&acdb_data.mem_len, 0);
- mutex_unlock(&acdb_data.acdb_mutex);
+ acdb_data.mem_len = 0;
return result;
}
static long acdb_ioctl(struct file *f,
@@ -1281,26 +1197,26 @@
struct msm_spk_prot_status acdb_spk_status;
pr_debug("%s\n", __func__);
+ mutex_lock(&acdb_data.acdb_mutex);
switch (cmd) {
case AUDIO_REGISTER_PMEM:
pr_debug("AUDIO_REGISTER_PMEM\n");
- if (atomic_read(&acdb_data.mem_len)) {
- deregister_memory();
- pr_debug("Remove the existing memory\n");
- }
+ result = deregister_memory();
+ if (result < 0)
+ pr_err("%s: deregister_memory failed returned %d!\n",
+ __func__, result);
if (copy_from_user(&map_fd, (void *)arg, sizeof(map_fd))) {
pr_err("%s: fail to copy memory handle!\n", __func__);
result = -EFAULT;
} else {
- atomic_set(&acdb_data.map_handle, map_fd);
+ acdb_data.map_handle = map_fd;
result = register_memory();
}
goto done;
-
case AUDIO_DEREGISTER_PMEM:
pr_debug("AUDIO_DEREGISTER_PMEM\n");
- deregister_memory();
+ result = deregister_memory();
goto done;
case AUDIO_SET_VOICE_RX_TOPOLOGY:
if (copy_from_user(&topology, (void *)arg,
@@ -1343,16 +1259,13 @@
store_asm_topology(topology);
goto done;
case AUDIO_SET_SPEAKER_PROT:
- mutex_lock(&acdb_data.acdb_mutex);
if (copy_from_user(&acdb_data.spk_prot_cfg, (void *)arg,
sizeof(acdb_data.spk_prot_cfg))) {
pr_err("%s fail to copy spk_prot_cfg\n", __func__);
result = -EFAULT;
}
- mutex_unlock(&acdb_data.acdb_mutex);
goto done;
case AUDIO_GET_SPEAKER_PROT:
- mutex_lock(&acdb_data.acdb_mutex);
/*Indicates calibration was succesfull*/
if (acdb_data.spk_prot_cfg.mode == MSM_SPKR_PROT_CALIBRATED) {
prot_status.r0 = acdb_data.spk_prot_cfg.r0;
@@ -1379,7 +1292,6 @@
sizeof(prot_status))) {
pr_err("%s: Failed to update prot_status\n", __func__);
}
- mutex_unlock(&acdb_data.acdb_mutex);
goto done;
case AUDIO_REGISTER_VOCPROC_VOL_TABLE:
result = register_vocvol_table();
@@ -1502,23 +1414,25 @@
}
done:
+ mutex_unlock(&acdb_data.acdb_mutex);
return result;
}
static int acdb_mmap(struct file *file, struct vm_area_struct *vma)
{
int result = 0;
- uint32_t size = vma->vm_end - vma->vm_start;
+ size_t size = vma->vm_end - vma->vm_start;
pr_debug("%s\n", __func__);
- if (atomic64_read(&acdb_data.mem_len)) {
- if (size <= atomic64_read(&acdb_data.mem_len)) {
+ mutex_lock(&acdb_data.acdb_mutex);
+ if (acdb_data.mem_len) {
+ if (size <= acdb_data.mem_len) {
vma->vm_page_prot = pgprot_noncached(
vma->vm_page_prot);
result = remap_pfn_range(vma,
vma->vm_start,
- atomic64_read(&acdb_data.paddr) >> PAGE_SHIFT,
+ acdb_data.paddr >> PAGE_SHIFT,
size,
vma->vm_page_prot);
} else {
@@ -1529,25 +1443,29 @@
pr_err("%s: memory is not allocated, yet!\n", __func__);
result = -ENODEV;
}
+ mutex_unlock(&acdb_data.acdb_mutex);
return result;
}
static int acdb_release(struct inode *inode, struct file *f)
{
- s32 result = 0;
+ int result = 0;
+ pr_debug("%s\n", __func__);
- atomic_dec(&usage_count);
- atomic_read(&usage_count);
+ mutex_lock(&acdb_data.acdb_mutex);
+ acdb_data.usage_count--;
- pr_debug("%s: ref count %d!\n", __func__,
- atomic_read(&usage_count));
+ pr_debug("%s: ref count %d!\n", __func__, acdb_data.usage_count);
- if (atomic_read(&usage_count) >= 1)
+ if (acdb_data.usage_count > 0) {
result = -EBUSY;
- else
- result = deregister_memory();
+ goto done;
+ }
+ result = deregister_memory();
+done:
+ mutex_unlock(&acdb_data.acdb_mutex);
return result;
}
@@ -1571,9 +1489,9 @@
/*Speaker protection disabled*/
acdb_data.spk_prot_cfg.mode = MSM_SPKR_PROT_DISABLED;
mutex_init(&acdb_data.acdb_mutex);
- atomic_set(&usage_count, 0);
- atomic_set(&acdb_data.valid_adm_custom_top, 1);
- atomic_set(&acdb_data.valid_asm_custom_top, 1);
+ acdb_data.usage_count = 0;
+ acdb_data.valid_adm_custom_top = 1;
+ acdb_data.valid_asm_custom_top = 1;
return misc_register(&acdb_misc);
}
diff --git a/sound/soc/msm/qdsp6v2/audio_acdb.h b/sound/soc/msm/qdsp6v2/audio_acdb.h
index e2ca395..45a83f6 100644
--- a/sound/soc/msm/qdsp6v2/audio_acdb.h
+++ b/sound/soc/msm/qdsp6v2/audio_acdb.h
@@ -35,12 +35,6 @@
uint32_t cal_paddr;
};
-struct acdb_atomic_cal_block {
- atomic_t cal_size;
- atomic_t cal_kvaddr;
- atomic_t cal_paddr;
-};
-
struct hw_delay_entry {
uint32_t sample_rate;
uint32_t delay_usec;