static int msm_dai_q6_hdmi_dai_probe(struct snd_soc_dai *dai) { struct msm_dai_q6_hdmi_dai_data *dai_data; const struct snd_kcontrol_new *kcontrol; int rc = 0; struct snd_soc_dapm_route intercon; if (!dai) { pr_err("%s: dai not found\n", __func__); return -EINVAL; } dai_data = kzalloc(sizeof(struct msm_dai_q6_hdmi_dai_data), GFP_KERNEL); if (!dai_data) { dev_err(dai->dev, "DAI-%d: fail to allocate dai data\n", dai->id); rc = -ENOMEM; } else dev_set_drvdata(dai->dev, dai_data); kcontrol = &hdmi_config_controls[0]; rc = snd_ctl_add(dai->card->snd_card, snd_ctl_new1(kcontrol, dai_data)); kcontrol = &hdmi_config_controls[1]; rc = snd_ctl_add(dai->card->snd_card, snd_ctl_new1(kcontrol, dai_data)); memset(&intercon, 0 , sizeof(intercon)); if (!rc && dai && dai->driver) { if (dai->driver->playback.stream_name && dai->driver->playback.aif_name) { dev_dbg(dai->dev, "%s add route for widget %s", __func__, dai->driver->playback.stream_name); intercon.source = dai->driver->playback.aif_name; intercon.sink = dai->driver->playback.stream_name; dev_dbg(dai->dev, "%s src %s sink %s\n", __func__, intercon.source, intercon.sink); snd_soc_dapm_add_routes(&dai->dapm, &intercon, 1); } if (dai->driver->capture.stream_name && dai->driver->capture.aif_name) { dev_dbg(dai->dev, "%s add route for widget %s", __func__, dai->driver->capture.stream_name); intercon.sink = dai->driver->capture.aif_name; intercon.source = dai->driver->capture.stream_name; dev_dbg(dai->dev, "%s src %s sink %s\n", __func__, intercon.source, intercon.sink); snd_soc_dapm_add_routes(&dai->dapm, &intercon, 1); } } return rc; }
int snd_cs4236_mixer(struct snd_wss *chip) { struct snd_card *card; unsigned int idx, count; int err; struct snd_kcontrol_new *kcontrol; if (snd_BUG_ON(!chip || !chip->card)) return -EINVAL; card = chip->card; strcpy(card->mixername, snd_wss_chip_id(chip)); if (chip->hardware == WSS_HW_CS4235 || chip->hardware == WSS_HW_CS4239) { for (idx = 0; idx < ARRAY_SIZE(snd_cs4235_controls); idx++) { if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cs4235_controls[idx], chip))) < 0) return err; } } else { for (idx = 0; idx < ARRAY_SIZE(snd_cs4236_controls); idx++) { if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cs4236_controls[idx], chip))) < 0) return err; } } switch (chip->hardware) { case WSS_HW_CS4235: case WSS_HW_CS4239: count = ARRAY_SIZE(snd_cs4236_3d_controls_cs4235); kcontrol = snd_cs4236_3d_controls_cs4235; break; case WSS_HW_CS4237B: count = ARRAY_SIZE(snd_cs4236_3d_controls_cs4237); kcontrol = snd_cs4236_3d_controls_cs4237; break; case WSS_HW_CS4238B: count = ARRAY_SIZE(snd_cs4236_3d_controls_cs4238); kcontrol = snd_cs4236_3d_controls_cs4238; break; default: count = 0; kcontrol = NULL; } for (idx = 0; idx < count; idx++, kcontrol++) { if ((err = snd_ctl_add(card, snd_ctl_new1(kcontrol, chip))) < 0) return err; } if (chip->hardware == WSS_HW_CS4237B || chip->hardware == WSS_HW_CS4238B) { for (idx = 0; idx < ARRAY_SIZE(snd_cs4236_iec958_controls); idx++) { if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cs4236_iec958_controls[idx], chip))) < 0) return err; } } return 0; }
int snd_ak4641_add_mixer_controls(struct snd_ak4641 *ak, struct snd_card *card) { snd_ak4641_lock(ak); snd_ctl_add(card, snd_ctl_new1(&snd_ak4641_actl_playback_volume, ak)); snd_ctl_add(card, snd_ctl_new1(&snd_ak4641_actl_playback_switch, ak)); snd_ctl_add(card, snd_ctl_new1(&snd_ak4641_actl_mic_gain, ak)); snd_ctl_add(card, snd_ctl_new1(&snd_ak4641_actl_mic_boost, ak)); snd_ctl_add(card, snd_ctl_new1(&snd_ak4641_actl_mono_out, ak)); snd_ak4641_unlock(ak); return 0; }
static int xonar_d1_mixer_init(struct oxygen *chip) { int err; err = snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip)); if (err < 0) return err; return 0; }
static int codec_soc_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec; int ret = 0; 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 = "tegra-generic-codec"; codec->owner = THIS_MODULE; codec->dai = &tegra_generic_codec_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 "codec: failed to create pcms\n"); goto pcm_err; } /* Register Card. */ ret = snd_soc_init_card(socdev); if (ret < 0) { printk(KERN_ERR "codec: failed to register card\n"); goto card_err; } /* Add volume control */ ret = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_codec_ctrl_volume, codec)); if (ret < 0) { printk(KERN_ERR "codec: failed to add control\n"); goto card_err; } /* Add route control */ return snd_ctl_add(codec->card, snd_ctl_new1(&tegra_codec_ctrl_route, codec)); card_err: snd_soc_free_pcms(socdev); pcm_err: kfree(socdev->card->codec); return ret; }
static int add_aicamixer_controls(struct snd_card_aica *dreamcastcard) { int err; err = snd_ctl_add (dreamcastcard->card, snd_ctl_new1(&snd_aica_pcmvolume_control, dreamcastcard)); if (unlikely(err < 0)) return err; err = snd_ctl_add (dreamcastcard->card, snd_ctl_new1(&snd_aica_pcmswitch_control, dreamcastcard)); if (unlikely(err < 0)) return err; return 0; }
/* * Pavo for a jzcodec as connected on jz4740 Device */ static int pavo_jzcodec_init(struct snd_soc_codec *codec) { int i, err; snd_soc_dapm_set_endpoint(codec, "LLINEIN", 0); snd_soc_dapm_set_endpoint(codec, "RLINEIN", 0); /* Add pavo specific controls */ for (i = 0; i < ARRAY_SIZE(jzcodec_pavo_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&jzcodec_pavo_controls[i],codec, NULL)); if (err < 0) return err; } /* Add pavo specific widgets */ for(i = 0; i < ARRAY_SIZE(jzcodec_dapm_widgets); i++) { snd_soc_dapm_new_control(codec, &jzcodec_dapm_widgets[i]); } /* Set up pavo specific audio path audio_map */ for(i = 0; audio_map[i][0] != NULL; i++) { snd_soc_dapm_connect_input(codec, audio_map[i][0], audio_map[i][1], audio_map[i][2]); } snd_soc_dapm_sync_endpoints(codec); return 0; }
int snd_ak4114_build(ak4114_t *ak4114, snd_pcm_substream_t *ply_substream, snd_pcm_substream_t *cap_substream) { snd_kcontrol_t *kctl; unsigned int idx; int err; snd_assert(cap_substream, return -EINVAL); ak4114->playback_substream = ply_substream; ak4114->capture_substream = cap_substream; for (idx = 0; idx < AK4114_CONTROLS; idx++) { kctl = snd_ctl_new1(&snd_ak4114_iec958_controls[idx], ak4114); if (kctl == NULL) return -ENOMEM; if (!strstr(kctl->id.name, "Playback")) { if (ply_substream == NULL) { snd_ctl_free_one(kctl); ak4114->kctls[idx] = NULL; continue; } kctl->id.device = ply_substream->pcm->device; kctl->id.subdevice = ply_substream->number; } else { kctl->id.device = cap_substream->pcm->device; kctl->id.subdevice = cap_substream->number; } err = snd_ctl_add(ak4114->card, kctl); if (err < 0) return err; ak4114->kctls[idx] = kctl; } return 0; }
/* Logic for a aic3x as connected on the s6105 ip camera ref design */ static int s6105_aic3x_init(struct snd_soc_codec *codec) { /* Add s6105 specific widgets */ snd_soc_dapm_new_controls(codec, aic3x_dapm_widgets, ARRAY_SIZE(aic3x_dapm_widgets)); /* Set up s6105 specific audio path audio_map */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); /* not present */ snd_soc_dapm_nc_pin(codec, "MONO_LOUT"); snd_soc_dapm_nc_pin(codec, "LINE2L"); snd_soc_dapm_nc_pin(codec, "LINE2R"); /* not connected */ snd_soc_dapm_nc_pin(codec, "MIC3L"); /* LINE2L on this chip */ snd_soc_dapm_nc_pin(codec, "MIC3R"); /* LINE2R on this chip */ snd_soc_dapm_nc_pin(codec, "LLOUT"); snd_soc_dapm_nc_pin(codec, "RLOUT"); snd_soc_dapm_nc_pin(codec, "HPRCOM"); /* always connected */ snd_soc_dapm_enable_pin(codec, "Audio In"); /* must correspond to audio_out_mux.private_value initializer */ snd_soc_dapm_disable_pin(codec, "Audio Out Differential"); snd_soc_dapm_sync(codec); snd_soc_dapm_enable_pin(codec, "Audio Out Stereo"); snd_soc_dapm_sync(codec); snd_ctl_add(codec->card, snd_ctl_new1(&audio_out_mux, codec)); return 0; }
/** * snd_intelmad_mixer- to setup mixer settings of the card * * @intelmaddata: pointer to internal context * * This function is called from probe function to set up mixer controls */ static int __devinit snd_intelmad_mixer(struct snd_intelmad *intelmaddata) { struct snd_card *card; unsigned int idx; int ret_val = 0, max_controls = 0; char *mixername = "IntelMAD Controls"; struct snd_kcontrol_new *controls; WARN_ON(!intelmaddata); card = intelmaddata->card; strncpy(card->mixername, mixername, sizeof(card->mixername)-1); /* add all widget controls and expose the same */ if (intelmaddata->cpu_id == CPU_CHIP_PENWELL) { max_controls = MAX_CTRL_MFLD; controls = snd_intelmad_controls_mfld; } else { max_controls = MAX_CTRL_MRST; controls = snd_intelmad_controls_mrst; } for (idx = 0; idx < max_controls; idx++) { ret_val = snd_ctl_add(card, snd_ctl_new1(&controls[idx], intelmaddata)); pr_debug("mixer[idx]=%d added\n", idx); if (ret_val) { pr_err("in adding of control index = %d\n", idx); break; } } return ret_val; }
static int n810_aic33_init(struct snd_soc_codec *codec) { int i, err; /* Not connected */ snd_soc_dapm_disable_pin(codec, "MONO_LOUT"); snd_soc_dapm_disable_pin(codec, "HPLCOM"); snd_soc_dapm_disable_pin(codec, "HPRCOM"); /* Add N810 specific controls */ for (i = 0; i < ARRAY_SIZE(aic33_n810_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&aic33_n810_controls[i], codec, NULL)); if (err < 0) return err; } /* Add N810 specific widgets */ snd_soc_dapm_new_controls(codec, aic33_dapm_widgets, ARRAY_SIZE(aic33_dapm_widgets)); /* Set up N810 specific audio path audio_map */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); snd_soc_dapm_sync(codec); return 0; }
int snd_ak4113_build(struct ak4113 *ak4113, struct snd_pcm_substream *cap_substream) { struct snd_kcontrol *kctl; unsigned int idx; int err; if (snd_BUG_ON(!cap_substream)) return -EINVAL; ak4113->substream = cap_substream; for (idx = 0; idx < AK4113_CONTROLS; idx++) { kctl = snd_ctl_new1(&snd_ak4113_iec958_controls[idx], ak4113); if (kctl == NULL) return -ENOMEM; kctl->id.device = cap_substream->pcm->device; kctl->id.subdevice = cap_substream->number; err = snd_ctl_add(ak4113->card, kctl); if (err < 0) return err; ak4113->kctls[idx] = kctl; } snd_ak4113_proc_init(ak4113); /* trigger workq */ schedule_delayed_work(&ak4113->work, HZ / 10); return 0; }
static int h5000_ak4535_init (struct snd_soc_codec *codec) { int i, err; /* NC codec pins */ snd_soc_dapm_set_endpoint (codec, "MOUT1", 0); snd_soc_dapm_set_endpoint (codec, "LOUT", 0); snd_soc_dapm_set_endpoint (codec, "ROUT", 0); snd_soc_dapm_set_endpoint (codec, "MOUT2", 0); /* FIXME: These pins are marked as INPUTS */ snd_soc_dapm_set_endpoint (codec, "MIN", 0); /* FIXME: and OUTPUTS in ak4535.c . We need to do this in order */ snd_soc_dapm_set_endpoint (codec, "AIN", 0); /* FIXME: to get DAPM working properly, because the pins are connected */ snd_soc_dapm_set_endpoint (codec, "MICOUT", 0); /* FIXME: OUTPUT -> INPUT. */ /* Add h5000 specific controls */ for (i = 0; i < ARRAY_SIZE (ak4535_h5000_controls); i++) { err = snd_ctl_add (codec->card, snd_soc_cnew (&ak4535_h5000_controls[i], codec, NULL)); if (err < 0) return err; }; /* Add h5000 specific widgets */ for (i = 0; i < ARRAY_SIZE (ak4535_dapm_widgets); i++) { snd_soc_dapm_new_control (codec, &ak4535_dapm_widgets [i]); }; /* Set up h5000 specific audio path audio_map */ for (i = 0; audio_map [i][0] != NULL; i++) { snd_soc_dapm_connect_input (codec, audio_map [i][0], audio_map [i][1], audio_map [i][2]); }; snd_soc_dapm_sync_endpoints (codec); return 0; };
/* * Logic for a wm8750 as connected on a Sharp SL-Cxx00 Device */ static int spitz_wm8750_init(struct snd_soc_codec *codec) { int i, err; /* NC codec pins */ snd_soc_dapm_set_endpoint(codec, "RINPUT1", 0); snd_soc_dapm_set_endpoint(codec, "LINPUT2", 0); snd_soc_dapm_set_endpoint(codec, "RINPUT2", 0); snd_soc_dapm_set_endpoint(codec, "LINPUT3", 0); snd_soc_dapm_set_endpoint(codec, "RINPUT3", 0); snd_soc_dapm_set_endpoint(codec, "OUT3", 0); snd_soc_dapm_set_endpoint(codec, "MONO", 0); /* Add spitz specific controls */ for (i = 0; i < ARRAY_SIZE(wm8750_spitz_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&wm8750_spitz_controls[i], codec, NULL)); if (err < 0) return err; } /* Add spitz specific widgets */ for (i = 0; i < ARRAY_SIZE(wm8750_dapm_widgets); i++) snd_soc_dapm_new_control(codec, &wm8750_dapm_widgets[i]); /* Set up spitz specific audio path audio_map */ for (i = 0; audio_map[i][0] != NULL; i++) snd_soc_dapm_connect_input(codec, audio_map[i][0], audio_map[i][1], audio_map[i][2]); snd_soc_dapm_sync_endpoints(codec); return 0; }
/* * This is an example machine initialisation for a wm8580 connected to a * smdk2450. It is missing logic to detect hp/mic insertions and logic * to re-route the audio in such an event. */ static int smdk_wm8580_init(struct snd_soc_codec *codec) { int i, err; /* set endpoints to default mode */ set_scenario_endpoints(codec, SMDK_AUDIO_OFF); /* Add smdk2450 specific widgets */ for (i = 0; i < ARRAY_SIZE(wm8580_dapm_widgets); i++) snd_soc_dapm_new_control(codec, &wm8580_dapm_widgets[i]); /* add smdk2450 specific controls */ for (i = 0; i < ARRAY_SIZE(wm8580_smdk_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&wm8580_smdk_controls[i], codec, NULL)); if (err < 0) return err; } /* set up smdk2450 specific audio path audio_mapnects */ for (i = 0; audio_map[i][0] != NULL; i++) { snd_soc_dapm_connect_input(codec, audio_map[i][0], audio_map[i][1], audio_map[i][2]); } /* always connected */ snd_soc_dapm_set_endpoint(codec, "Mic1 Jack", 1); snd_soc_dapm_set_endpoint(codec, "Headphone Jack", 1); snd_soc_dapm_set_endpoint(codec, "Line In Jack", 1); snd_soc_dapm_sync_endpoints(codec); return 0; }
/* * Pavo for a jzcodec as connected on jz4740 Device */ static int pavo_jzcodec_init(struct snd_soc_codec *codec) { int i, err; snd_soc_dapm_nc_pin(codec, "LLINEIN"); snd_soc_dapm_nc_pin(codec, "RLINEIN"); /* Add pavo specific controls */ for (i = 0; i < ARRAY_SIZE(jzcodec_pavo_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&jzcodec_pavo_controls[i],codec, NULL)); if (err < 0) return err; } /* Add pavo specific widgets */ for(i = 0; i < ARRAY_SIZE(jzcodec_dapm_widgets); i++) { snd_soc_dapm_new_control(codec, &jzcodec_dapm_widgets[i]); } // snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); snd_soc_dapm_sync(codec); return 0; }
int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427, struct snd_pcm_substream *play_substream, struct snd_pcm_substream *cap_substream) { struct cs8427 *chip = cs8427->private_data; struct snd_kcontrol *kctl; unsigned int idx; int err; if (snd_BUG_ON(!play_substream || !cap_substream)) return -EINVAL; for (idx = 0; idx < ARRAY_SIZE(snd_cs8427_iec958_controls); idx++) { kctl = snd_ctl_new1(&snd_cs8427_iec958_controls[idx], cs8427); if (kctl == NULL) return -ENOMEM; kctl->id.device = play_substream->pcm->device; kctl->id.subdevice = play_substream->number; err = snd_ctl_add(cs8427->bus->card, kctl); if (err < 0) return err; if (! strcmp(kctl->id.name, SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM))) chip->playback.pcm_ctl = kctl; } chip->playback.substream = play_substream; chip->capture.substream = cap_substream; if (snd_BUG_ON(!chip->playback.pcm_ctl)) return -EIO; return 0; }
static int imx_3stack_wm8350_init(struct snd_soc_codec *codec) { struct imx_3stack_priv *priv = &machine_priv; struct wm8350 *wm8350 = priv->wm8350; int i, ret; codec->control_data = wm8350; /* Add imx_3stack specific controls */ for (i = 0; i < ARRAY_SIZE(wm8350_machine_controls); i++) { ret = snd_ctl_add(codec->card, snd_soc_cnew(&wm8350_machine_controls[i], codec, NULL)); if (ret < 0) return ret; } /* Add imx_3stack specific widgets */ snd_soc_dapm_new_controls(codec, imx_3stack_dapm_widgets, ARRAY_SIZE(imx_3stack_dapm_widgets)); /* Set up imx_3stack specific audio path audio_map */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); snd_soc_dapm_sync(codec); return 0; }
/* * Logic for a wm8750 as connected on a Sharp SL-Cxx00 Device */ static int spitz_wm8750_init(struct snd_soc_codec *codec) { int i, err; /* NC codec pins */ snd_soc_dapm_disable_pin(codec, "RINPUT1"); snd_soc_dapm_disable_pin(codec, "LINPUT2"); snd_soc_dapm_disable_pin(codec, "RINPUT2"); snd_soc_dapm_disable_pin(codec, "LINPUT3"); snd_soc_dapm_disable_pin(codec, "RINPUT3"); snd_soc_dapm_disable_pin(codec, "OUT3"); snd_soc_dapm_disable_pin(codec, "MONO"); /* Add spitz specific controls */ for (i = 0; i < ARRAY_SIZE(wm8750_spitz_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&wm8750_spitz_controls[i], codec, NULL)); if (err < 0) return err; } /* Add spitz specific widgets */ snd_soc_dapm_new_controls(codec, wm8750_dapm_widgets, ARRAY_SIZE(wm8750_dapm_widgets)); /* Set up spitz specific audio paths */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); snd_soc_dapm_sync(codec); return 0; }
static int smdkc110_wm8994_init(struct snd_soc_codec *codec) { #if 0 debug_msg("%s\n", __FUNCTION__); /* Add smdkc110 specific controls */ for (i = 0; i < ARRAY_SIZE(wm8580_smdkc110_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&wm8580_smdkc110_controls[i], codec, NULL)); if (err < 0) return err; } /* Add smdkc110 specific widgets */ snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets, ARRAY_SIZE(wm8580_dapm_widgets)); /* Set up smdkc110 specific audio path audio_map */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); /* No jack detect - mark all jacks as enabled */ for (i = 0; i < ARRAY_SIZE(wm8580_dapm_widgets); i++) snd_soc_dapm_enable_pin(codec, wm8580_dapm_widgets[i].name); /* Setup Default Route */ smdkc110_play_opt = PLAY_STEREO; smdkc110_rec_opt = REC_LINE; smdkc110_ext_control(codec); #endif return 0; }
static int tosa_ac97_init(struct snd_soc_codec *codec) { int i, err; snd_soc_dapm_disable_pin(codec, "OUT3"); snd_soc_dapm_disable_pin(codec, "MONOOUT"); /* add tosa specific controls */ for (i = 0; i < ARRAY_SIZE(tosa_controls); i++) { err = snd_ctl_add(codec->card, snd_soc_cnew(&tosa_controls[i],codec, NULL)); if (err < 0) return err; } /* add tosa specific widgets */ snd_soc_dapm_new_controls(codec, tosa_dapm_widgets, ARRAY_SIZE(tosa_dapm_widgets)); /* set up tosa specific audio path audio_map */ snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); snd_soc_dapm_sync(codec); return 0; }
int tegra_controls_init(struct snd_soc_codec *codec) { struct tegra_audio_data* audio_data = codec->socdev->codec_data; int err; /* Add play route control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_play_route_control, audio_data)); if (err < 0) return err; /* Add capture route control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_capture_route_control, audio_data)); if (err < 0) return err; /* Add call mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_call_mode_control, audio_data)); if (err < 0) return err; #if defined(CONFIG_MACH_ACER_PICASSO) || defined(CONFIG_MACH_ACER_MAYA) || defined(CONFIG_MACH_ACER_VANGOGH) /* Add mic mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_mic_mode_control, audio_data)); if (err < 0) return err; /* Add shutdown mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_shutdown_mode_control, audio_data)); if (err < 0) return err; /* Add ringtone mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_ringtone_mode_control, audio_data)); if (err < 0) return err; /* Add video call mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_video_call_mode_control, audio_data)); if (err < 0) return err; /* Add automatic speech recognition mode switch control */ err = snd_ctl_add(codec->card, snd_ctl_new1(&tegra_speech_mode_control, audio_data)); if (err < 0) return err; #endif return 0; }
int __devinit usb6fire_control_init(struct sfire_chip *chip) { int i; int ret; struct control_runtime *rt = kzalloc(sizeof(struct control_runtime), GFP_KERNEL); struct comm_runtime *comm_rt = chip->comm; if (!rt) return -ENOMEM; rt->chip = chip; rt->update_streaming = usb6fire_control_streaming_update; rt->set_rate = usb6fire_control_set_rate; rt->set_channels = usb6fire_control_set_channels; i = 0; while (init_data[i].type) { comm_rt->write8(comm_rt, init_data[i].type, init_data[i].reg, init_data[i].value); i++; } usb6fire_control_opt_coax_update(rt); usb6fire_control_line_phono_update(rt); usb6fire_control_output_vol_update(rt); usb6fire_control_output_mute_update(rt); usb6fire_control_input_vol_update(rt); usb6fire_control_streaming_update(rt); ret = usb6fire_control_add_virtual(rt, chip->card, "Master Playback Volume", vol_elements); if (ret) { snd_printk(KERN_ERR PREFIX "cannot add control.\n"); kfree(rt); return ret; } ret = usb6fire_control_add_virtual(rt, chip->card, "Master Playback Switch", mute_elements); if (ret) { snd_printk(KERN_ERR PREFIX "cannot add control.\n"); kfree(rt); return ret; } i = 0; while (elements[i].name) { ret = snd_ctl_add(chip->card, snd_ctl_new1(&elements[i], rt)); if (ret < 0) { kfree(rt); snd_printk(KERN_ERR PREFIX "cannot add control.\n"); return ret; } i++; } chip->control = rt; return 0; }
static int create_src_gain_mixer(struct lola *chip, int num, int ofs, char *name) { lola_src_gain_mixer.name = name; lola_src_gain_mixer.private_value = ofs + (num << 8); return snd_ctl_add(chip->card, snd_ctl_new1(&lola_src_gain_mixer, chip)); }
/* * Lola16161 or Lola881 can have Hardware sample rate converters * on its digital input pins */ static int create_input_src_mixer(struct lola *chip) { if (!chip->input_src_caps_mask) return 0; return snd_ctl_add(chip->card, snd_ctl_new1(&lola_input_src_mixer, chip)); }
/*! * This function registers the control components of ALSA Mixer * It is called by ALSA PCM init. * * @param card pointer to the ALSA sound card structure. * * @return 0 on success, -ve otherwise. */ int __devinit mxc_alsa_create_ctl(struct snd_card *card, void *p_value) { int err = 0; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_op_sw, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_pb_vol, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_pb_monoconfig, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_pb_bal, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_cap_vol, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_ip_sw, p_value)); if (err < 0) return err; err = snd_ctl_add(card, snd_ctl_new1(&pmic_control_loop_out, p_value)); if (err < 0) return err; return 0; }
/* Initialize beep stuff */ int snd_pmac_attach_beep(struct snd_pmac *chip) { struct pmac_beep *beep; struct input_dev *input_dev; struct snd_kcontrol *beep_ctl; void *dmabuf; int err = -ENOMEM; beep = kzalloc(sizeof(*beep), GFP_KERNEL); if (! beep) return -ENOMEM; dmabuf = dma_alloc_coherent(&chip->pdev->dev, BEEP_BUFLEN * 4, &beep->addr, GFP_KERNEL); input_dev = input_allocate_device(); if (! dmabuf || ! input_dev) goto fail1; /* FIXME: set more better values */ input_dev->name = "PowerMac Beep"; input_dev->phys = "powermac/beep"; input_dev->id.bustype = BUS_ADB; input_dev->id.vendor = 0x001f; input_dev->id.product = 0x0001; input_dev->id.version = 0x0100; input_dev->evbit[0] = BIT_MASK(EV_SND); input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE); input_dev->event = snd_pmac_beep_event; input_dev->dev.parent = &chip->pdev->dev; input_set_drvdata(input_dev, chip); beep->dev = input_dev; beep->buf = dmabuf; beep->volume = BEEP_VOLUME; beep->running = 0; beep_ctl = snd_ctl_new1(&snd_pmac_beep_mixer, chip); err = snd_ctl_add(chip->card, beep_ctl); if (err < 0) goto fail1; chip->beep = beep; err = input_register_device(beep->dev); if (err) goto fail2; return 0; fail2: snd_ctl_remove(chip->card, beep_ctl); fail1: input_free_device(input_dev); if (dmabuf) dma_free_coherent(&chip->pdev->dev, BEEP_BUFLEN * 4, dmabuf, beep->addr); kfree(beep); return err; }
static int create_dest_gain_mixer(struct lola *chip, int src_num, int src_ofs, int num, int ofs, char *name) { lola_dest_gain_mixer.count = num; lola_dest_gain_mixer.name = name; lola_dest_gain_mixer.private_value = src_ofs + (src_num << 8) + (ofs << 16) + (num << 24); return snd_ctl_add(chip->card, snd_ctl_new1(&lola_dest_gain_mixer, chip)); }
static int __devinit phase28_add_controls(struct snd_ice1712 *ice) { unsigned int i, counts; int err; counts = ARRAY_SIZE(phase28_dac_controls); for (i = 0; i < counts; i++) { err = snd_ctl_add(ice->card, snd_ctl_new1(&phase28_dac_controls[i], ice)); if (err < 0) return err; } for (i = 0; i < ARRAY_SIZE(wm_controls); i++) { err = snd_ctl_add(ice->card, snd_ctl_new1(&wm_controls[i], ice)); if (err < 0) return err; } return 0; }
static int av8100_codec_probe(struct snd_soc_codec *codec) { pr_debug("%s: Enter (codec->name = %s).\n", __func__, codec->name); audio_coding_type = AV8100_CODEC_CT_REFER; /* Add controls with events */ snd_ctl_add(codec->card->snd_card, snd_ctl_new1(&hdmi_coding_type_control, codec)); return 0; }