C++ (Cpp) msm_snddev_register示例

示例#1

文件： pcm_in_proxy.c 项目： BackupWildfireDEV/ElementalX-Sense-5.0.2

static int __init pcm_in_proxy_init(void)
{
	struct msm_snddev_info *dev_info;

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		pr_err("unable to allocate memeory for msm_snddev_info\n");
		return -ENOMEM;
	}
	dev_info->name = "rtproxy_rx";
	dev_info->copp_id = RT_PROXY_PORT_001_RX;
	dev_info->acdb_id = 0;
	dev_info->private_data = NULL;
	dev_info->dev_ops.open = snddev_rtproxy_open;
	dev_info->dev_ops.close = snddev_rtproxy_close;
	dev_info->dev_ops.set_freq = snddev_rtproxy_set_freq;
	dev_info->capability = SNDDEV_CAP_RX;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	dev_info->sample_rate = 48000;

	pr_debug("init done for proxy\n");

	return misc_register(&pcm_in_proxy_misc);
}

示例#2

文件： snddev_mi2s.c 项目： Blackburn29/PsycoKernel

static int snddev_mi2s_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_mi2s_data *pdata;
	struct msm_snddev_info *dev_info;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller\n");
		return -ENODEV;
	}

	pdata = pdev->dev.platform_data;

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		pr_err("%s: uneable to allocate memeory for msm_snddev_info\n",
		       __func__);

		return -ENOMEM;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->dev_ops.open = snddev_mi2s_open;
	dev_info->dev_ops.close = snddev_mi2s_close;
	dev_info->private_data = (void *)pdata;
	dev_info->dev_ops.set_freq = snddev_mi2s_set_freq;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	dev_info->sample_rate = pdata->sample_rate;
	msm_snddev_register(dev_info);

	return rc;
}

示例#3

文件： snddev_icodec.c 项目： yxsh/ZTE-Blade-2.6.38.6

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0, i;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		pr_err("%s: invalid device data either RX or TX\n", __func__);
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->dev_ops.set_device_volume = snddev_icodec_set_device_volume;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = pdata->default_sample_rate;
	dev_info->sample_rate = pdata->default_sample_rate;
	if (pdata->capability & SNDDEV_CAP_RX) {
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			dev_info->max_voc_rx_vol[i] =
				pdata->max_voice_rx_vol[i];
			dev_info->min_voc_rx_vol[i] =
				pdata->min_voice_rx_vol[i];
		}
		dev_info->dev_ops.enable_sidetone =
		snddev_icodec_enable_sidetone;
	} else {
		dev_info->dev_ops.enable_sidetone = NULL;
	}

error:
	return rc;
}

示例#4

文件： snddev_ecodec.c 项目： ISTweak/android_kernel_sharp_is15sh

static int snddev_ecodec_probe(struct platform_device *pdev)
{
	int rc = 0, i;
	struct snddev_ecodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_ecodec_state *ecodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;

	ecodec = kzalloc(sizeof(struct snddev_ecodec_state), GFP_KERNEL);
	if (!ecodec) {
		rc = -ENOMEM;
		goto error;
	}

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(ecodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) ecodec;
	dev_info->dev_ops.open = snddev_ecodec_open;
	dev_info->dev_ops.close = snddev_ecodec_close;
	dev_info->dev_ops.set_freq = snddev_ecodec_set_freq;
	dev_info->dev_ops.enable_sidetone = NULL;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;

	msm_snddev_register(dev_info);
	ecodec->data = pdata;
	ecodec->sample_rate = 8000; /* Default to 8KHz */
	 if (pdata->capability & SNDDEV_CAP_RX) {
#ifdef CONFIG_SH_AUDIO_DRIVER
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			memcpy(dev_info->voc_rx_vol_step[i], pdata->voice_rx_vol_step[i], sizeof(dev_info->voc_rx_vol_step[i]));
		}
#else
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			dev_info->max_voc_rx_vol[i] =
				pdata->max_voice_rx_vol[i];
			dev_info->min_voc_rx_vol[i] =
				pdata->min_voice_rx_vol[i];
		}
