C++ (Cpp) acoustic_register_ops Beispiele

Beispiel #1

Datei: board-rider-audio.c Projekt: AmeriCanAndroid/kernel-android-msm-2.6.35

void __init rider_audio_init(void)
{
	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);

#ifdef CONFIG_MSM8X60_AUDIO
	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_icodec_ops(&iops);
	htc_8x60_register_ecodec_ops(&eops);
	acoustic_register_ops(&acoustic);
	htc_8x60_register_aic3254_ops(&aops);
	msm_set_voc_freq(8000, 8000);
#endif

	aic3254_register_ctl_ops(&cops);

	/* PMIC GPIO Init (See board-rider.c) */
	/* Reset AIC3254 */
	rider_reset_3254();
	gpio_tlmm_config(
		GPIO_CFG(RIDER_AUD_CDC_LDO_SEL, 0, GPIO_CFG_OUTPUT,
			GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
	gpio_tlmm_config(msm_snddev_gpio[0], GPIO_CFG_DISABLE);
	gpio_tlmm_config(msm_snddev_gpio[1], GPIO_CFG_DISABLE);
	gpio_tlmm_config(msm_snddev_gpio[2], GPIO_CFG_DISABLE);
}

Beispiel #2

Datei: board-glacier-audio.c Projekt: Akinus/htc-kernel-msm7x30

void __init glacier_audio_init(void)
{
	static struct pm8058_gpio audio_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull           = PM_GPIO_PULL_NO,
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function       = PM_GPIO_FUNC_NORMAL,
		.vin_sel        = 6,
	};

	mutex_init(&bt_sco_lock);
#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
#endif
	pm8058_gpio_config(GLACIER_AUD_SPK_ENO, &audio_pwr);
	pm8058_gpio_config(GLACIER_AUD_HP_EN, &audio_pwr);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(GLACIER_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(GLACIER_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(GLACIER_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #3

Datei: board-htcleo-audio.c Projekt: ajeet17181/fathom-kernel

void __init htcleo_audio_init(void)
{
    mutex_init(&mic_lock);
    mutex_init(&bt_sco_lock);
    q6audio_register_analog_ops(&ops);
    acoustic_register_ops(&acoustic);
}

Beispiel #4

Datei: board-deluxe_u-audio.c Projekt: Mantouidev/htc_msm8960_kernel

static int __init deluxe_u_audio_init(void)
{
        int ret = 0;

	static uint32_t audio_i2s_table[] = {
		GPIO_CFG(35, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
		GPIO_CFG(36, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
		GPIO_CFG(37, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
	};
	pr_info("%s", __func__);
	gpio_request(HAC_PAMP_GPIO, "AUDIO_HAC_AMP");
	gpio_direction_output(HAC_PAMP_GPIO, 0);
	gpio_free(HAC_PAMP_GPIO);
	gpio_tlmm_config(audio_i2s_table[0], GPIO_CFG_DISABLE);
	gpio_tlmm_config(audio_i2s_table[1], GPIO_CFG_DISABLE);
	gpio_tlmm_config(audio_i2s_table[2], GPIO_CFG_DISABLE);

	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	htc_register_compr_q6_ops(&cops);
	acoustic_register_ops(&acoustic);
	pr_info("%s", __func__);
	return ret;

}

Beispiel #5

Datei: board-htcleo-audio.c Projekt: DrGrip/tiamat-2.6.38-LEO-Dr_Grip

void __init htcleo_audio_init(void)
{
    mutex_init(&mic_lock);
    mutex_init(&bt_sco_lock);
    q6audio_register_analog_ops(&ops);
    acoustic_register_ops(&acoustic);
    hs_mic_register();
    mic_gain_file = create_proc_entry(PROCFS_NAME, 0644, NULL);

    if (mic_gain_file == NULL) {
        remove_proc_entry(PROCFS_NAME, NULL);
        printk(KERN_ALERT "Error: Could not initialize /proc/%s\n",
            PROCFS_NAME);
        return;
    }

    mic_gain_file->read_proc  = mic_level_read;
    mic_gain_file->write_proc = mic_level_write;
    //mic_gain_file->mode       = S_IFREG | S_IRUGO;
    mic_gain_file->uid        = 0;
    mic_gain_file->gid        = 0;

    printk(KERN_INFO "/proc/%s created\n", PROCFS_NAME);
//        q6audio_set_acdb_file("default_PMIC.acdb");
}

Beispiel #6

Datei: board-runnymede-audio.c Projekt: DevChun/htc-runnymede-ics-kernel

void __init runnymede_audio_init(void)
{

	mutex_init(&bt_sco_lock);
	mutex_init(&audio_2v85_usage_lock);
	audio_2v85_usage_counter = 0;

	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
	aic3254_register_ctl_ops(&cops);

	gpio_request(runnymede_AUD_MICPATH_SEL, "aud_mic_sel");
	gpio_direction_output(runnymede_AUD_MICPATH_SEL, 1);
	gpio_set_value(runnymede_AUD_MICPATH_SEL, 0);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(runnymede_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(runnymede_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(runnymede_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #7

Datei: board-incrediblec-audio.c Projekt: tiny4579/tiny-gingersense

void __init incrediblec_audio_init(void)
{
	mutex_init(&mic_lock);
	mutex_init(&bt_sco_lock);
	q6audio_register_analog_ops(&ops);
	acoustic_register_ops(&acoustic);
	aboost = 1;
}

Beispiel #8

Datei: board-htcleo-audio.c Projekt: marc1706/hd2_kernel

void __init htcleo_audio_init(void)
{
    mutex_init(&mic_lock);
    mutex_init(&bt_sco_lock);
    q6audio_register_analog_ops(&ops);
    acoustic_register_ops(&acoustic);
    hs_mic_register();
//        q6audio_set_acdb_file("default_PMIC.acdb");
}

Beispiel #9

Datei: board-bravo-audio.c Projekt: Redux/rx-kernel

void __init bravo_audio_init(void)
{
	mutex_init(&mic_lock);
	mutex_init(&bt_sco_lock);
	q6audio_register_analog_ops(&ops);
	acoustic_register_ops(&acoustic);
	if (is_cdma_version(system_rev))
		q6audio_set_acdb_file("default_PMIC.acdb");
}

Beispiel #10

Datei: board-bravo-audio.c Projekt: amarius/Supernova-Kernel

void __init bravo_audio_init(void)
{
	mutex_init(&mic_lock);
	mutex_init(&bt_sco_lock);
#if defined(CONFIG_QSD_AUDIO)
	q6audio_register_analog_ops(&ops);
#endif
	acoustic_register_ops(&acoustic);
}

Beispiel #11

Datei: board-ville-audio.c Projekt: BackupWildfireDEV/ElementalX-Sense-5.0.2

static int __init ville_audio_init(void)
{
	int ret;

	if (!cpu_is_msm8960()) {
		pr_info("%s: Not the right machine type\n", __func__);
		return -ENODEV ;
	}
	pr_info("%s", __func__);

	msm8960_snd_device = platform_device_alloc("soc-audio", 0);
	if (!msm8960_snd_device) {
		pr_err("Platform device allocation failed\n");
		return -ENOMEM;
	}

	memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common));
	memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common),
		msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x));

	platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960);
	ret = platform_device_add(msm8960_snd_device);
	if (ret) {
		platform_device_put(msm8960_snd_device);
		return ret;
	}

	msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1);
	if (!msm8960_snd_tabla1x_device) {
		pr_err("Platform device allocation failed\n");
		return -ENOMEM;
	}

	memcpy(msm8960_tabla1x_dai, msm8960_dai_common,
		sizeof(msm8960_dai_common));
	memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common),
		msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x));

	platform_set_drvdata(msm8960_snd_tabla1x_device,
		&snd_soc_tabla1x_card_msm8960);
	ret = platform_device_add(msm8960_snd_tabla1x_device);
	if (ret) {
		platform_device_put(msm8960_snd_tabla1x_device);
		return ret;
	}

	mutex_init(&cdc_mclk_mutex);
	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	acoustic_register_ops(&acoustic);
	return ret;

}

Beispiel #12

Datei: board-m7wlj-audio.c Projekt: KING000/android_kernel_htc_m7wlj

static int __init m7wl_audio_init(void)
{
        int ret = 0;

	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	htc_register_compr_q6_ops(&cops);
	acoustic_register_ops(&acoustic);
	m7wl_audio_pmic_mpp_config();
	pr_info("%s", __func__);
	return ret;

}

Beispiel #13

Datei: board-elite-audio.c Projekt: Team-Blackout/BeastMode-Evita

static int __init elite_audio_init(void)
{
	int ret;
	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION
	int retval = 0;
	#endif
	pr_aud_info("%s", __func__);

	msm8960_snd_device = platform_device_alloc("soc-audio", 0);
	if (!msm8960_snd_device) {
		pr_aud_err("%s, Platform device allocation failed\n", __func__);
		return -ENOMEM;
	}

	platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960);
	ret = platform_device_add(msm8960_snd_device);
	if (ret) {
		pr_aud_err("%s, Platform device add failed\n", __func__);
		platform_device_put(msm8960_snd_device);
		return ret;
	}

	mutex_init(&audio_notifier_lock);
	pr_aud_info("%s: register cable detect func for dock", __func__);
	ret = cable_detect_register_notifier(&audio_dock_notifier);

	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION
	/* Create two audio status file nodes, audio_speaker_t and
	 * audio_headset_t under /sys/audio_stats/					*/
	if (audio_stat_kobj == NULL)
	{
		audio_stat_kobj = kobject_create_and_add("audio_stats", NULL);
		retval = sysfs_create_file(audio_stat_kobj, attrs[0]);
		if (!retval)
		{
			pr_err("Speaker file node creation failed under kobject\n");
		}
		retval = sysfs_create_file(audio_stat_kobj, attrs[1]);
		if (!retval)
		{
			pr_err("Headset file node creation failed under kobject\n");
		}
	}
	#endif

	htc_8960_register_q6asm_ops(&qops);
	htc_8960_register_pcm_routing_ops(&rops);
	acoustic_register_ops(&acoustic);
	return ret;

}

