M7350/kernel/arch/arm/mach-msm/qdsp5v2/afe.c

/* Copyright (c) 2009-2011, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * 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/module.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/jiffies.h>
#include <linux/debugfs.h>
#include <asm/uaccess.h>
#include <mach/qdsp5v2/qdsp5afecmdi.h>
#include <mach/qdsp5v2/qdsp5afemsg.h>
#include <mach/qdsp5v2/afe.h>
#include <mach/msm_adsp.h>
#include <mach/debug_mm.h>

#define AFE_MAX_TIMEOUT 500 /* 500 ms */
#define AFE_MAX_CLNT 6 /* 6 HW path defined so far */
#define GETDEVICEID(x) ((x) - 1)

struct msm_afe_state {
	struct msm_adsp_module *mod;
	struct msm_adsp_ops    adsp_ops;
	struct mutex           lock;
	u8                     in_use;
	u8                     codec_config[AFE_MAX_CLNT];
	wait_queue_head_t      wait;
	u8			aux_conf_flag;
};

#ifdef CONFIG_DEBUG_FS
static struct dentry *debugfs_afelb;
#endif


static struct msm_afe_state the_afe_state;

#define afe_send_queue(afe, cmd, len) \
  msm_adsp_write(afe->mod, QDSP_apuAfeQueue, \
	cmd, len)

static void afe_dsp_event(void *data, unsigned id, size_t len,
			    void (*getevent)(void *ptr, size_t len))
{
	struct msm_afe_state *afe = data;

	MM_DBG("msg_id %d \n", id);

	switch (id) {
	case AFE_APU_MSG_CODEC_CONFIG_ACK: {
		struct afe_msg_codec_config_ack afe_ack;
		getevent(&afe_ack, AFE_APU_MSG_CODEC_CONFIG_ACK_LEN);
		MM_DBG("%s: device_id: %d device activity: %d\n", __func__,
		afe_ack.device_id, afe_ack.device_activity);
		if (afe_ack.device_activity == AFE_MSG_CODEC_CONFIG_DISABLED)
			afe->codec_config[GETDEVICEID(afe_ack.device_id)] = 0;
		else
			afe->codec_config[GETDEVICEID(afe_ack.device_id)] =
			afe_ack.device_activity;

		wake_up(&afe->wait);
		break;
	}
	case AFE_APU_MSG_VOC_TIMING_SUCCESS:
		MM_INFO("Received VOC_TIMING_SUCCESS message from AFETASK\n");
		break;
	case ADSP_MESSAGE_ID:
		MM_DBG("Received ADSP event: module enable/disable(audpptask)");
		break;
	default:
		MM_ERR("unexpected message from afe \n");
	}

	return;
}

static void afe_dsp_codec_config(struct msm_afe_state *afe,
	u8 path_id, u8 enable, struct msm_afe_config *config)
{
	struct afe_cmd_codec_config cmd;

	MM_DBG("%s() %p\n", __func__, config);
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_CODEC_CONFIG_CMD;
	cmd.device_id = path_id;
	cmd.activity = enable;
	if (config) {
		MM_DBG("%s: sample_rate %x ch mode %x vol %x\n",
			__func__, config->sample_rate,
			config->channel_mode, config->volume);
		cmd.sample_rate = config->sample_rate;
		cmd.channel_mode = config->channel_mode;
		cmd.volume = config->volume;
	}
	afe_send_queue(afe, &cmd, sizeof(cmd));
}
/* Function is called after afe module been enabled */
void afe_loopback(int enable)
{
	struct afe_cmd_loopback cmd;
	struct msm_afe_state *afe;

	afe = &the_afe_state;
	MM_DBG("enable %d\n", enable);
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_LOOPBACK;
	if (enable)
		cmd.enable_flag = AFE_LOOPBACK_ENABLE_COMMAND;

	afe_send_queue(afe, &cmd, sizeof(cmd));
}
EXPORT_SYMBOL(afe_loopback);