#endif /* CONFIG_SH_AUDIO_DRIVER */
	}
error:
	return rc;
}

示例#5

文件： snddev_ecodec.c 项目： free-z4u/android_kernel_htc_msm7x30

static int snddev_ecodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_ecodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_ecodec_state *ecodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;

	ecodec = kzalloc(sizeof(struct snddev_ecodec_state), GFP_KERNEL);
	if (!ecodec) {
		rc = -ENOMEM;
		goto error;
	}

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(ecodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) ecodec;
	dev_info->dev_ops.open = snddev_ecodec_open;
	dev_info->dev_ops.close = snddev_ecodec_close;
	dev_info->dev_ops.set_freq = snddev_ecodec_set_freq;
	dev_info->dev_ops.enable_sidetone = NULL;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;

	msm_snddev_register(dev_info);
	ecodec->data = pdata;
	ecodec->sample_rate = 8000; /* Default to 8KHz */
	 if (pdata->capability & SNDDEV_CAP_RX)
		dev_info->vol_idx = pdata->vol_idx;

error:
	return rc;
}

示例#6

文件： snddev_ecodec.c 项目： DennisBold/SebastianFM-kernel

static int snddev_ecodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_ecodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_ecodec_state *ecodec;

	pr_aud_info("%s:\n", __func__);

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller\n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;

	ecodec = kzalloc(sizeof(struct snddev_ecodec_state), GFP_KERNEL);
	if (!ecodec) {
		rc = -ENOMEM;
		goto error;
	}

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(ecodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->private_data = (void *)ecodec;
	dev_info->dev_ops.open = snddev_ecodec_open;
	dev_info->dev_ops.close = snddev_ecodec_close;
	dev_info->dev_ops.set_freq = snddev_ecodec_set_freq;
	dev_info->dev_ops.enable_sidetone = NULL;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;

	msm_snddev_register(dev_info);

	ecodec->data = pdata;
	ecodec->sample_rate = ECODEC_SAMPLE_RATE;	
error:
	return rc;
}

示例#7

文件： snddev_icodec.c 项目： BobZhome/kernel-2.6.29-M860

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		pr_err("%s: invalid device data either RX or TX\n", __func__);
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->capability = pdata->capability;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = 8000; /* Default to 8KHz */
error:
	return rc;
}

示例#8

文件： snddev_mi2s.c 项目： Adrioid83/GT-I9505

static int snddev_mi2s_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_mi2s_data *pdata;
	struct msm_snddev_info *dev_info;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		return -ENODEV;
	}

	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	    (pdata->capability & SNDDEV_CAP_TX)) {
		MM_ERR("%s: invalid device data either RX or TX\n", __func__);
		return -ENODEV;
	}

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		MM_ERR("%s: uneable to allocate memeory for msm_snddev_info \n",
		       __func__);

		return -ENOMEM;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *)pdata;
	dev_info->dev_ops.open = snddev_mi2s_open;
	dev_info->dev_ops.close = snddev_mi2s_close;
	dev_info->dev_ops.set_freq = snddev_mi2s_set_freq;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	dev_info->sample_rate = pdata->default_sample_rate;

	MM_DBG("%s: probe done for %s\n", __func__, pdata->name);
	return rc;
}

示例#9

文件： snddev_virtual.c 项目： CL0SeY/i957kernel