Beispiel #14

Datei: board-doubleshot-audio.c Projekt: TeamSXL/ds-kernel-3.4

void __init doubleshot_audio_init(void)
{
	mutex_init(&mic_lock);

	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_register_q6asm_ops(&qops);
	acoustic_register_ops(&acoustic);
	htc_8x60_register_aic3254_ops(&aops);
	msm_set_voc_freq(8000, 8000);	
	aic3254_register_ctl_ops(&cops);
	doubleshot_audio_gpios_init();
	doubleshot_reset_3254();
}

Beispiel #15

Datei: board-mecha-audio.c Projekt: drod2169/drodspeed-cfs

void __init mecha_audio_init(void)
{
	static struct pm8058_gpio tpa2051_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull	        = PM_GPIO_PULL_NO,
		.vin_sel	= 6,	  /* S3 1.8 V */
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function	= PM_GPIO_FUNC_NORMAL,
	};

	mutex_init(&bt_sco_lock);

#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
#endif
	aic3254_register_ctl_ops(&cops);

	pm8058_gpio_config(MECHA_AUD_SPK_SD, &tpa2051_pwr);

	if (system_rev == 0)
		pm8058_gpio_config(MECHA_GPIO_AUD_AMP_EN_XA, &tpa2051_pwr);
	else {
		gpio_request(MECHA_GPIO_AUD_AMP_EN, "aud_amp_en");
		gpio_direction_output(MECHA_GPIO_AUD_AMP_EN, 1);
		gpio_set_value(MECHA_GPIO_AUD_AMP_EN, 0);
	}

	gpio_request(MECHA_AUD_MICPATH_SEL, "aud_mic_sel");
	gpio_direction_output(MECHA_AUD_MICPATH_SEL, 1);
	gpio_set_value(MECHA_AUD_MICPATH_SEL, 0);

	gpio_set_value(MECHA_AUD_CODEC_RST, 0);
	mdelay(1);
	gpio_set_value(MECHA_AUD_CODEC_RST, 1);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(MECHA_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(MECHA_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(MECHA_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #16

Datei: board-m7wl-audio.c Projekt: talnoah/Sprint-One-4.2.2-Sense

static int __init m7wl_audio_init(void)
{
        int ret = 0;

	
	gpio_request(RCV_PAMP_GPIO, "AUDIO_RCV_AMP");
	gpio_tlmm_config(GPIO_CFG(67, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	htc_register_compr_q6_ops(&cops);
	acoustic_register_ops(&acoustic);
	pr_info("%s", __func__);
	return ret;

}

Beispiel #17

Datei: board-doubleshot-audio.c Projekt: scverhagen/htc-kernel-doubleshot

void __init doubleshot_audio_init(void)
{
	int i = 0;
	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);

#ifdef CONFIG_MSM8X60_AUDIO
	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_icodec_ops(&iops);
	htc_8x60_register_ecodec_ops(&eops);
	acoustic_register_ops(&acoustic);
	htc_8x60_register_aic3254_ops(&aops);

	/*fix voice sample rate as 8KHz for 3254 dual mic.*/
	msm_set_voc_freq(8000, 8000);
#endif
	aic3254_register_ctl_ops(&cops);

	/* PMIC GPIO Init (See board-doubleshot.c) */

	/*
	EVT XA : 0x0000FFFF
	DVT XB : 0x0101FFFF
	DVT XC : 0x0202FFFF

	Use XB as critiria because there are some XA devices did
	not follow this rule.
	*/
	pr_info("%s: system_rev = 0x%08x", __func__, system_rev);
	switch (system_rev)
	{
	case XA_DEV:
		emic_micbias = OTHC_MICBIAS_1;
		bmic_micbias = OTHC_MICBIAS_2;
		break;
	case XB_DEV:
	case XC_DEV:
	default:
		emic_micbias = OTHC_MICBIAS_2;
		bmic_micbias = OTHC_MICBIAS_1;
		break;
	}
	/* Reset AIC3254 */
	doubleshot_reset_3254();
	for (i=0 ; i<sizeof(msm_snddev_gpio); i++)
		gpio_tlmm_config(msm_snddev_gpio[i], GPIO_CFG_DISABLE);
}

Beispiel #18

Datei: board-shooter_u-audio.c Projekt: cmartinbaughman/msm8660_3.4_htc_kernel

void __init shooter_u_audio_init(void)
{
	int i = 0;
	mutex_init(&mic_lock);

	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_icodec_ops(&iops);
	htc_register_q6asm_ops(&qops);
	acoustic_register_ops(&acoustic);

	
	for (i = 0 ; i < ARRAY_SIZE(msm_snddev_gpio); i++)
		gpio_tlmm_config(msm_snddev_gpio[i], GPIO_CFG_DISABLE);

	shooter_u_audio_gpios_init();
}

Beispiel #19

Datei: board-k2_cl-audio.c Projekt: bgcngm/802Xtreem

static int __init k2cl_audio_init(void)
{
	int ret = 0;
	pr_info("%s", __func__);

	/* SPK AMP */
	gpio_tlmm_config(GPIO_CFG(MSM_AUD_SPK_EN, 0, GPIO_CFG_OUTPUT,
		 GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_set_value(MSM_AUD_SPK_EN, 0);

	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	htc_register_compr_q6_ops(&cops);
	acoustic_register_ops(&acoustic);

	return ret;
}

Beispiel #20

Datei: board-holiday-audio.c Projekt: ericdjobs/android_kernel_htc_msm8660

void __init holiday_audio_init(void)
{
	int i = 0;
	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);
	pr_aud_info("%s: 0x%x\n", __func__, skuid);
	switch (skuid) {
	case SKU_ATT1:
	case SKU_ATT2:
	case SKU_ATT3:
		support_audience = 1;
		break;
	default:
		support_audience = 0;
		break;
	}

#ifdef CONFIG_MSM8X60_AUDIO
	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_ecodec_ops(&eops);
	htc_8x60_register_icodec_ops(&iops);
	acoustic_register_ops(&acoustic);
	htc_8x60_register_aic3254_ops(&aops);
	htc_8x60_register_q6asm_ops(&qops);

#ifdef CONFIG_VP_A1026
	a1026_register_ctl_ops(&a1026ops);
#endif

	if (!support_audience)
		/*fix voice sample rate as 8KHz for 3254 dual mic.*/
		msm_set_voc_freq(8000, 8000);

	aic3254_register_ctl_ops(&cops);
#endif

	/* PMIC GPIO Init (See board-holiday.c) */
	/* Reset AIC3254 */
	holiday_reset_3254();
	for (i = 0; i < sizeof(msm_snddev_gpio); i++)
		gpio_tlmm_config(msm_snddev_gpio[i], GPIO_CFG_DISABLE);

	/* Configure A1026 GPIOs */
	audience_gpio_init();
}

Beispiel #21

Datei: board-villec2-audio.c Projekt: bilalliberty/depricated-kernel-villec2--3.4-

void __init villec2_audio_init(void)
{
	int i = 0;
	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);

	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_ecodec_ops(&eops);
	htc_8x60_register_icodec_ops(&iops);
	htc_8x60_register_dev_ctrl_ops(&dops);
	htc_register_q6asm_ops(&qops);
	acoustic_register_ops(&acoustic);

	/* PMIC GPIO Init (See board-villec2.c) */
	for (i = 0 ; i < ARRAY_SIZE(msm_snddev_gpio); i++)
		gpio_tlmm_config(msm_snddev_gpio[i], GPIO_CFG_DISABLE);
}

Beispiel #22

Datei: board-speedy-audio.c Projekt: Scaryghoul/7x30-Sense-kernel

void __init speedy_audio_init(void)
{
	struct pm8058_gpio audio_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull           = PM_GPIO_PULL_NO,
		.vin_sel        = 6,	/* LDO5 2.85 V */
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function       = PM_GPIO_FUNC_NORMAL,
	};

	struct pm8058_gpio tpa2051_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull           = PM_GPIO_PULL_NO,
		.vin_sel        = 6,      /* S3 1.8 V */
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function       = PM_GPIO_FUNC_NORMAL,
	};

	mutex_init(&bt_sco_lock);
	mutex_init(&pm_lock);
	mutex_init(&vreg_lock);
#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
#endif
	pm8058_gpio_config(SPEEDY_AUD_HANDSET_ENO, &audio_pwr);
	pm8058_gpio_config(SPEEDY_AUD_SPK_ENO, &tpa2051_pwr);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(SPEEDY_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(SPEEDY_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(SPEEDY_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #23

Datei: board-spade-audio.c Projekt: BuzzBumbleBee/linux-htc-acevivo

void __init spade_audio_init(void)
{
	struct pm8058_gpio audio_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull           = PM_GPIO_PULL_NO,
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function       = PM_GPIO_FUNC_NORMAL,
		.vin_sel        = 6,
	};

	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);

#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
#endif
	aic3254_register_ctl_ops(&cops);

	/* Init PMIC GPIO */
	pm8058_gpio_config(SPADE_AUD_EP_EN, &audio_pwr);
	pm8058_gpio_config(SPADE_AUD_SPK_ENO, &audio_pwr);
	pm8058_gpio_config(SPADE_AUD_HP_EN, &audio_pwr);

	/* Rest AIC3254 */
	gpio_set_value(SPADE_AUD_CODEC_RST, 0);
	mdelay(1);
	gpio_set_value(SPADE_AUD_CODEC_RST, 1);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(SPADE_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(SPADE_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(SPADE_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #24

Datei: board-mecha-audio.c Projekt: MaceksMod/mecha-ics-mr-3.0.16

void __init mecha_audio_init(void)
{

	mutex_init(&bt_sco_lock);

#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
#endif
	aic3254_register_ctl_ops(&cops);

#if 0
	pm8058_gpio_config(MECHA_AUD_SPK_SD, &tpa2051_pwr);

	if (system_rev == 0)
		pm8058_gpio_config(MECHA_GPIO_AUD_AMP_EN_XA, &tpa2051_pwr);
	else {
		gpio_request(MECHA_GPIO_AUD_AMP_EN, "aud_amp_en");
		gpio_direction_output(MECHA_GPIO_AUD_AMP_EN, 1);
		gpio_set_value(MECHA_GPIO_AUD_AMP_EN, 0);
	}
  #endif
	gpio_request(MECHA_AUD_MICPATH_SEL, "aud_mic_sel");
	gpio_direction_output(MECHA_AUD_MICPATH_SEL, 1);
	gpio_set_value(MECHA_AUD_MICPATH_SEL, 0);

	gpio_set_value(MECHA_AUD_CODEC_RST, 0);
	mdelay(1);
	gpio_set_value(MECHA_AUD_CODEC_RST, 1);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(MECHA_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(MECHA_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(MECHA_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #25

Datei: board-runnymede-audio.c Projekt: DutchDanny/runnymede-2.6.35.13

void __init runnymede_audio_init(void)
{

	struct pm8058_gpio tpa2051_pwr = {
		.direction      = PM_GPIO_DIR_OUT,
		.output_buffer  = PM_GPIO_OUT_BUF_CMOS,
		.output_value   = 0,
		.pull           = PM_GPIO_PULL_NO,
		.vin_sel        = 6,      /* S3 1.8 V */
		.out_strength   = PM_GPIO_STRENGTH_HIGH,
		.function       = PM_GPIO_FUNC_NORMAL,
	};

	mutex_init(&bt_sco_lock);
	mutex_init(&audio_2v85_usage_lock);
	audio_2v85_usage_counter = 0;
#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
#endif
	aic3254_register_ctl_ops(&cops);

	pm8058_gpio_config(runnymede_AUD_SPK_SD, &tpa2051_pwr);
	pm8058_gpio_config(runnymede_AUD_AMP_EN, &tpa2051_pwr);
	gpio_request(runnymede_AUD_MICPATH_SEL, "aud_mic_sel");
	gpio_direction_output(runnymede_AUD_MICPATH_SEL, 1);
	gpio_set_value(runnymede_AUD_MICPATH_SEL, 0);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(runnymede_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(runnymede_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(runnymede_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);
}

Beispiel #26

Datei: board-pyramid-audio.c Projekt: zarboz/OpenSense_kernel

void __init pyramid_audio_init(void)
{
	mutex_init(&bt_sco_lock);
	mutex_init(&mic_lock);

#ifdef CONFIG_MSM8X60_AUDIO
	pr_aud_info("%s\n", __func__);
	htc_8x60_register_analog_ops(&ops);
	htc_8x60_register_icodec_ops(&iops);
	htc_8x60_register_ecodec_ops(&eops);
	acoustic_register_ops(&acoustic);
	htc_8x60_register_aic3254_ops(&aops);
	htc_8x60_register_q6asm_ops(&qops);
	msm_set_voc_freq(8000, 8000);
#endif

	aic3254_register_ctl_ops(&cops);

	/* PMIC GPIO Init (See board-pyramid.c) */

	/* Reset AIC3254 */
	pyramid_reset_3254();
}

Beispiel #27

Datei: board-zara_cl-audio.c Projekt: xXminiWHOOPERxX/xXminiWHOOPERxX-Kernel-ZaraCL-

static int __init zara_cl_audio_init(void)
{
	int ret = 0;
	pr_info("%s", __func__);

	
	gpio_request(MSM_AUD_REC_EN, "AUDIO_RCV_AMP");
	gpio_tlmm_config(GPIO_CFG(MSM_AUD_REC_EN, 0, GPIO_CFG_OUTPUT,
		GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_set_value(MSM_AUD_REC_EN, 0);

	
	gpio_request(MSM_AUD_RECEIVER_SEL, "AUD_RECEIVER_SEL");
	gpio_tlmm_config(GPIO_CFG(MSM_AUD_RECEIVER_SEL, 0, GPIO_CFG_OUTPUT,
		GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_set_value(MSM_AUD_RECEIVER_SEL, 0);

	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	htc_register_compr_q6_ops(&cops);
	acoustic_register_ops(&acoustic);

	return ret;
}

Beispiel #28

void __init primou_audio_init(void)
{

	mutex_init(&bt_sco_lock);

#ifdef CONFIG_MSM7KV2_AUDIO
	htc_7x30_register_analog_ops(&ops);
	htc_7x30_register_icodec_ops(&iops);
	htc_7x30_register_ecodec_ops(&eops);
	htc_7x30_register_voice_ops(&vops);
	acoustic_register_ops(&acoustic);
	acdb_register_ops(&acdb);
#endif

	gpio_request(PM8058_GPIO_PM_TO_SYS(PRIMOU_AUD_SPK_SD), "AUD_SPK_EN");
	gpio_direction_output(PM8058_GPIO_PM_TO_SYS(PRIMOU_AUD_SPK_SD), 1);
	gpio_set_value(PM8058_GPIO_PM_TO_SYS(PRIMOU_AUD_SPK_SD), 0);
	gpio_request(PM8058_GPIO_PM_TO_SYS(PRIMOU_AUD_CODEC_EN), "aud_2v85_en");
	gpio_direction_output(PM8058_GPIO_PM_TO_SYS(PRIMOU_AUD_CODEC_EN), 1);
	gpio_set_value(PRIMOU_AUD_CODEC_EN, 0);

	primou_hs_n1v8_enable(0);

	mutex_lock(&bt_sco_lock);
	config_gpio_table(aux_pcm_gpio_off, ARRAY_SIZE(aux_pcm_gpio_off));
	gpio_set_value(PRIMOU_GPIO_BT_PCM_OUT, 0);
	gpio_set_value(PRIMOU_GPIO_BT_PCM_SYNC, 0);
	gpio_set_value(PRIMOU_GPIO_BT_PCM_CLK, 0);
	mutex_unlock(&bt_sco_lock);

	audio_wq = create_workqueue("AUDIO_EFFECT_VOLUME");
	if (audio_wq == NULL) {
		pr_aud_info("%s: cannot create workqueue\n", __func__);
	}

}

Beispiel #29

Datei: board-fighter-audio.c Projekt: KIMMINWOO/FusionUlt-AOSP-MR1

static int __init fighter_audio_init(void)
{
	int ret = 0, rc = 0;

	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION
	int retval = 0;
	#endif

	struct pm_gpio param = {
		.direction	= PM_GPIO_DIR_OUT,
		.output_buffer	= PM_GPIO_OUT_BUF_CMOS,
		.output_value	= 0,
		.pull		= PM_GPIO_PULL_NO,
		.vin_sel	= PM_GPIO_VIN_S4,
		.out_strength	= PM_GPIO_STRENGTH_MED,
		.function	= PM_GPIO_FUNC_NORMAL,
	};

	pr_debug("%s", __func__);

	msm8960_snd_device = platform_device_alloc("soc-audio", 0);
	if (!msm8960_snd_device) {
		pr_aud_err("%s, Platform device allocation failed\n", __func__);
		return -ENOMEM;
	}

	platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960);
	ret = platform_device_add(msm8960_snd_device);
	if (ret) {
		pr_aud_err("%s, Platform device add failed\n", __func__);
		platform_device_put(msm8960_snd_device);
		return ret;
	}

	#ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION
	/* Create two audio status file nodes, audio_speaker_t and
	 * audio_headset_t under /sys/audio_stats/					*/
	if (audio_stat_kobj == NULL)
	{
		audio_stat_kobj = kobject_create_and_add("audio_stats", NULL);
		retval = sysfs_create_file(audio_stat_kobj, attrs[0]);
		if (!retval)
		{
			pr_err("Speaker file node creation failed under kobject\n");
		}
		retval = sysfs_create_file(audio_stat_kobj, attrs[1]);
		if (!retval)
		{
			pr_err("Headset file node creation failed under kobject\n");
		}
	}
	#endif


	rc = gpio_request(PM8921_GPIO_PM_TO_SYS(FIGHTER_AUD_AMP_EN),
					"tpa2051_en");

	rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(FIGHTER_AUD_AMP_EN),
			&param);

	if (rc < 0)
		pr_aud_err("failed to configure tpa2051_en gpio\n");

	gpio_tlmm_config(msm_2051_gpio[0], GPIO_CFG_ENABLE);
	gpio_tlmm_config(msm_2051_gpio[1], GPIO_CFG_ENABLE);

	htc_8960_register_q6asm_ops(&qops);
	htc_8960_register_pcm_routing_ops(&rops);
	acoustic_register_ops(&acoustic);
	return ret;

}
late_initcall(fighter_audio_init);

static void __exit fighter_audio_exit(void)
{
	pr_debug("%s", __func__);
	platform_device_unregister(msm8960_snd_device);
}

Beispiel #30

Datei: board-jet-audio.c Projekt: MassStash/sensejb

static int __init jet_audio_init(void)
{
	int ret = 0, rc = 0;
	struct pm_gpio param = {
		.direction	= PM_GPIO_DIR_OUT,
		.output_buffer	= PM_GPIO_OUT_BUF_CMOS,
		.output_value	= 0,
		.pull		= PM_GPIO_PULL_NO,
		.vin_sel	= PM_GPIO_VIN_L17,
		.out_strength	= PM_GPIO_STRENGTH_MED,
		.function	= PM_GPIO_FUNC_NORMAL,
	};

	if (!cpu_is_msm8960()) {
		pr_info("%s: Not the right machine type\n", __func__);
		return -ENODEV ;
	}

	pr_info("%s", __func__);

	msm8960_snd_device = platform_device_alloc("soc-audio", 0);
	if (!msm8960_snd_device) {
		pr_err("Platform device allocation failed\n");
		return -ENOMEM;
	}

	memcpy(msm8960_dai, msm8960_dai_common, sizeof(msm8960_dai_common));
	memcpy(msm8960_dai + ARRAY_SIZE(msm8960_dai_common),
		msm8960_dai_delta_tabla2x, sizeof(msm8960_dai_delta_tabla2x));

	platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960);
	ret = platform_device_add(msm8960_snd_device);
	if (ret) {
		platform_device_put(msm8960_snd_device);
		return ret;
	}

	msm8960_snd_tabla1x_device = platform_device_alloc("soc-audio", 1);
	if (!msm8960_snd_tabla1x_device) {
		pr_err("Platform device allocation failed\n");
		return -ENOMEM;
	}

	memcpy(msm8960_tabla1x_dai, msm8960_dai_common,
		sizeof(msm8960_dai_common));
	memcpy(msm8960_tabla1x_dai + ARRAY_SIZE(msm8960_dai_common),
		msm8960_dai_delta_tabla1x, sizeof(msm8960_dai_delta_tabla1x));

	platform_set_drvdata(msm8960_snd_tabla1x_device,
		&snd_soc_tabla1x_card_msm8960);
	ret = platform_device_add(msm8960_snd_tabla1x_device);
	if (ret) {
		platform_device_put(msm8960_snd_tabla1x_device);
		return ret;
	}

	rc = gpio_request(PM8921_GPIO_PM_TO_SYS(JET_PMGPIO_AUD_AMP_EN),
					"jet_en");
	rc = pm8xxx_gpio_config(PM8921_GPIO_PM_TO_SYS(JET_PMGPIO_AUD_AMP_EN),
			&param);
	if (rc < 0)
		pr_aud_err("failed to configure tpa2051_en gpio\n");

	mutex_init(&cdc_mclk_mutex);
	htc_register_q6asm_ops(&qops);
	htc_register_pcm_routing_ops(&rops);
	acoustic_register_ops(&acoustic);
	return ret;

}
late_initcall(jet_audio_init);

static void __exit jet_audio_exit(void)
{

	if (!cpu_is_msm8960()) {
		pr_info("%s: Not the right machine type\n", __func__);
		return ;
	}
	pr_info("%s", __func__);

	platform_device_unregister(msm8960_snd_device);
	platform_device_unregister(msm8960_snd_tabla1x_device);
	gpio_free(PAMP_GPIO);
	mutex_destroy(&cdc_mclk_mutex);
}
module_exit(jet_audio_exit);

MODULE_DESCRIPTION("ALSA Platform Jet");
MODULE_LICENSE("GPL v2");