void afe_ext_loopback(int enable, int rx_copp_id, int tx_copp_id)
{
	struct afe_cmd_ext_loopback cmd;
	struct msm_afe_state *afe;

	afe = &the_afe_state;
	MM_DBG("enable %d\n", enable);
	if ((rx_copp_id == 0) && (tx_copp_id == 0)) {
		afe_loopback(enable);
	} else {
		memset(&cmd, 0, sizeof(cmd));
		cmd.cmd_id = AFE_CMD_EXT_LOOPBACK;
		cmd.source_id = tx_copp_id;
		cmd.dst_id = rx_copp_id;
		if (enable)
			cmd.enable_flag = AFE_LOOPBACK_ENABLE_COMMAND;

		afe_send_queue(afe, &cmd, sizeof(cmd));
	}
}
EXPORT_SYMBOL(afe_ext_loopback);

void afe_device_volume_ctrl(u16 device_id, u16 device_volume)
{
	struct afe_cmd_device_volume_ctrl cmd;
	struct msm_afe_state *afe;

	afe = &the_afe_state;
	MM_DBG("device 0x%4x volume 0x%4x\n", device_id, device_volume);
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_DEVICE_VOLUME_CTRL;
	cmd.device_id = device_id;
	cmd.device_volume = device_volume;
	afe_send_queue(afe, &cmd, sizeof(cmd));
}
EXPORT_SYMBOL(afe_device_volume_ctrl);

