arch/arm/mach-msm/qdsp6v2/audio_acdb.c - kernel/msm - Gitiles

 /* Copyright (c) 2010-2012, Code Aurora Forum. 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
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  */
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/miscdevice.h>
 #include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/android_pmem.h>
 #include <linux/mm.h>
 #include <mach/qdsp6v2/audio_acdb.h>


 #define MAX_NETWORKS		12

 struct acdb_data {
 	struct mutex		acdb_mutex;

 	/* ANC Cal */
 	struct acdb_cal_block	anc_cal;

 	/* AudProc Cal */
 	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 */
 	uint32_t                voice_rx_topology;
 	uint32_t                voice_tx_topology;
 	struct acdb_cal_block	vocproc_cal[MAX_NETWORKS];
 	struct acdb_cal_block	vocstrm_cal[MAX_NETWORKS];
 	struct acdb_cal_block	vocvol_cal[MAX_NETWORKS];
 	/* size of cal block tables above*/
 	uint32_t		vocproc_cal_size;
 	uint32_t		vocstrm_cal_size;
 	uint32_t		vocvol_cal_size;
 	/* Total size of cal data for all networks */
 	uint32_t		vocproc_total_cal_size;
 	uint32_t		vocstrm_total_cal_size;
 	uint32_t		vocvol_total_cal_size;

 	/* Sidetone Cal */
 	struct sidetone_cal	sidetone_cal;

 	/* PMEM information */
 	int			pmem_fd;
 	unsigned long		paddr;
 	unsigned long		kvaddr;
 	unsigned long		pmem_len;
 	struct file		*file;

 };

 static struct acdb_data		acdb_data;
 static atomic_t usage_count;

 uint32_t get_voice_rx_topology(void)
 {
 	return acdb_data.voice_rx_topology;
 }

 void store_voice_rx_topology(uint32_t topology)
 {
 	acdb_data.voice_rx_topology = topology;
 }

 uint32_t get_voice_tx_topology(void)
 {
 	return acdb_data.voice_tx_topology;
 }

 void store_voice_tx_topology(uint32_t topology)
 {
 	acdb_data.voice_tx_topology = topology;
 }

 uint32_t get_adm_rx_topology(void)
 {
 	return acdb_data.adm_topology[RX_CAL];
 }

 void store_adm_rx_topology(uint32_t topology)
 {
 	acdb_data.adm_topology[RX_CAL] = topology;
 }

 uint32_t get_adm_tx_topology(void)
 {
 	return acdb_data.adm_topology[TX_CAL];
 }

 void store_adm_tx_topology(uint32_t topology)
 {
 	acdb_data.adm_topology[TX_CAL] = topology;
 }

 uint32_t get_asm_topology(void)
 {
 	return acdb_data.asm_topology;
 }

 void store_asm_topology(uint32_t topology)
 {
 	acdb_data.asm_topology = topology;
 }

 void get_all_voice_cal(struct acdb_cal_block *cal_block)
 {
 	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
 	cal_block->cal_size = acdb_data.vocproc_total_cal_size +
 				acdb_data.vocstrm_total_cal_size +
 				acdb_data.vocvol_total_cal_size;
 }

 void get_all_cvp_cal(struct acdb_cal_block *cal_block)
 {
 	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
 	cal_block->cal_size = acdb_data.vocproc_total_cal_size +
 				acdb_data.vocvol_total_cal_size;
 }

 void get_all_vocproc_cal(struct acdb_cal_block *cal_block)
 {
 	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
 	cal_block->cal_size = acdb_data.vocproc_total_cal_size;
 }

 void get_all_vocstrm_cal(struct acdb_cal_block *cal_block)
 {
 	cal_block->cal_kvaddr = acdb_data.vocstrm_cal[0].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.vocstrm_cal[0].cal_paddr;
 	cal_block->cal_size = acdb_data.vocstrm_total_cal_size;
 }

 void get_all_vocvol_cal(struct acdb_cal_block *cal_block)
 {
 	cal_block->cal_kvaddr = acdb_data.vocvol_cal[0].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.vocvol_cal[0].cal_paddr;
 	cal_block->cal_size = acdb_data.vocvol_total_cal_size;
 }

 void get_anc_cal(struct acdb_cal_block *cal_block)
 {
 	pr_debug("%s\n", __func__);

 	if (cal_block == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_block->cal_kvaddr = acdb_data.anc_cal.cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.anc_cal.cal_paddr;
 	cal_block->cal_size = acdb_data.anc_cal.cal_size;

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_anc_cal(struct cal_block *cal_block)
 {
 	pr_debug("%s,\n", __func__);

 	if (cal_block->cal_offset > acdb_data.pmem_len) {
 		pr_err("%s: offset %d is > pmem_len %ld\n",
 			__func__, cal_block->cal_offset,
 			acdb_data.pmem_len);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	acdb_data.anc_cal.cal_kvaddr =
 		cal_block->cal_offset + acdb_data.kvaddr;
 	acdb_data.anc_cal.cal_paddr =
 		cal_block->cal_offset + acdb_data.paddr;
 	acdb_data.anc_cal.cal_size =
 		cal_block->cal_size;

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_audproc_cal(int32_t path, struct cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	mutex_lock(&acdb_data.acdb_mutex);

 	if (cal_block->cal_offset > acdb_data.pmem_len) {
 		pr_err("%s: offset %d is > pmem_len %ld\n",
 			__func__, cal_block->cal_offset,
 			acdb_data.pmem_len);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	acdb_data.audproc_cal[path].cal_kvaddr =
 		cal_block->cal_offset + acdb_data.kvaddr;
 	acdb_data.audproc_cal[path].cal_paddr =
 		cal_block->cal_offset + acdb_data.paddr;
 	acdb_data.audproc_cal[path].cal_size =
 		cal_block->cal_size;

 done:
 	mutex_unlock(&acdb_data.acdb_mutex);
 	return;
 }

 void get_audproc_cal(int32_t path, struct acdb_cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	if (cal_block == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_block->cal_kvaddr = acdb_data.audproc_cal[path].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.audproc_cal[path].cal_paddr;
 	cal_block->cal_size = acdb_data.audproc_cal[path].cal_size;

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_audstrm_cal(int32_t path, struct cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	mutex_lock(&acdb_data.acdb_mutex);

 	if (cal_block->cal_offset > acdb_data.pmem_len) {
 		pr_err("%s: offset %d is > pmem_len %ld\n",
 			__func__, cal_block->cal_offset,
 			acdb_data.pmem_len);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	acdb_data.audstrm_cal[path].cal_kvaddr =
 		cal_block->cal_offset + acdb_data.kvaddr;
 	acdb_data.audstrm_cal[path].cal_paddr =
 		cal_block->cal_offset + acdb_data.paddr;
 	acdb_data.audstrm_cal[path].cal_size =
 		cal_block->cal_size;

 done:
 	mutex_unlock(&acdb_data.acdb_mutex);
 	return;
 }

 void get_audstrm_cal(int32_t path, struct acdb_cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	if (cal_block == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_block->cal_kvaddr = acdb_data.audstrm_cal[path].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.audstrm_cal[path].cal_paddr;
 	cal_block->cal_size = acdb_data.audstrm_cal[path].cal_size;

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_audvol_cal(int32_t path, struct cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	mutex_lock(&acdb_data.acdb_mutex);

 	if (cal_block->cal_offset > acdb_data.pmem_len) {
 		pr_err("%s: offset %d is > pmem_len %ld\n",
 			__func__, cal_block->cal_offset,
 			acdb_data.pmem_len);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	acdb_data.audvol_cal[path].cal_kvaddr =
 		cal_block->cal_offset + acdb_data.kvaddr;
 	acdb_data.audvol_cal[path].cal_paddr =
 		cal_block->cal_offset + acdb_data.paddr;
 	acdb_data.audvol_cal[path].cal_size =
 		cal_block->cal_size;

 done:
 	mutex_unlock(&acdb_data.acdb_mutex);
 	return;
 }

 void get_audvol_cal(int32_t path, struct acdb_cal_block *cal_block)
 {
 	pr_debug("%s, path = %d\n", __func__, path);

 	if (cal_block == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}
 	if (path >= MAX_AUDPROC_TYPES || path < 0) {
 		pr_err("ACDB=> Bad path sent to %s, path: %d\n",
 			__func__, path);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_block->cal_kvaddr = acdb_data.audvol_cal[path].cal_kvaddr;
 	cal_block->cal_paddr = acdb_data.audvol_cal[path].cal_paddr;
 	cal_block->cal_size = acdb_data.audvol_cal[path].cal_size;

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }


 void store_vocproc_cal(int32_t len, struct cal_block *cal_blocks)
 {
 	int i;
 	pr_debug("%s\n", __func__);

 	if (len > MAX_NETWORKS) {
 		pr_err("%s: Calibration sent for %d networks, only %d are "
 			"supported!\n", __func__, len, MAX_NETWORKS);
 		goto done;
 	}


 	mutex_lock(&acdb_data.acdb_mutex);

 	acdb_data.vocproc_total_cal_size = 0;
 	for (i = 0; i < len; i++) {
 		if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
 			pr_err("%s: offset %d is > pmem_len %ld\n",
 				__func__, cal_blocks[i].cal_offset,
 				acdb_data.pmem_len);
 			acdb_data.vocproc_cal[i].cal_size = 0;
 		} else {
 			acdb_data.vocproc_total_cal_size +=
 				cal_blocks[i].cal_size;
 			acdb_data.vocproc_cal[i].cal_size =
 				cal_blocks[i].cal_size;
 			acdb_data.vocproc_cal[i].cal_paddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.paddr;
 			acdb_data.vocproc_cal[i].cal_kvaddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.kvaddr;
 		}
 	}
 	acdb_data.vocproc_cal_size = len;
 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void get_vocproc_cal(struct acdb_cal_data *cal_data)
 {
 	pr_debug("%s\n", __func__);

 	if (cal_data == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_data->num_cal_blocks = acdb_data.vocproc_cal_size;
 	cal_data->cal_blocks = &acdb_data.vocproc_cal[0];

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_vocstrm_cal(int32_t len, struct cal_block *cal_blocks)
 {
 	int i;
 	pr_debug("%s\n", __func__);

 	if (len > MAX_NETWORKS) {
 		pr_err("%s: Calibration sent for %d networks, only %d are "
 			"supported!\n", __func__, len, MAX_NETWORKS);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	acdb_data.vocstrm_total_cal_size = 0;
 	for (i = 0; i < len; i++) {
 		if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
 			pr_err("%s: offset %d is > pmem_len %ld\n",
 				__func__, cal_blocks[i].cal_offset,
 				acdb_data.pmem_len);
 			acdb_data.vocstrm_cal[i].cal_size = 0;
 		} else {
 			acdb_data.vocstrm_total_cal_size +=
 				cal_blocks[i].cal_size;
 			acdb_data.vocstrm_cal[i].cal_size =
 				cal_blocks[i].cal_size;
 			acdb_data.vocstrm_cal[i].cal_paddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.paddr;
 			acdb_data.vocstrm_cal[i].cal_kvaddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.kvaddr;
 		}
 	}
 	acdb_data.vocstrm_cal_size = len;
 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void get_vocstrm_cal(struct acdb_cal_data *cal_data)
 {
 	pr_debug("%s\n", __func__);

 	if (cal_data == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_data->num_cal_blocks = acdb_data.vocstrm_cal_size;
 	cal_data->cal_blocks = &acdb_data.vocstrm_cal[0];

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_vocvol_cal(int32_t len, struct cal_block *cal_blocks)
 {
 	int i;
 	pr_debug("%s\n", __func__);

 	if (len > MAX_NETWORKS) {
 		pr_err("%s: Calibration sent for %d networks, only %d are "
 			"supported!\n", __func__, len, MAX_NETWORKS);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	acdb_data.vocvol_total_cal_size = 0;
 	for (i = 0; i < len; i++) {
 		if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
 			pr_err("%s: offset %d is > pmem_len %ld\n",
 				__func__, cal_blocks[i].cal_offset,
 				acdb_data.pmem_len);
 			acdb_data.vocvol_cal[i].cal_size = 0;
 		} else {
 			acdb_data.vocvol_total_cal_size +=
 				cal_blocks[i].cal_size;
 			acdb_data.vocvol_cal[i].cal_size =
 				cal_blocks[i].cal_size;
 			acdb_data.vocvol_cal[i].cal_paddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.paddr;
 			acdb_data.vocvol_cal[i].cal_kvaddr =
 				cal_blocks[i].cal_offset +
 				acdb_data.kvaddr;
 		}
 	}
 	acdb_data.vocvol_cal_size = len;
 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void get_vocvol_cal(struct acdb_cal_data *cal_data)
 {
 	pr_debug("%s\n", __func__);

 	if (cal_data == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}

 	mutex_lock(&acdb_data.acdb_mutex);

 	cal_data->num_cal_blocks = acdb_data.vocvol_cal_size;
 	cal_data->cal_blocks = &acdb_data.vocvol_cal[0];

 	mutex_unlock(&acdb_data.acdb_mutex);
 done:
 	return;
 }

 void store_sidetone_cal(struct sidetone_cal *cal_data)
 {
 	pr_debug("%s\n", __func__);

 	mutex_lock(&acdb_data.acdb_mutex);

 	acdb_data.sidetone_cal.enable = cal_data->enable;
 	acdb_data.sidetone_cal.gain = cal_data->gain;

 	mutex_unlock(&acdb_data.acdb_mutex);
 }


 void get_sidetone_cal(struct sidetone_cal *cal_data)
 {
 	pr_debug("%s\n", __func__);

 	if (cal_data == NULL) {
 		pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
 		goto done;
 	}

 	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;
 }

 static int acdb_open(struct inode *inode, struct file *f)
 {
 	s32 result = 0;
 	pr_info("%s\n", __func__);

 	mutex_lock(&acdb_data.acdb_mutex);
 	if (acdb_data.pmem_fd) {
 		pr_info("%s: ACDB opened but PMEM allocated, using existing PMEM!\n",
 			__func__);
 	}
 	mutex_unlock(&acdb_data.acdb_mutex);

 	atomic_inc(&usage_count);
 	return result;
 }

 static int deregister_pmem(void)
 {
 	if (acdb_data.pmem_fd) {
 		put_pmem_file(acdb_data.file);
 		acdb_data.pmem_fd = 0;
 	}
 	return 0;
 }

 static int register_pmem(void)
 {
 	int result;

 	result = get_pmem_file(acdb_data.pmem_fd, &acdb_data.paddr,
 				&acdb_data.kvaddr, &acdb_data.pmem_len,
 				&acdb_data.file);
 	if (result != 0) {
 		acdb_data.pmem_fd = 0;
 		pr_err("%s: Could not register PMEM!!!\n", __func__);
 		goto done;
 	}

 	pr_debug("AUDIO_REGISTER_PMEM done! paddr = 0x%lx, "
 		"kvaddr = 0x%lx, len = x%lx\n", acdb_data.paddr,
 		acdb_data.kvaddr, acdb_data.pmem_len);

 done:
 	return result;
 }
 static long acdb_ioctl(struct file *f,
 		unsigned int cmd, unsigned long arg)
 {
 	s32			result = 0;
 	s32			audproc_path;
 	s32			size;
 	u32			topology;
 	struct cal_block	data[MAX_NETWORKS];
 	pr_debug("%s\n", __func__);

 	switch (cmd) {
 	case AUDIO_REGISTER_PMEM:
 		pr_debug("AUDIO_REGISTER_PMEM\n");
 		mutex_lock(&acdb_data.acdb_mutex);
 		if (acdb_data.pmem_fd) {
 			deregister_pmem();
 			pr_info("Remove the existing PMEM\n");
 		}

 		if (copy_from_user(&acdb_data.pmem_fd, (void *)arg,
 					sizeof(acdb_data.pmem_fd))) {
 			pr_err("%s: fail to copy pmem handle!\n", __func__);
 			result = -EFAULT;
 		} else {
 			result = register_pmem();
 		}
 		mutex_unlock(&acdb_data.acdb_mutex);
 		goto done;

 	case AUDIO_DEREGISTER_PMEM:
 		pr_debug("AUDIO_DEREGISTER_PMEM\n");
 		mutex_lock(&acdb_data.acdb_mutex);
 		deregister_pmem();
 		mutex_unlock(&acdb_data.acdb_mutex);
 		goto done;
 	case AUDIO_SET_VOICE_RX_TOPOLOGY:
 		if (copy_from_user(&topology, (void *)arg,
 				sizeof(topology))) {
 			pr_err("%s: fail to copy topology!\n", __func__);
 			result = -EFAULT;
 		}
 		store_voice_rx_topology(topology);
 		goto done;
 	case AUDIO_SET_VOICE_TX_TOPOLOGY:
 		if (copy_from_user(&topology, (void *)arg,
 				sizeof(topology))) {
 			pr_err("%s: fail to copy topology!\n", __func__);
 			result = -EFAULT;
 		}
 		store_voice_tx_topology(topology);
 		goto done;
 	case AUDIO_SET_ADM_RX_TOPOLOGY:
 		if (copy_from_user(&topology, (void *)arg,
 				sizeof(topology))) {
 			pr_err("%s: fail to copy topology!\n", __func__);
 			result = -EFAULT;
 		}
 		store_adm_rx_topology(topology);
 		goto done;
 	case AUDIO_SET_ADM_TX_TOPOLOGY:
 		if (copy_from_user(&topology, (void *)arg,
 				sizeof(topology))) {
 			pr_err("%s: fail to copy topology!\n", __func__);
 			result = -EFAULT;
 		}
 		store_adm_tx_topology(topology);
 		goto done;
 	case AUDIO_SET_ASM_TOPOLOGY:
 		if (copy_from_user(&topology, (void *)arg,
 				sizeof(topology))) {
 			pr_err("%s: fail to copy topology!\n", __func__);
 			result = -EFAULT;
 		}
 		store_asm_topology(topology);
 		goto done;
 	}

 	if (copy_from_user(&size, (void *) arg, sizeof(size))) {

 		result = -EFAULT;
 		goto done;
 	}

 	if (size <= 0) {
 		pr_err("%s: Invalid size sent to driver: %d\n",
 			__func__, size);
 		result = -EFAULT;
 		goto done;
 	}

 	if (copy_from_user(data, (void *)(arg + sizeof(size)), size)) {

 		pr_err("%s: fail to copy table size %d\n", __func__, size);
 		result = -EFAULT;
 		goto done;
 	}

 	if (data == NULL) {
 		pr_err("%s: NULL pointer sent to driver!\n", __func__);
 		result = -EFAULT;
 		goto done;
 	}

 	switch (cmd) {
 	case AUDIO_SET_AUDPROC_TX_CAL:
 		audproc_path = TX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audproc_cal(audproc_path, data);
 		break;
 	case AUDIO_SET_AUDPROC_RX_CAL:
 		audproc_path = RX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audproc_cal(audproc_path, data);
 		break;
 	case AUDIO_SET_AUDPROC_TX_STREAM_CAL:
 		audproc_path = TX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audstrm_cal(audproc_path, data);
 		break;
 	case AUDIO_SET_AUDPROC_RX_STREAM_CAL:
 		audproc_path = RX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audstrm_cal(audproc_path, data);
 		break;
 	case AUDIO_SET_AUDPROC_TX_VOL_CAL:
 		audproc_path = TX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audvol_cal(audproc_path, data);
 	case AUDIO_SET_AUDPROC_RX_VOL_CAL:
 		audproc_path = RX_CAL;
 		if (size > sizeof(struct cal_block))
 			pr_err("%s: More Audproc Cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_audvol_cal(audproc_path, data);
 		break;
 	case AUDIO_SET_VOCPROC_CAL:
 		store_vocproc_cal(size / sizeof(struct cal_block), data);
 		break;
 	case AUDIO_SET_VOCPROC_STREAM_CAL:
 		store_vocstrm_cal(size / sizeof(struct cal_block), data);
 		break;
 	case AUDIO_SET_VOCPROC_VOL_CAL:
 		store_vocvol_cal(size / sizeof(struct cal_block), data);
 		break;
 	case AUDIO_SET_SIDETONE_CAL:
 		if (size > sizeof(struct sidetone_cal))
 			pr_err("%s: More sidetone cal then expected, "
 				"size received: %d\n", __func__, size);
 		store_sidetone_cal((struct sidetone_cal *)data);
 		break;
 	case AUDIO_SET_ANC_CAL:
 		store_anc_cal(data);
 		break;
 	default:
 		pr_err("ACDB=> ACDB ioctl not found!\n");
 	}

 done:
 	return result;
 }

 static int acdb_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	int result = 0;
 	int size = vma->vm_end - vma->vm_start;

 	pr_debug("%s\n", __func__);

 	mutex_lock(&acdb_data.acdb_mutex);
 	if (acdb_data.pmem_fd) {
 		if (size <= acdb_data.pmem_len) {
 			vma->vm_page_prot = pgprot_noncached(
 						vma->vm_page_prot);
 			result = remap_pfn_range(vma,
 				vma->vm_start,
 				acdb_data.paddr >> PAGE_SHIFT,
 				size,
 				vma->vm_page_prot);
 		} else {
 			pr_err("%s: Not enough PMEM memory!\n", __func__);
 			result = -ENOMEM;
 		}
 	} else {
 		pr_err("%s: PMEM 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;

 	atomic_dec(&usage_count);
 	atomic_read(&usage_count);

 	pr_info("%s: ref count %d!\n", __func__,
 		atomic_read(&usage_count));

 	if (atomic_read(&usage_count) >= 1) {
 		result = -EBUSY;
 	} else {
 		mutex_lock(&acdb_data.acdb_mutex);
 		result = deregister_pmem();
 		mutex_unlock(&acdb_data.acdb_mutex);
 	}

 	return result;
 }

 static const struct file_operations acdb_fops = {
 	.owner = THIS_MODULE,
 	.open = acdb_open,
 	.release = acdb_release,
 	.unlocked_ioctl = acdb_ioctl,
 	.mmap = acdb_mmap,
 };

 struct miscdevice acdb_misc = {
 	.minor	= MISC_DYNAMIC_MINOR,
 	.name	= "msm_acdb",
 	.fops	= &acdb_fops,
 };

 static int __init acdb_init(void)
 {
 	memset(&acdb_data, 0, sizeof(acdb_data));
 	mutex_init(&acdb_data.acdb_mutex);
 	atomic_set(&usage_count, 0);
 	return misc_register(&acdb_misc);
 }

 static void __exit acdb_exit(void)
 {
 }

 module_init(acdb_init);
 module_exit(acdb_exit);

 MODULE_DESCRIPTION("MSM 8x60 Audio ACDB driver");
 MODULE_LICENSE("GPL v2");
	/* Copyright (c) 2010-2012, Code Aurora Forum. 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
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	*/
	#include <linux/fs.h>
	#include <linux/module.h>
	#include <linux/miscdevice.h>
	#include <linux/mutex.h>
	#include <linux/uaccess.h>
	#include <linux/android_pmem.h>
	#include <linux/mm.h>
	#include <mach/qdsp6v2/audio_acdb.h>


	#define MAX_NETWORKS 12

	struct acdb_data {
	struct mutex acdb_mutex;

	/* ANC Cal */
	struct acdb_cal_block anc_cal;

	/* AudProc Cal */
	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 */
	uint32_t voice_rx_topology;
	uint32_t voice_tx_topology;
	struct acdb_cal_block vocproc_cal[MAX_NETWORKS];
	struct acdb_cal_block vocstrm_cal[MAX_NETWORKS];
	struct acdb_cal_block vocvol_cal[MAX_NETWORKS];
	/* size of cal block tables above*/
	uint32_t vocproc_cal_size;
	uint32_t vocstrm_cal_size;
	uint32_t vocvol_cal_size;
	/* Total size of cal data for all networks */
	uint32_t vocproc_total_cal_size;
	uint32_t vocstrm_total_cal_size;
	uint32_t vocvol_total_cal_size;

	/* Sidetone Cal */
	struct sidetone_cal sidetone_cal;

	/* PMEM information */
	int pmem_fd;
	unsigned long paddr;
	unsigned long kvaddr;
	unsigned long pmem_len;
	struct file *file;

	};

	static struct acdb_data acdb_data;
	static atomic_t usage_count;

	uint32_t get_voice_rx_topology(void)
	{
	return acdb_data.voice_rx_topology;
	}

	void store_voice_rx_topology(uint32_t topology)
	{
	acdb_data.voice_rx_topology = topology;
	}

	uint32_t get_voice_tx_topology(void)
	{
	return acdb_data.voice_tx_topology;
	}

	void store_voice_tx_topology(uint32_t topology)
	{
	acdb_data.voice_tx_topology = topology;
	}

	uint32_t get_adm_rx_topology(void)
	{
	return acdb_data.adm_topology[RX_CAL];
	}

	void store_adm_rx_topology(uint32_t topology)
	{
	acdb_data.adm_topology[RX_CAL] = topology;
	}

	uint32_t get_adm_tx_topology(void)
	{
	return acdb_data.adm_topology[TX_CAL];
	}

	void store_adm_tx_topology(uint32_t topology)
	{
	acdb_data.adm_topology[TX_CAL] = topology;
	}

	uint32_t get_asm_topology(void)
	{
	return acdb_data.asm_topology;
	}

	void store_asm_topology(uint32_t topology)
	{
	acdb_data.asm_topology = topology;
	}

	void get_all_voice_cal(struct acdb_cal_block *cal_block)
	{
	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
	cal_block->cal_size = acdb_data.vocproc_total_cal_size +
	acdb_data.vocstrm_total_cal_size +
	acdb_data.vocvol_total_cal_size;
	}

	void get_all_cvp_cal(struct acdb_cal_block *cal_block)
	{
	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
	cal_block->cal_size = acdb_data.vocproc_total_cal_size +
	acdb_data.vocvol_total_cal_size;
	}

	void get_all_vocproc_cal(struct acdb_cal_block *cal_block)
	{
	cal_block->cal_kvaddr = acdb_data.vocproc_cal[0].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.vocproc_cal[0].cal_paddr;
	cal_block->cal_size = acdb_data.vocproc_total_cal_size;
	}

	void get_all_vocstrm_cal(struct acdb_cal_block *cal_block)
	{
	cal_block->cal_kvaddr = acdb_data.vocstrm_cal[0].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.vocstrm_cal[0].cal_paddr;
	cal_block->cal_size = acdb_data.vocstrm_total_cal_size;
	}

	void get_all_vocvol_cal(struct acdb_cal_block *cal_block)
	{
	cal_block->cal_kvaddr = acdb_data.vocvol_cal[0].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.vocvol_cal[0].cal_paddr;
	cal_block->cal_size = acdb_data.vocvol_total_cal_size;
	}

	void get_anc_cal(struct acdb_cal_block *cal_block)
	{
	pr_debug("%s\n", __func__);

	if (cal_block == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_block->cal_kvaddr = acdb_data.anc_cal.cal_kvaddr;
	cal_block->cal_paddr = acdb_data.anc_cal.cal_paddr;
	cal_block->cal_size = acdb_data.anc_cal.cal_size;

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_anc_cal(struct cal_block *cal_block)
	{
	pr_debug("%s,\n", __func__);

	if (cal_block->cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_block->cal_offset,
	acdb_data.pmem_len);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	acdb_data.anc_cal.cal_kvaddr =
	cal_block->cal_offset + acdb_data.kvaddr;
	acdb_data.anc_cal.cal_paddr =
	cal_block->cal_offset + acdb_data.paddr;
	acdb_data.anc_cal.cal_size =
	cal_block->cal_size;

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_audproc_cal(int32_t path, struct cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	mutex_lock(&acdb_data.acdb_mutex);

	if (cal_block->cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_block->cal_offset,
	acdb_data.pmem_len);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	acdb_data.audproc_cal[path].cal_kvaddr =
	cal_block->cal_offset + acdb_data.kvaddr;
	acdb_data.audproc_cal[path].cal_paddr =
	cal_block->cal_offset + acdb_data.paddr;
	acdb_data.audproc_cal[path].cal_size =
	cal_block->cal_size;

	done:
	mutex_unlock(&acdb_data.acdb_mutex);
	return;
	}

	void get_audproc_cal(int32_t path, struct acdb_cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	if (cal_block == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_block->cal_kvaddr = acdb_data.audproc_cal[path].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.audproc_cal[path].cal_paddr;
	cal_block->cal_size = acdb_data.audproc_cal[path].cal_size;

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_audstrm_cal(int32_t path, struct cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	mutex_lock(&acdb_data.acdb_mutex);

	if (cal_block->cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_block->cal_offset,
	acdb_data.pmem_len);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	acdb_data.audstrm_cal[path].cal_kvaddr =
	cal_block->cal_offset + acdb_data.kvaddr;
	acdb_data.audstrm_cal[path].cal_paddr =
	cal_block->cal_offset + acdb_data.paddr;
	acdb_data.audstrm_cal[path].cal_size =
	cal_block->cal_size;

	done:
	mutex_unlock(&acdb_data.acdb_mutex);
	return;
	}

	void get_audstrm_cal(int32_t path, struct acdb_cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	if (cal_block == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_block->cal_kvaddr = acdb_data.audstrm_cal[path].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.audstrm_cal[path].cal_paddr;
	cal_block->cal_size = acdb_data.audstrm_cal[path].cal_size;

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_audvol_cal(int32_t path, struct cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	mutex_lock(&acdb_data.acdb_mutex);

	if (cal_block->cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_block->cal_offset,
	acdb_data.pmem_len);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	acdb_data.audvol_cal[path].cal_kvaddr =
	cal_block->cal_offset + acdb_data.kvaddr;
	acdb_data.audvol_cal[path].cal_paddr =
	cal_block->cal_offset + acdb_data.paddr;
	acdb_data.audvol_cal[path].cal_size =
	cal_block->cal_size;

	done:
	mutex_unlock(&acdb_data.acdb_mutex);
	return;
	}

	void get_audvol_cal(int32_t path, struct acdb_cal_block *cal_block)
	{
	pr_debug("%s, path = %d\n", __func__, path);

	if (cal_block == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}
	if (path >= MAX_AUDPROC_TYPES \|\| path < 0) {
	pr_err("ACDB=> Bad path sent to %s, path: %d\n",
	__func__, path);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_block->cal_kvaddr = acdb_data.audvol_cal[path].cal_kvaddr;
	cal_block->cal_paddr = acdb_data.audvol_cal[path].cal_paddr;
	cal_block->cal_size = acdb_data.audvol_cal[path].cal_size;

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}


	void store_vocproc_cal(int32_t len, struct cal_block *cal_blocks)
	{
	int i;
	pr_debug("%s\n", __func__);

	if (len > MAX_NETWORKS) {
	pr_err("%s: Calibration sent for %d networks, only %d are "
	"supported!\n", __func__, len, MAX_NETWORKS);
	goto done;
	}


	mutex_lock(&acdb_data.acdb_mutex);

	acdb_data.vocproc_total_cal_size = 0;
	for (i = 0; i < len; i++) {
	if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_blocks[i].cal_offset,
	acdb_data.pmem_len);
	acdb_data.vocproc_cal[i].cal_size = 0;
	} else {
	acdb_data.vocproc_total_cal_size +=
	cal_blocks[i].cal_size;
	acdb_data.vocproc_cal[i].cal_size =
	cal_blocks[i].cal_size;
	acdb_data.vocproc_cal[i].cal_paddr =
	cal_blocks[i].cal_offset +
	acdb_data.paddr;
	acdb_data.vocproc_cal[i].cal_kvaddr =
	cal_blocks[i].cal_offset +
	acdb_data.kvaddr;
	}
	}
	acdb_data.vocproc_cal_size = len;
	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void get_vocproc_cal(struct acdb_cal_data *cal_data)
	{
	pr_debug("%s\n", __func__);

	if (cal_data == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_data->num_cal_blocks = acdb_data.vocproc_cal_size;
	cal_data->cal_blocks = &acdb_data.vocproc_cal[0];

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_vocstrm_cal(int32_t len, struct cal_block *cal_blocks)
	{
	int i;
	pr_debug("%s\n", __func__);

	if (len > MAX_NETWORKS) {
	pr_err("%s: Calibration sent for %d networks, only %d are "
	"supported!\n", __func__, len, MAX_NETWORKS);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	acdb_data.vocstrm_total_cal_size = 0;
	for (i = 0; i < len; i++) {
	if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_blocks[i].cal_offset,
	acdb_data.pmem_len);
	acdb_data.vocstrm_cal[i].cal_size = 0;
	} else {
	acdb_data.vocstrm_total_cal_size +=
	cal_blocks[i].cal_size;
	acdb_data.vocstrm_cal[i].cal_size =
	cal_blocks[i].cal_size;
	acdb_data.vocstrm_cal[i].cal_paddr =
	cal_blocks[i].cal_offset +
	acdb_data.paddr;
	acdb_data.vocstrm_cal[i].cal_kvaddr =
	cal_blocks[i].cal_offset +
	acdb_data.kvaddr;
	}
	}
	acdb_data.vocstrm_cal_size = len;
	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void get_vocstrm_cal(struct acdb_cal_data *cal_data)
	{
	pr_debug("%s\n", __func__);

	if (cal_data == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_data->num_cal_blocks = acdb_data.vocstrm_cal_size;
	cal_data->cal_blocks = &acdb_data.vocstrm_cal[0];

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_vocvol_cal(int32_t len, struct cal_block *cal_blocks)
	{
	int i;
	pr_debug("%s\n", __func__);

	if (len > MAX_NETWORKS) {
	pr_err("%s: Calibration sent for %d networks, only %d are "
	"supported!\n", __func__, len, MAX_NETWORKS);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	acdb_data.vocvol_total_cal_size = 0;
	for (i = 0; i < len; i++) {
	if (cal_blocks[i].cal_offset > acdb_data.pmem_len) {
	pr_err("%s: offset %d is > pmem_len %ld\n",
	__func__, cal_blocks[i].cal_offset,
	acdb_data.pmem_len);
	acdb_data.vocvol_cal[i].cal_size = 0;
	} else {
	acdb_data.vocvol_total_cal_size +=
	cal_blocks[i].cal_size;
	acdb_data.vocvol_cal[i].cal_size =
	cal_blocks[i].cal_size;
	acdb_data.vocvol_cal[i].cal_paddr =
	cal_blocks[i].cal_offset +
	acdb_data.paddr;
	acdb_data.vocvol_cal[i].cal_kvaddr =
	cal_blocks[i].cal_offset +
	acdb_data.kvaddr;
	}
	}
	acdb_data.vocvol_cal_size = len;
	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void get_vocvol_cal(struct acdb_cal_data *cal_data)
	{
	pr_debug("%s\n", __func__);

	if (cal_data == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}

	mutex_lock(&acdb_data.acdb_mutex);

	cal_data->num_cal_blocks = acdb_data.vocvol_cal_size;
	cal_data->cal_blocks = &acdb_data.vocvol_cal[0];

	mutex_unlock(&acdb_data.acdb_mutex);
	done:
	return;
	}

	void store_sidetone_cal(struct sidetone_cal *cal_data)
	{
	pr_debug("%s\n", __func__);

	mutex_lock(&acdb_data.acdb_mutex);

	acdb_data.sidetone_cal.enable = cal_data->enable;
	acdb_data.sidetone_cal.gain = cal_data->gain;

	mutex_unlock(&acdb_data.acdb_mutex);
	}


	void get_sidetone_cal(struct sidetone_cal *cal_data)
	{
	pr_debug("%s\n", __func__);

	if (cal_data == NULL) {
	pr_err("ACDB=> NULL pointer sent to %s\n", __func__);
	goto done;
	}

	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;
	}

	static int acdb_open(struct inode inode, struct file f)
	{
	s32 result = 0;
	pr_info("%s\n", __func__);

	mutex_lock(&acdb_data.acdb_mutex);
	if (acdb_data.pmem_fd) {
	pr_info("%s: ACDB opened but PMEM allocated, using existing PMEM!\n",
	__func__);
	}
	mutex_unlock(&acdb_data.acdb_mutex);

	atomic_inc(&usage_count);
	return result;
	}

	static int deregister_pmem(void)
	{
	if (acdb_data.pmem_fd) {
	put_pmem_file(acdb_data.file);
	acdb_data.pmem_fd = 0;
	}
	return 0;
	}

	static int register_pmem(void)
	{
	int result;

	result = get_pmem_file(acdb_data.pmem_fd, &acdb_data.paddr,
	&acdb_data.kvaddr, &acdb_data.pmem_len,
	&acdb_data.file);
	if (result != 0) {
	acdb_data.pmem_fd = 0;
	pr_err("%s: Could not register PMEM!!!\n", __func__);
	goto done;
	}

	pr_debug("AUDIO_REGISTER_PMEM done! paddr = 0x%lx, "
	"kvaddr = 0x%lx, len = x%lx\n", acdb_data.paddr,
	acdb_data.kvaddr, acdb_data.pmem_len);

	done:
	return result;
	}
	static long acdb_ioctl(struct file *f,
	unsigned int cmd, unsigned long arg)
	{
	s32 result = 0;
	s32 audproc_path;
	s32 size;
	u32 topology;
	struct cal_block data[MAX_NETWORKS];
	pr_debug("%s\n", __func__);

	switch (cmd) {
	case AUDIO_REGISTER_PMEM:
	pr_debug("AUDIO_REGISTER_PMEM\n");
	mutex_lock(&acdb_data.acdb_mutex);
	if (acdb_data.pmem_fd) {
	deregister_pmem();
	pr_info("Remove the existing PMEM\n");
	}

	if (copy_from_user(&acdb_data.pmem_fd, (void *)arg,
	sizeof(acdb_data.pmem_fd))) {
	pr_err("%s: fail to copy pmem handle!\n", __func__);
	result = -EFAULT;
	} else {
	result = register_pmem();
	}
	mutex_unlock(&acdb_data.acdb_mutex);
	goto done;

	case AUDIO_DEREGISTER_PMEM:
	pr_debug("AUDIO_DEREGISTER_PMEM\n");
	mutex_lock(&acdb_data.acdb_mutex);
	deregister_pmem();
	mutex_unlock(&acdb_data.acdb_mutex);
	goto done;
	case AUDIO_SET_VOICE_RX_TOPOLOGY:
	if (copy_from_user(&topology, (void *)arg,
	sizeof(topology))) {
	pr_err("%s: fail to copy topology!\n", __func__);
	result = -EFAULT;
	}
	store_voice_rx_topology(topology);
	goto done;
	case AUDIO_SET_VOICE_TX_TOPOLOGY:
	if (copy_from_user(&topology, (void *)arg,
	sizeof(topology))) {
	pr_err("%s: fail to copy topology!\n", __func__);
	result = -EFAULT;
	}
	store_voice_tx_topology(topology);
	goto done;
	case AUDIO_SET_ADM_RX_TOPOLOGY:
	if (copy_from_user(&topology, (void *)arg,
	sizeof(topology))) {
	pr_err("%s: fail to copy topology!\n", __func__);
	result = -EFAULT;
	}
	store_adm_rx_topology(topology);
	goto done;
	case AUDIO_SET_ADM_TX_TOPOLOGY:
	if (copy_from_user(&topology, (void *)arg,
	sizeof(topology))) {
	pr_err("%s: fail to copy topology!\n", __func__);
	result = -EFAULT;
	}
	store_adm_tx_topology(topology);
	goto done;
	case AUDIO_SET_ASM_TOPOLOGY:
	if (copy_from_user(&topology, (void *)arg,
	sizeof(topology))) {
	pr_err("%s: fail to copy topology!\n", __func__);
	result = -EFAULT;
	}
	store_asm_topology(topology);
	goto done;
	}

	if (copy_from_user(&size, (void *) arg, sizeof(size))) {

	result = -EFAULT;
	goto done;
	}

	if (size <= 0) {
	pr_err("%s: Invalid size sent to driver: %d\n",
	__func__, size);
	result = -EFAULT;
	goto done;
	}

	if (copy_from_user(data, (void *)(arg + sizeof(size)), size)) {

	pr_err("%s: fail to copy table size %d\n", __func__, size);
	result = -EFAULT;
	goto done;
	}

	if (data == NULL) {
	pr_err("%s: NULL pointer sent to driver!\n", __func__);
	result = -EFAULT;
	goto done;
	}

	switch (cmd) {
	case AUDIO_SET_AUDPROC_TX_CAL:
	audproc_path = TX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audproc_cal(audproc_path, data);
	break;
	case AUDIO_SET_AUDPROC_RX_CAL:
	audproc_path = RX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audproc_cal(audproc_path, data);
	break;
	case AUDIO_SET_AUDPROC_TX_STREAM_CAL:
	audproc_path = TX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audstrm_cal(audproc_path, data);
	break;
	case AUDIO_SET_AUDPROC_RX_STREAM_CAL:
	audproc_path = RX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audstrm_cal(audproc_path, data);
	break;
	case AUDIO_SET_AUDPROC_TX_VOL_CAL:
	audproc_path = TX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audvol_cal(audproc_path, data);
	case AUDIO_SET_AUDPROC_RX_VOL_CAL:
	audproc_path = RX_CAL;
	if (size > sizeof(struct cal_block))
	pr_err("%s: More Audproc Cal then expected, "
	"size received: %d\n", __func__, size);
	store_audvol_cal(audproc_path, data);
	break;
	case AUDIO_SET_VOCPROC_CAL:
	store_vocproc_cal(size / sizeof(struct cal_block), data);
	break;
	case AUDIO_SET_VOCPROC_STREAM_CAL:
	store_vocstrm_cal(size / sizeof(struct cal_block), data);
	break;
	case AUDIO_SET_VOCPROC_VOL_CAL:
	store_vocvol_cal(size / sizeof(struct cal_block), data);
	break;
	case AUDIO_SET_SIDETONE_CAL:
	if (size > sizeof(struct sidetone_cal))
	pr_err("%s: More sidetone cal then expected, "
	"size received: %d\n", __func__, size);
	store_sidetone_cal((struct sidetone_cal *)data);
	break;
	case AUDIO_SET_ANC_CAL:
	store_anc_cal(data);
	break;
	default:
	pr_err("ACDB=> ACDB ioctl not found!\n");
	}

	done:
	return result;
	}

	static int acdb_mmap(struct file file, struct vm_area_struct vma)
	{
	int result = 0;
	int size = vma->vm_end - vma->vm_start;

	pr_debug("%s\n", __func__);

	mutex_lock(&acdb_data.acdb_mutex);
	if (acdb_data.pmem_fd) {
	if (size <= acdb_data.pmem_len) {
	vma->vm_page_prot = pgprot_noncached(
	vma->vm_page_prot);
	result = remap_pfn_range(vma,
	vma->vm_start,
	acdb_data.paddr >> PAGE_SHIFT,
	size,
	vma->vm_page_prot);
	} else {
	pr_err("%s: Not enough PMEM memory!\n", __func__);
	result = -ENOMEM;
	}
	} else {
	pr_err("%s: PMEM 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;

	atomic_dec(&usage_count);
	atomic_read(&usage_count);

	pr_info("%s: ref count %d!\n", __func__,
	atomic_read(&usage_count));

	if (atomic_read(&usage_count) >= 1) {
	result = -EBUSY;
	} else {
	mutex_lock(&acdb_data.acdb_mutex);
	result = deregister_pmem();
	mutex_unlock(&acdb_data.acdb_mutex);
	}

	return result;
	}

	static const struct file_operations acdb_fops = {
	.owner = THIS_MODULE,
	.open = acdb_open,
	.release = acdb_release,
	.unlocked_ioctl = acdb_ioctl,
	.mmap = acdb_mmap,
	};

	struct miscdevice acdb_misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "msm_acdb",
	.fops = &acdb_fops,
	};

	static int __init acdb_init(void)
	{
	memset(&acdb_data, 0, sizeof(acdb_data));
	mutex_init(&acdb_data.acdb_mutex);
	atomic_set(&usage_count, 0);
	return misc_register(&acdb_misc);
	}

	static void __exit acdb_exit(void)
	{
	}

	module_init(acdb_init);
	module_exit(acdb_exit);

	MODULE_DESCRIPTION("MSM 8x60 Audio ACDB driver");
	MODULE_LICENSE("GPL v2");