static int snddev_virtual_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_virtual_data *pdata;
	struct msm_snddev_info *dev_info;

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

	if (!pdev || !pdev->dev.platform_data) {
		pr_err("%s: Invalid caller\n", __func__);

		rc = -EPERM;
		goto done;
	}

	pdata = pdev->dev.platform_data;

	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		pr_err("%s: Out of memory\n", __func__);

		rc = -ENOMEM;
		goto done;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->private_data = (void *) NULL;
	dev_info->dev_ops.open = snddev_virtual_open;
	dev_info->dev_ops.close = snddev_virtual_close;
	dev_info->dev_ops.set_freq = snddev_virtual_set_freq;
	dev_info->capability = pdata->capability;
	dev_info->sample_rate = 48000;
	dev_info->opened = 0;
	dev_info->sessions = 0;

	msm_snddev_register(dev_info);

done:
	return rc;
}

示例#10

文件： snddev_virtual.c 项目： 0-t/samsung-kernel-msm7x30

static int snddev_virtual_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_virtual_data *pdata;
	struct msm_snddev_info *dev_info;

	if (!pdev || !pdev->dev.platform_data) {
		MM_ERR("Invalid caller\n");
		rc = -EPERM;
		goto error;
	}
	pdata = pdev->dev.platform_data;

	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) NULL;
	dev_info->dev_ops.open = snddev_virtual_open;
	dev_info->dev_ops.close = snddev_virtual_close;
	dev_info->dev_ops.set_freq = snddev_virtual_set_freq;
	dev_info->capability = pdata->capability;
	dev_info->sample_rate = 8000;
	dev_info->opened = 0;
	dev_info->sessions = 0;

	msm_snddev_register(dev_info);

error:
	return rc;
}

示例#11

文件： snddev_icodec.c 项目： AmeriCanAndroid/aca-evo3d-omega-htc-35

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;
	static int first_time = 1;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller\n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		pr_aud_err("%s: invalid device data either RX or TX\n", __func__);
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->dev_ops.set_device_volume = snddev_icodec_set_device_volume;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = pdata->default_sample_rate;
	dev_info->sample_rate = pdata->default_sample_rate;
	dev_info->channel_mode = pdata->channel_mode;
	if (pdata->capability & SNDDEV_CAP_RX)
		dev_info->dev_ops.enable_sidetone =
			snddev_icodec_enable_sidetone;
	else
		dev_info->dev_ops.enable_sidetone = NULL;

	if (pdata->capability & SNDDEV_CAP_ANC) {
		dev_info->dev_ops.enable_anc =
		snddev_icodec_enable_anc;
	} else {
		dev_info->dev_ops.enable_anc = NULL;
	}
	if (first_time) {
		if (audio_ops->support_aic3254) {
			support_aic3254 = audio_ops->support_aic3254();
		} else {
			support_aic3254 = 0;
		}
		pr_aud_info("%s: support_aic3254 = %d\n",
			__func__, support_aic3254);

		if (audio_ops->support_adie) {
			support_adie = audio_ops->support_adie();
		} else {
			support_adie = 0;
		}
		pr_aud_info("%s: support_adie = %d\n",
			__func__, support_adie);

		if (audio_ops->is_msm_i2s_slave) {
			msm_codec_i2s_slave_mode = audio_ops->is_msm_i2s_slave();
		} else {
			msm_codec_i2s_slave_mode = 0;
		}
		pr_aud_info("%s: msm_codec_i2s_slave_mode = %d\n",
			__func__, msm_codec_i2s_slave_mode);

		if (audio_ops->support_aic3254_use_mclk)
			support_aic3254_use_mclk = \
					audio_ops->support_aic3254_use_mclk();
		else
			support_aic3254_use_mclk = 0;
		pr_aud_info("%s: support_aic3254_use_mclk = %d\n",
			__func__, support_aic3254_use_mclk);

		first_time = 0;
	}

error:
	return rc;
}

示例#12