int afe_enable(u8 path_id, struct msm_afe_config *config)
{
	struct msm_afe_state *afe = &the_afe_state;
	int rc;

	MM_DBG("%s: path %d\n", __func__, path_id);
	if ((GETDEVICEID(path_id) < 0) || (GETDEVICEID(path_id) > 5)) {
		MM_ERR("Invalid path_id: %d\n", path_id);
		return -EINVAL;
	}
	mutex_lock(&afe->lock);
	if (!afe->in_use && !afe->aux_conf_flag) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_ERR("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	/* Issue codec config command */
	afe_dsp_codec_config(afe, path_id, 1, config);
	rc = wait_event_timeout(afe->wait,
		afe->codec_config[GETDEVICEID(path_id)],
		msecs_to_jiffies(AFE_MAX_TIMEOUT));
	if (!rc) {
		MM_ERR("AFE failed to respond within %d ms\n", AFE_MAX_TIMEOUT);
		rc = -ENODEV;
		if (!afe->in_use) {
			if (!afe->aux_conf_flag ||
			(afe->aux_conf_flag &&
			(path_id == AFE_HW_PATH_AUXPCM_RX ||
			path_id == AFE_HW_PATH_AUXPCM_TX))) {
				/* clean up if there is no client */
				msm_adsp_disable(afe->mod);
				msm_adsp_put(afe->mod);
				afe->aux_conf_flag = 0;
				afe->mod = NULL;
			}
		}

	} else {
		rc = 0;
		afe->in_use++;
	}

	mutex_unlock(&afe->lock);
	return rc;

error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_enable);

int afe_config_fm_codec(int fm_enable, uint16_t source)
{
	struct afe_cmd_fm_codec_config cmd;
	struct msm_afe_state *afe = &the_afe_state;
	int rc = 0;
	int i = 0;
	unsigned short *ptrmem = (unsigned short *)&cmd;

	MM_INFO(" configure fm codec\n");
	mutex_lock(&afe->lock);
	if (!afe->in_use) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_ERR("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_FM_RX_ROUTING_CMD;
	cmd.enable = fm_enable;
	cmd.device_id = source;

	for (i = 0; i < sizeof(cmd)/2; i++, ++ptrmem)
		MM_DBG("cmd[%d]=0x%04x\n", i, *ptrmem);
	afe_send_queue(afe, &cmd, sizeof(cmd));

	mutex_unlock(&afe->lock);
	return rc;
error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_config_fm_codec);

int afe_config_fm_volume(uint16_t volume)
{
	struct afe_cmd_fm_volume_config cmd;
	struct msm_afe_state *afe = &the_afe_state;
	int rc = 0;

	MM_INFO(" configure fm volume\n");
	mutex_lock(&afe->lock);
	if (!afe->in_use) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_ERR("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_FM_PLAYBACK_VOLUME_CMD;
	cmd.volume = volume;

	afe_send_queue(afe, &cmd, sizeof(cmd));

	mutex_unlock(&afe->lock);
	return rc;
error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_config_fm_volume);

int afe_config_fm_calibration_gain(uint16_t device_id,
			uint16_t calibration_gain)
{
	struct afe_cmd_fm_calibgain_config cmd;
	struct msm_afe_state *afe = &the_afe_state;
	int rc = 0;

	MM_INFO("Configure for rx device = 0x%4x, gain = 0x%4x\n", device_id,
			calibration_gain);
	mutex_lock(&afe->lock);
	if (!afe->in_use) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_ERR("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_FM_CALIBRATION_GAIN_CMD;
	cmd.device_id = device_id;
	cmd.calibration_gain = calibration_gain;

	afe_send_queue(afe, &cmd, sizeof(cmd));

	mutex_unlock(&afe->lock);
	return rc;
error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_config_fm_calibration_gain);

int afe_config_aux_codec(int pcm_ctl_value, int aux_codec_intf_value,
				int data_format_pad)
{
	struct afe_cmd_aux_codec_config cmd;
	struct msm_afe_state *afe = &the_afe_state;
	int rc = 0;

	MM_DBG(" configure aux codec \n");
	mutex_lock(&afe->lock);
	if (!afe->in_use && !afe->aux_conf_flag) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_ERR("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	afe->aux_conf_flag = 1;
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_AUX_CODEC_CONFIG_CMD;
	cmd.dma_path_ctl = 0;
	cmd.pcm_ctl = pcm_ctl_value;
	cmd.eight_khz_int_mode = 0;
	cmd.aux_codec_intf_ctl = aux_codec_intf_value;
	cmd.data_format_padding_info = data_format_pad;

	afe_send_queue(afe, &cmd, sizeof(cmd));

	mutex_unlock(&afe->lock);
	return rc;
error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_config_aux_codec);

int afe_config_rmc_block(struct acdb_rmc_block *acdb_rmc)
{
	struct afe_cmd_cfg_rmc cmd;
	struct msm_afe_state *afe = &the_afe_state;
	int rc = 0;
	int i = 0;
	unsigned short *ptrmem = (unsigned short *)&cmd;

	MM_DBG(" configure rmc block\n");
	mutex_lock(&afe->lock);
	if (!afe->in_use && !afe->mod) {
		/* enable afe */
		rc = msm_adsp_get("AFETASK", &afe->mod, &afe->adsp_ops, afe);
		if (rc < 0) {
			MM_DBG("%s: failed to get AFETASK module\n", __func__);
			goto error_adsp_get;
		}
		rc = msm_adsp_enable(afe->mod);
		if (rc < 0)
			goto error_adsp_enable;
	}
	memset(&cmd, 0, sizeof(cmd));
	cmd.cmd_id = AFE_CMD_CFG_RMC_PARAMS;

	cmd.rmc_mode = acdb_rmc->rmc_enable;
	cmd.rmc_ipw_length_ms =	acdb_rmc->rmc_ipw_length_ms;
	cmd.rmc_peak_length_ms = acdb_rmc->rmc_peak_length_ms;
	cmd.rmc_init_pulse_length_ms = acdb_rmc->rmc_init_pulse_length_ms;
	cmd.rmc_total_int_length_ms = acdb_rmc->rmc_total_int_length_ms;
	cmd.rmc_rampupdn_length_ms = acdb_rmc->rmc_rampupdn_length_ms;
	cmd.rmc_delay_length_ms = acdb_rmc->rmc_delay_length_ms;
	cmd.rmc_detect_start_threshdb = acdb_rmc->rmc_detect_start_threshdb;
	cmd.rmc_init_pulse_threshdb = acdb_rmc->rmc_init_pulse_threshdb;

	for (i = 0; i < sizeof(cmd)/2; i++, ++ptrmem)
		MM_DBG("cmd[%d]=0x%04x\n", i, *ptrmem);
	afe_send_queue(afe, &cmd, sizeof(cmd));

	mutex_unlock(&afe->lock);
	return rc;
error_adsp_enable:
	msm_adsp_put(afe->mod);
	afe->mod = NULL;
error_adsp_get:
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_config_rmc_block);

int afe_disable(u8 path_id)
{
	struct msm_afe_state *afe = &the_afe_state;
	int rc;

	mutex_lock(&afe->lock);

	BUG_ON(!afe->in_use);
	MM_DBG("%s() path_id:%d codec state:%d\n", __func__, path_id,
	afe->codec_config[GETDEVICEID(path_id)]);
	afe_dsp_codec_config(afe, path_id, 0, NULL);
	rc = wait_event_timeout(afe->wait,
		!afe->codec_config[GETDEVICEID(path_id)],
		msecs_to_jiffies(AFE_MAX_TIMEOUT));
	if (!rc) {
		MM_ERR("AFE failed to respond within %d ms\n", AFE_MAX_TIMEOUT);
		rc = -1;
	} else
		rc = 0;
	afe->in_use--;
	MM_DBG("%s() in_use:%d \n", __func__, afe->in_use);
	if (!afe->in_use) {
		msm_adsp_disable(afe->mod);
		msm_adsp_put(afe->mod);
		afe->aux_conf_flag = 0;
		afe->mod = NULL;
	}
	mutex_unlock(&afe->lock);
	return rc;
}
EXPORT_SYMBOL(afe_disable);


#ifdef CONFIG_DEBUG_FS
static int afe_debug_open(struct inode *inode, struct file *file)
{
	file->private_data = inode->i_private;
	MM_INFO("debug intf %s\n", (char *) file->private_data);
	return 0;
}

static ssize_t afe_debug_write(struct file *filp,
	const char __user *ubuf, size_t cnt, loff_t *ppos)
{
	char *lb_str = filp->private_data;
	char cmd;

	if (get_user(cmd, ubuf))
		return -EFAULT;

	MM_INFO("%s %c\n", lb_str, cmd);

	if (!strcmp(lb_str, "afe_loopback")) {
		switch (cmd) {
		case '1':
			afe_loopback(1);
			break;
		case '0':
			afe_loopback(0);
			break;
		}
	}

	return cnt;
}

static const struct file_operations afe_debug_fops = {
	.open = afe_debug_open,
	.write = afe_debug_write
};
#endif

static int __init afe_init(void)
{
	struct msm_afe_state *afe = &the_afe_state;

	MM_INFO("AFE driver init\n");

	memset(afe, 0, sizeof(struct msm_afe_state));
	afe->adsp_ops.event = afe_dsp_event;
	mutex_init(&afe->lock);
	init_waitqueue_head(&afe->wait);

#ifdef CONFIG_DEBUG_FS
	debugfs_afelb = debugfs_create_file("afe_loopback",
	S_IFREG | S_IWUGO, NULL, (void *) "afe_loopback",
	&afe_debug_fops);
#endif

	return 0;
}

static void __exit afe_exit(void)
{
	MM_INFO("AFE driver exit\n");
#ifdef CONFIG_DEBUG_FS
	if (debugfs_afelb)
		debugfs_remove(debugfs_afelb);
#endif
	if (the_afe_state.mod)
		msm_adsp_put(the_afe_state.mod);
	return;
}

module_init(afe_init);
module_exit(afe_exit);

MODULE_DESCRIPTION("MSM AFE driver");
MODULE_LICENSE("GPL v2");