static int pcm3008_soc_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; struct pcm3008_setup_data *setup = socdev->codec_data; int ret = 0; printk(KERN_INFO "PCM3008 SoC Audio Codec %s\n", PCM3008_VERSION); socdev->card->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL); if (!socdev->card->codec) return -ENOMEM; codec = socdev->card->codec; mutex_init(&codec->mutex); codec->name = "PCM3008"; codec->owner = THIS_MODULE; codec->dai = &pcm3008_dai; codec->num_dai = 1; codec->write = NULL; codec->read = NULL; INIT_LIST_HEAD(&codec->dapm_widgets); INIT_LIST_HEAD(&codec->dapm_paths); /* Register PCMs. */ ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { printk(KERN_ERR "pcm3008: failed to create pcms\n"); goto pcm_err; } /* Register Card. */ ret = snd_soc_init_card(socdev); if (ret < 0) { printk(KERN_ERR "pcm3008: failed to register card\n"); goto card_err; } /* DEM1 DEM0 DE-EMPHASIS_MODE * Low Low De-emphasis 44.1 kHz ON * Low High De-emphasis OFF * High Low De-emphasis 48 kHz ON * High High De-emphasis 32 kHz ON */ /* Configure DEM0 GPIO (turning OFF DAC De-emphasis). */ ret = gpio_request(setup->dem0_pin, "codec_dem0"); if (ret == 0) ret = gpio_direction_output(setup->dem0_pin, 1); if (ret != 0) goto gpio_err; /* Configure DEM1 GPIO (turning OFF DAC De-emphasis). */ ret = gpio_request(setup->dem1_pin, "codec_dem1"); if (ret == 0) ret = gpio_direction_output(setup->dem1_pin, 0); if (ret != 0) goto gpio_err; /* Configure PDAD GPIO. */ ret = gpio_request(setup->pdad_pin, "codec_pdad"); if (ret == 0) ret = gpio_direction_output(setup->pdad_pin, 1); if (ret != 0) goto gpio_err; /* Configure PDDA GPIO. */ ret = gpio_request(setup->pdda_pin, "codec_pdda"); if (ret == 0) ret = gpio_direction_output(setup->pdda_pin, 1); if (ret != 0) goto gpio_err; return ret; gpio_err: pcm3008_gpio_free(setup); card_err: snd_soc_free_pcms(socdev); pcm_err: kfree(socdev->card->codec); return ret; }
static int ak4104_remove(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); snd_soc_free_pcms(socdev); return 0; };
static int wm8350_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; struct wm8350 *wm8350; struct wm8350_data *priv; int ret; struct wm8350_output *out1; struct wm8350_output *out2; BUG_ON(!wm8350_codec); socdev->codec = wm8350_codec; codec = socdev->codec; wm8350 = codec->control_data; priv = codec->private_data; /* Enable the codec */ wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA); /* Enable robust clocking mode in ADC */ wm8350_codec_write(codec, WM8350_SECURITY, 0xa7); wm8350_codec_write(codec, 0xde, 0x13); wm8350_codec_write(codec, WM8350_SECURITY, 0); /* read OUT1 & OUT2 volumes */ out1 = &priv->out1; out2 = &priv->out2; out1->left_vol = (wm8350_reg_read(wm8350, WM8350_LOUT1_VOLUME) & WM8350_OUT1L_VOL_MASK) >> WM8350_OUT1L_VOL_SHIFT; out1->right_vol = (wm8350_reg_read(wm8350, WM8350_ROUT1_VOLUME) & WM8350_OUT1R_VOL_MASK) >> WM8350_OUT1R_VOL_SHIFT; out2->left_vol = (wm8350_reg_read(wm8350, WM8350_LOUT2_VOLUME) & WM8350_OUT2L_VOL_MASK) >> WM8350_OUT1L_VOL_SHIFT; out2->right_vol = (wm8350_reg_read(wm8350, WM8350_ROUT2_VOLUME) & WM8350_OUT2R_VOL_MASK) >> WM8350_OUT1R_VOL_SHIFT; wm8350_reg_write(wm8350, WM8350_LOUT1_VOLUME, 0); wm8350_reg_write(wm8350, WM8350_ROUT1_VOLUME, 0); wm8350_reg_write(wm8350, WM8350_LOUT2_VOLUME, 0); wm8350_reg_write(wm8350, WM8350_ROUT2_VOLUME, 0); /* Latch VU bits & mute */ wm8350_set_bits(wm8350, WM8350_LOUT1_VOLUME, WM8350_OUT1_VU | WM8350_OUT1L_MUTE); wm8350_set_bits(wm8350, WM8350_LOUT2_VOLUME, WM8350_OUT2_VU | WM8350_OUT2L_MUTE); wm8350_set_bits(wm8350, WM8350_ROUT1_VOLUME, WM8350_OUT1_VU | WM8350_OUT1R_MUTE); wm8350_set_bits(wm8350, WM8350_ROUT2_VOLUME, WM8350_OUT2_VU | WM8350_OUT2R_MUTE); wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L); wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R); wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L, wm8350_hp_jack_handler, priv); wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R, wm8350_hp_jack_handler, priv); ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { dev_err(&pdev->dev, "failed to create pcms\n"); return ret; } snd_soc_add_controls(codec, wm8350_snd_controls, ARRAY_SIZE(wm8350_snd_controls)); wm8350_add_widgets(codec); wm8350_set_bias_level(codec, SND_SOC_BIAS_STANDBY); ret = snd_soc_init_card(socdev); if (ret < 0) { dev_err(&pdev->dev, "failed to register card\n"); goto card_err; } return 0; card_err: snd_soc_free_pcms(socdev); snd_soc_dapm_free(socdev); return ret; }
static int uda134x_soc_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; struct uda134x_priv *uda134x; void *codec_setup_data = socdev->codec_data; int ret = -ENOMEM; struct uda134x_platform_data *pd; printk(KERN_INFO "UDA134X SoC Audio Codec\n"); if (!codec_setup_data) { printk(KERN_ERR "UDA134X SoC codec: " "missing L3 bitbang function\n"); return -ENODEV; } pd = codec_setup_data; switch (pd->model) { case UDA134X_UDA1340: case UDA134X_UDA1341: case UDA134X_UDA1344: break; default: printk(KERN_ERR "UDA134X SoC codec: " "unsupported model %d\n", pd->model); return -EINVAL; } socdev->card->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL); if (socdev->card->codec == NULL) return ret; codec = socdev->card->codec; uda134x = kzalloc(sizeof(struct uda134x_priv), GFP_KERNEL); if (uda134x == NULL) goto priv_err; codec->private_data = uda134x; codec->reg_cache = kmemdup(uda134x_reg, sizeof(uda134x_reg), GFP_KERNEL); if (codec->reg_cache == NULL) goto reg_err; mutex_init(&codec->mutex); codec->reg_cache_size = sizeof(uda134x_reg); codec->reg_cache_step = 1; codec->name = "UDA134X"; codec->owner = THIS_MODULE; codec->dai = &uda134x_dai; codec->num_dai = 1; codec->read = uda134x_read_reg_cache; codec->write = uda134x_write; #ifdef POWER_OFF_ON_STANDBY codec->set_bias_level = uda134x_set_bias_level; #endif INIT_LIST_HEAD(&codec->dapm_widgets); INIT_LIST_HEAD(&codec->dapm_paths); codec->control_data = codec_setup_data; if (pd->power) pd->power(1); uda134x_reset(codec); ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { printk(KERN_ERR "UDA134X: failed to register pcms\n"); goto pcm_err; } switch (pd->model) { case UDA134X_UDA1340: case UDA134X_UDA1344: ret = snd_soc_add_controls(codec, uda1340_snd_controls, ARRAY_SIZE(uda1340_snd_controls)); break; case UDA134X_UDA1341: ret = snd_soc_add_controls(codec, uda1341_snd_controls, ARRAY_SIZE(uda1341_snd_controls)); break; default: printk(KERN_ERR "%s unkown codec type: %d", __func__, pd->model); return -EINVAL; } if (ret < 0) { printk(KERN_ERR "UDA134X: failed to register controls\n"); goto pcm_err; } ret = snd_soc_init_card(socdev); if (ret < 0) { printk(KERN_ERR "UDA134X: failed to register card\n"); goto card_err; } return 0; card_err: snd_soc_free_pcms(socdev); snd_soc_dapm_free(socdev); pcm_err: kfree(codec->reg_cache); reg_err: kfree(codec->private_data); priv_err: kfree(codec); return ret; }
/* * ASoC probe function * * This function is called when the machine driver calls * platform_device_add(). */ static int cs4270_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; int ret = 0; printk(KERN_INFO "CS4270 ALSA SoC Codec\n"); /* Allocate enough space for the snd_soc_codec structure and our private data together. */ codec = kzalloc(ALIGN(sizeof(struct snd_soc_codec), 4) + sizeof(struct cs4270_private), GFP_KERNEL); if (!codec) { printk(KERN_ERR "cs4270: Could not allocate codec structure\n"); return -ENOMEM; } mutex_init(&codec->mutex); INIT_LIST_HEAD(&codec->dapm_widgets); INIT_LIST_HEAD(&codec->dapm_paths); codec->name = "CS4270"; codec->owner = THIS_MODULE; codec->dai = &cs4270_dai; codec->num_dai = 1; codec->private_data = (void *) codec + ALIGN(sizeof(struct snd_soc_codec), 4); socdev->codec = codec; /* Register PCMs */ ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { printk(KERN_ERR "cs4270: failed to create PCMs\n"); return ret; } #ifdef USE_I2C cs4270_socdev = socdev; ret = i2c_add_driver(&cs4270_i2c_driver); if (ret) { printk(KERN_ERR "cs4270: failed to attach driver"); snd_soc_free_pcms(socdev); return ret; } /* Did we find a CS4270 on the I2C bus? */ if (codec->control_data) { /* Initialize codec ops */ cs4270_dai.ops.hw_params = cs4270_hw_params; cs4270_dai.dai_ops.set_sysclk = cs4270_set_dai_sysclk; cs4270_dai.dai_ops.set_fmt = cs4270_set_dai_fmt; #ifdef CONFIG_SND_SOC_CS4270_HWMUTE cs4270_dai.dai_ops.digital_mute = cs4270_mute; #endif } else printk(KERN_INFO "cs4270: no I2C device found, " "using stand-alone mode\n"); #else printk(KERN_INFO "cs4270: I2C disabled, using stand-alone mode\n"); #endif ret = snd_soc_register_card(socdev); if (ret < 0) { printk(KERN_ERR "cs4270: failed to register card\n"); snd_soc_free_pcms(socdev); return ret; } return ret; }
static int ad1980_soc_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; int ret = 0; u16 vendor_id2; u16 ext_status; printk(KERN_INFO "AD1980 SoC Audio Codec\n"); socdev->card->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL); if (socdev->card->codec == NULL) return -ENOMEM; codec = socdev->card->codec; mutex_init(&codec->mutex); codec->reg_cache = kzalloc(sizeof(u16) * ARRAY_SIZE(ad1980_reg), GFP_KERNEL); if (codec->reg_cache == NULL) { ret = -ENOMEM; goto cache_err; } memcpy(codec->reg_cache, ad1980_reg, sizeof(u16) * \ ARRAY_SIZE(ad1980_reg)); codec->reg_cache_size = sizeof(u16) * ARRAY_SIZE(ad1980_reg); codec->reg_cache_step = 2; codec->name = "AD1980"; codec->owner = THIS_MODULE; codec->dai = &ad1980_dai; codec->num_dai = 1; codec->write = ac97_write; codec->read = ac97_read; INIT_LIST_HEAD(&codec->dapm_widgets); INIT_LIST_HEAD(&codec->dapm_paths); ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0); if (ret < 0) { printk(KERN_ERR "ad1980: failed to register AC97 codec\n"); goto codec_err; } /* register pcms */ ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) goto pcm_err; ret = ad1980_reset(codec, 0); if (ret < 0) { printk(KERN_ERR "Failed to reset AD1980: AC97 link error\n"); goto reset_err; } /* Read out vendor ID to make sure it is ad1980 */ if (ac97_read(codec, AC97_VENDOR_ID1) != 0x4144) goto reset_err; vendor_id2 = ac97_read(codec, AC97_VENDOR_ID2); if (vendor_id2 != 0x5370) { if (vendor_id2 != 0x5374) goto reset_err; else printk(KERN_WARNING "ad1980: " "Found AD1981 - only 2/2 IN/OUT Channels " "supported\n"); } /* unmute captures and playbacks volume */ ac97_write(codec, AC97_MASTER, 0x0000); ac97_write(codec, AC97_PCM, 0x0000); ac97_write(codec, AC97_REC_GAIN, 0x0000); ac97_write(codec, AC97_CENTER_LFE_MASTER, 0x0000); ac97_write(codec, AC97_SURROUND_MASTER, 0x0000); /*power on LFE/CENTER/Surround DACs*/ ext_status = ac97_read(codec, AC97_EXTENDED_STATUS); ac97_write(codec, AC97_EXTENDED_STATUS, ext_status&~0x3800); snd_soc_add_controls(codec, ad1980_snd_ac97_controls, ARRAY_SIZE(ad1980_snd_ac97_controls)); return 0; reset_err: snd_soc_free_pcms(socdev); pcm_err: snd_soc_free_ac97_codec(codec); codec_err: kfree(codec->reg_cache); cache_err: kfree(socdev->card->codec); socdev->card->codec = NULL; return ret; }