文件： snddev_icodec.c 项目： Leoyzen/Charm-CM10-Primou

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;
	static int first_time = 1;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		MM_AUD_ERR("%s: invalid device data either RX or TX\n", __func__);
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->dev_ops.set_device_volume = snddev_icodec_set_device_volume;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = pdata->default_sample_rate;
	dev_info->sample_rate = pdata->default_sample_rate;

	if (first_time) {
		if (audio_ops->support_aic3254) {
			support_aic3254 = audio_ops->support_aic3254();
			MM_AUD_INFO("%s: support_aic3254 = %d\n",
				__func__, support_aic3254);
		}
		if (audio_ops->support_adie) {
			support_adie = audio_ops->support_adie();
			MM_AUD_INFO("%s: support_adie = %d\n",
				__func__, support_adie);
		}
		first_time = 0;
	}

	if (pdata->capability & SNDDEV_CAP_RX) {
		dev_info->vol_idx = pdata->vol_idx;
		if (support_aic3254 || !support_adie)
			dev_info->dev_ops.enable_sidetone = NULL;
		else
			dev_info->dev_ops.enable_sidetone =
				snddev_icodec_enable_sidetone;
	} else {
		dev_info->dev_ops.enable_sidetone = NULL;
	}

error:
	return rc;
}

示例#13

文件： snddev_icodec.c 项目： ISTweak/android_kernel_sharp_c01

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0, i;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		MM_ERR("invalid device data either RX or TX\n");
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->dev_ops.set_device_volume = snddev_icodec_set_device_volume;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = pdata->default_sample_rate;
	dev_info->sample_rate = pdata->default_sample_rate;
	if (pdata->capability & SNDDEV_CAP_RX) {
#ifdef CONFIG_SH_AUDIO_DRIVER
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			memcpy(dev_info->voc_rx_vol_step[i], pdata->voice_rx_vol_step[i], sizeof(dev_info->voc_rx_vol_step[i]));
		}
#else
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			dev_info->max_voc_rx_vol[i] =
				pdata->max_voice_rx_vol[i];
			dev_info->min_voc_rx_vol[i] =
				pdata->min_voice_rx_vol[i];
		}
#endif /* CONFIG_SH_AUDIO_DRIVER */
		/*sidetone is enabled only for  the device which
		property set for side tone*/
		if (pdata->property & SIDE_TONE_MASK)
			dev_info->dev_ops.enable_sidetone =
				snddev_icodec_enable_sidetone;
		else
			dev_info->dev_ops.enable_sidetone = NULL;
	} else {
		dev_info->dev_ops.enable_sidetone = NULL;
	}

error:
	return rc;
}

示例#14

文件： snddev_ecodec.c 项目： andr00ib/3.0.94-victor-kernel

static int snddev_ecodec_probe(struct platform_device *pdev)
{
	int rc = 0, i;
	struct snddev_ecodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_ecodec_state *ecodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller \n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;

	ecodec = kzalloc(sizeof(struct snddev_ecodec_state), GFP_KERNEL);
	if (!ecodec) {
		rc = -ENOMEM;
		goto error;
	}

	dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(ecodec);
		rc = -ENOMEM;
		goto error;
	}

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->acdb_id = pdata->acdb_id;
	dev_info->private_data = (void *) ecodec;
	dev_info->dev_ops.open = snddev_ecodec_open;
	dev_info->dev_ops.close = snddev_ecodec_close;
	dev_info->dev_ops.set_freq = snddev_ecodec_set_freq;
	dev_info->dev_ops.enable_sidetone = NULL;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;

	msm_snddev_register(dev_info);
	ecodec->data = pdata;
	ecodec->sample_rate = 8000; /* Default to 8KHz */
	 if (pdata->capability & SNDDEV_CAP_RX) {
		for (i = 0; i < VOC_RX_VOL_ARRAY_NUM; i++) {
			dev_info->max_voc_rx_vol[i] =
				pdata->max_voice_rx_vol[i];
			dev_info->min_voc_rx_vol[i] =
				pdata->min_voice_rx_vol[i];
		}
	}


	/* LGE_CHANGE
	  * added for BT loopback
	  * 2010-03-22, [email protected]
	  */
	/* Register sysfs hooks */
	rc = device_create_file(&pdev->dev, &dev_attr_btlb);
	if (rc) {
		printk(KERN_ALERT "sysfs register failed for loopback attr\n");
		goto error;
	}


