mutex_unlock(&preset_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
+EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
{
mutex_unlock(&preset_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
+EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
#ifdef CONFIG_SND_HDA_POWER_SAVE
static void hda_power_work(struct work_struct *work);
}
return "UNKNOWN";
}
-EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
+EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
const char *snd_hda_get_jack_connectivity(u32 cfg)
{
return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
}
-EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
+EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
const char *snd_hda_get_jack_type(u32 cfg)
{
return jack_types[(cfg & AC_DEFCFG_DEVICE)
>> AC_DEFCFG_DEVICE_SHIFT];
}
-EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
+EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
/*
* Compose a 32bit command word to be sent to the HD-audio controller
snd_hda_power_down(codec);
return res;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_read);
+EXPORT_SYMBOL_HDA(snd_hda_codec_read);
/**
* snd_hda_codec_write - send a single command without waiting for response
snd_hda_power_down(codec);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_write);
+EXPORT_SYMBOL_HDA(snd_hda_codec_write);
/**
* snd_hda_sequence_write - sequence writes
for (; seq->nid; seq++)
snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
}
-EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
+EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
/**
* snd_hda_get_sub_nodes - get the range of sub nodes
*start_id = (parm >> 16) & 0x7fff;
return (int)(parm & 0x7fff);
}
-EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
+EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
/**
* snd_hda_get_connections - get connection list
}
return conns;
}
-EXPORT_SYMBOL_GPL(snd_hda_get_connections);
+EXPORT_SYMBOL_HDA(snd_hda_get_connections);
/**
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
+EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
/*
* process queued unsolicited events
*busp = bus;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_bus_new);
+EXPORT_SYMBOL_HDA(snd_hda_bus_new);
#ifdef CONFIG_SND_HDA_GENERIC
#define is_generic_config(codec) \
#define is_generic_config(codec) 0
#endif
-#ifdef CONFIG_SND_HDA_INTEL_MODULE
+#ifdef MODULE
#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
#else
-#define HDA_MODREQ_MAX_COUNT 0
+#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
#endif
/*
*codecp = codec;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_new);
+EXPORT_SYMBOL_HDA(snd_hda_codec_new);
int snd_hda_codec_configure(struct hda_codec *codec)
{
msleep(1);
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
+EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
{
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
#endif
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_stream);
+EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
/*
* amp access functions
}
return info->amp_caps;
}
-EXPORT_SYMBOL_GPL(query_amp_caps);
+EXPORT_SYMBOL_HDA(query_amp_caps);
int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
unsigned int caps)
info->head.val |= INFO_AMP_CAPS;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
+EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
/*
* read the current volume to info
return 0;
return get_vol_mute(codec, info, nid, ch, direction, index);
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
+EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
/*
* update the AMP value, mask = bit mask to set, val = the value
put_vol_mute(codec, info, nid, ch, direction, idx, val);
return 1;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
+EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
/*
* update the AMP stereo with the same mask and value
idx, mask, val);
return ret;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
+EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
#ifdef SND_HDA_NEEDS_RESUME
/* resume the all amp commands from the cache */
}
}
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
+EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
#endif /* SND_HDA_NEEDS_RESUME */
/* volume */
uinfo->value.integer.max = caps;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
& HDA_AMP_VOLMASK;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
snd_hda_power_down(codec);
return change;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
unsigned int size, unsigned int __user *_tlv)
return -EFAULT;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
/*
* set (static) TLV for virtual master volume; recalculated as max 0dB
tlv[2] = -nums * step;
tlv[3] = step;
}
-EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
+EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
/* find a mixer control element with the given name */
static struct snd_kcontrol *
{
return _snd_hda_find_mixer_ctl(codec, name, 0);
}
-EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
+EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
/* Add a control element and assign to the codec */
int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
*knewp = kctl;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
+EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
#ifdef CONFIG_SND_HDA_RECONFIG
/* Clear all controls assigned to the given codec */
}
if (codec->patch_ops.free)
codec->patch_ops.free(codec);
+ codec->proc_widget_hook = NULL;
codec->spec = NULL;
free_hda_cache(&codec->amp_cache);
free_hda_cache(&codec->cmd_cache);
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_add_vmaster);
+EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
/* switch */
int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
uinfo->value.integer.max = 1;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
HDA_AMP_MUTE) ? 0 : 1;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
snd_hda_power_down(codec);
return change;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
/*
* bound volume controls
mutex_unlock(&codec->spdif_mutex);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
mutex_unlock(&codec->spdif_mutex);
return err < 0 ? err : change;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
/*
* generic bound volume/swtich controls
mutex_unlock(&codec->spdif_mutex);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
mutex_unlock(&codec->spdif_mutex);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
mutex_unlock(&codec->spdif_mutex);
return err < 0 ? err : change;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
unsigned int size, unsigned int __user *tlv)
mutex_unlock(&codec->spdif_mutex);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
+EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
struct hda_ctl_ops snd_hda_bind_vol = {
.info = snd_hda_mixer_amp_volume_info,
.put = snd_hda_mixer_amp_volume_put,
.tlv = snd_hda_mixer_amp_tlv
};
-EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
+EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
struct hda_ctl_ops snd_hda_bind_sw = {
.info = snd_hda_mixer_amp_switch_info,
.put = snd_hda_mixer_amp_switch_put,
.tlv = snd_hda_mixer_amp_tlv
};
-EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
+EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
/*
* SPDIF out controls
codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_create_spdif_out_ctls);
+EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
/*
* SPDIF sharing with analog output
return snd_hda_ctl_add(codec,
snd_ctl_new1(&spdif_share_sw, mout));
}
-EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
+EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
/*
* SPDIF input
AC_DIG1_ENABLE;
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
+EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
#ifdef SND_HDA_NEEDS_RESUME
/*
snd_hda_power_down(codec);
return err;
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
+EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
/* resume the all commands from the cache */
void snd_hda_codec_resume_cache(struct hda_codec *codec)
get_cmd_cache_cmd(key), buffer->val);
}
}
-EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
+EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
/**
* snd_hda_sequence_write_cache - sequence writes with caching
snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
seq->param);
}
-EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
+EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
#endif /* SND_HDA_NEEDS_RESUME */
/*
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_build_controls);
+EXPORT_SYMBOL_HDA(snd_hda_build_controls);
int snd_hda_codec_build_controls(struct hda_codec *codec)
{
return val;
}
-EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
+EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
/**
* snd_hda_query_supported_pcm - query the supported PCM rates and formats
return 1;
}
-EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
+EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
/*
* PCM stuff
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
+EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
/**
* snd_hda_check_board_config - compare the current codec with the config table
}
return -1;
}
-EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
+EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
/**
* snd_hda_add_new_ctls - create controls from the array
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
+EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
#ifdef CONFIG_SND_HDA_POWER_SAVE
static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
cancel_delayed_work(&codec->power_work);
codec->power_transition = 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_power_up);
+EXPORT_SYMBOL_HDA(snd_hda_power_up);
#define power_save(codec) \
((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
msecs_to_jiffies(power_save(codec) * 1000));
}
}
-EXPORT_SYMBOL_GPL(snd_hda_power_down);
+EXPORT_SYMBOL_HDA(snd_hda_power_down);
int snd_hda_check_amp_list_power(struct hda_codec *codec,
struct hda_loopback_check *check,
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
+EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
#endif
/*
chmode[uinfo->value.enumerated.item].channels);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
+EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
int snd_hda_ch_mode_get(struct hda_codec *codec,
struct snd_ctl_elem_value *ucontrol,
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
+EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
int snd_hda_ch_mode_put(struct hda_codec *codec,
struct snd_ctl_elem_value *ucontrol,
snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
return 1;
}
-EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
+EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
/*
* input MUX helper
strcpy(uinfo->value.enumerated.name, imux->items[index].label);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
+EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
int snd_hda_input_mux_put(struct hda_codec *codec,
const struct hda_input_mux *imux,
*cur_val = idx;
return 1;
}
-EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
+EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
/*
mutex_unlock(&codec->spdif_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
struct hda_multi_out *mout,
mutex_unlock(&codec->spdif_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
/*
* release the digital out
mutex_unlock(&codec->spdif_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
/*
* set up more restrictions for analog out
return snd_pcm_hw_constraint_step(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
/*
* set up the i/o for analog out
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
/*
* clean up the setting for analog out
mutex_unlock(&codec->spdif_mutex);
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
/*
* Helper for automatic pin configuration
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_parse_pin_def_config);
+EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
/* labels for input pins */
const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
"Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
};
-EXPORT_SYMBOL_GPL(auto_pin_cfg_labels);
+EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
#ifdef CONFIG_PM
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_suspend);
+EXPORT_SYMBOL_HDA(snd_hda_suspend);
/**
* snd_hda_resume - resume the codecs
}
return 0;
}
-EXPORT_SYMBOL_GPL(snd_hda_resume);
+EXPORT_SYMBOL_HDA(snd_hda_resume);
#endif /* CONFIG_PM */
/*
}
return snd_array_elem(array, array->used++);
}
-EXPORT_SYMBOL_GPL(snd_array_new);
+EXPORT_SYMBOL_HDA(snd_array_new);
/* free the given array elements */
void snd_array_free(struct snd_array *array)
array->alloced = 0;
array->list = NULL;
}
-EXPORT_SYMBOL_GPL(snd_array_free);
+EXPORT_SYMBOL_HDA(snd_array_free);
/*
* used by hda_proc.c and hda_eld.c
buf[j] = '\0'; /* necessary when j == 0 */
}
-EXPORT_SYMBOL_GPL(snd_print_pcm_rates);
+EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
void snd_print_pcm_bits(int pcm, char *buf, int buflen)
{
buf[j] = '\0'; /* necessary when j == 0 */
}
-EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
+EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
MODULE_DESCRIPTION("HDA codec core");
MODULE_LICENSE("GPL");
projects / linux-2.6-omap-h63xx.git / blobdiff