error:
	return rc;
}

示例#15

文件： snddev_icodec.c 项目： gnychis/sgs2-skyrocket-kernel

static int snddev_icodec_probe(struct platform_device *pdev)
{
	int rc = 0;
	struct snddev_icodec_data *pdata;
	struct msm_snddev_info *dev_info;
	struct snddev_icodec_state *icodec;

	if (!pdev || !pdev->dev.platform_data) {
		printk(KERN_ALERT "Invalid caller\n");
		rc = -1;
		goto error;
	}
	pdata = pdev->dev.platform_data;
	if ((pdata->capability & SNDDEV_CAP_RX) &&
	   (pdata->capability & SNDDEV_CAP_TX)) {
		pr_err("%s: invalid device data either RX or TX\n", __func__);
		goto error;
	}
	icodec = kzalloc(sizeof(struct snddev_icodec_state), GFP_KERNEL);
	if (!icodec) {
		rc = -ENOMEM;
		goto error;
	}
	dev_info = kmalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
	if (!dev_info) {
		kfree(icodec);
		rc = -ENOMEM;
		goto error;
	}

#if 0//clean up source		defined(CONFIG_USA_MODEL_SGH_T989) || defined(CONFIG_KOR_MODEL_SHV_E110S)
#if defined(CONFIG_USA_MODEL_SGH_T989)
	if(get_hw_rev()>=0x9) //Rev0.3, Rev0.3A
#elif defined(CONFIG_KOR_MODEL_SHV_E110S)
	if(get_hw_rev()!=0x4) // NOT Rev0.3
#endif
	{
		pr_info("[QTR] HPH_CAPLESS_MODE  (get_hw_rev:%d) \n", get_hw_rev() );
	}
	else
	{
		if(strcmp(pdata->name, "headset_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &headset_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "headset_vt_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &headset_vt_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "headset_voip_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &headset_voip_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "fm_radio_headset_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &fm_radio_headset_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "tty_headset_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &tty_headset_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "headset_call_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &headset_call_rx_legacy_48KHz_osr256_actions[0];
		}
		if(strcmp(pdata->name, "speaker_headset_rx")==0)
		{
			pr_info("[QTR] %s name: %s\n", __func__, pdata->name); 
			pdata->profile->settings->actions = &speaker_headset_rx_legacy_48KHz_osr256_actions[0];
		}
	}
#endif

	dev_info->name = pdata->name;
	dev_info->copp_id = pdata->copp_id;
	dev_info->private_data = (void *) icodec;
	dev_info->dev_ops.open = snddev_icodec_open;
	dev_info->dev_ops.close = snddev_icodec_close;
	dev_info->dev_ops.set_freq = snddev_icodec_set_freq;
	dev_info->dev_ops.set_device_volume = snddev_icodec_set_device_volume;
	dev_info->capability = pdata->capability;
	dev_info->opened = 0;
	msm_snddev_register(dev_info);
	icodec->data = pdata;
	icodec->sample_rate = pdata->default_sample_rate;
	dev_info->sample_rate = pdata->default_sample_rate;
	dev_info->channel_mode = pdata->channel_mode;
	if (pdata->capability & SNDDEV_CAP_RX)
		dev_info->dev_ops.enable_sidetone =
			snddev_icodec_enable_sidetone;
	else
		dev_info->dev_ops.enable_sidetone = NULL;

	if (pdata->capability & SNDDEV_CAP_ANC) {
		dev_info->dev_ops.enable_anc =
		snddev_icodec_enable_anc;
	} else {
		dev_info->dev_ops.enable_anc = NULL;
	}
error:
	return rc;
}