ALSA: hda - Kill EXPORT_SYMBOL_HDA()
Replace all with the standard EXPORT_SYMBOL_GPL(). Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai
parent
595fe1b702
commit
2698ea9805
@ -414,7 +414,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_parse_pin_defcfg);
|
||||
|
||||
int snd_hda_get_input_pin_attr(unsigned int def_conf)
|
||||
{
|
||||
@ -435,7 +435,7 @@ int snd_hda_get_input_pin_attr(unsigned int def_conf)
|
||||
return INPUT_PIN_ATTR_FRONT;
|
||||
return INPUT_PIN_ATTR_NORMAL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_input_pin_attr);
|
||||
|
||||
/**
|
||||
* hda_get_input_pin_label - Give a label for the given input pin
|
||||
@ -547,7 +547,7 @@ const char *hda_get_autocfg_input_label(struct hda_codec *codec,
|
||||
cfg->inputs[input].pin,
|
||||
has_multiple_pins);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
|
||||
EXPORT_SYMBOL_GPL(hda_get_autocfg_input_label);
|
||||
|
||||
/* return the position of NID in the list, or -1 if not found */
|
||||
static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
|
||||
@ -721,7 +721,7 @@ int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
|
||||
strlcpy(label, name, maxlen);
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_pin_label);
|
||||
|
||||
int snd_hda_add_verbs(struct hda_codec *codec,
|
||||
const struct hda_verb *list)
|
||||
@ -733,7 +733,7 @@ int snd_hda_add_verbs(struct hda_codec *codec,
|
||||
*v = list;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_verbs);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_verbs);
|
||||
|
||||
void snd_hda_apply_verbs(struct hda_codec *codec)
|
||||
{
|
||||
@ -743,7 +743,7 @@ void snd_hda_apply_verbs(struct hda_codec *codec)
|
||||
snd_hda_sequence_write(codec, *v);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_apply_verbs);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_apply_verbs);
|
||||
|
||||
void snd_hda_apply_pincfgs(struct hda_codec *codec,
|
||||
const struct hda_pintbl *cfg)
|
||||
@ -751,7 +751,7 @@ void snd_hda_apply_pincfgs(struct hda_codec *codec,
|
||||
for (; cfg->nid; cfg++)
|
||||
snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_apply_pincfgs);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_apply_pincfgs);
|
||||
|
||||
static void set_pin_targets(struct hda_codec *codec,
|
||||
const struct hda_pintbl *cfg)
|
||||
@ -822,7 +822,7 @@ void snd_hda_apply_fixup(struct hda_codec *codec, int action)
|
||||
if (codec->fixup_list)
|
||||
apply_fixup(codec, codec->fixup_id, action, 0);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_apply_fixup);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);
|
||||
|
||||
void snd_hda_pick_fixup(struct hda_codec *codec,
|
||||
const struct hda_model_fixup *models,
|
||||
@ -880,4 +880,4 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
|
||||
codec->fixup_name = name;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_pick_fixup);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);
|
||||
|
||||
@ -194,7 +194,7 @@ int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_enable_beep_device);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
|
||||
|
||||
int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
|
||||
{
|
||||
@ -231,7 +231,7 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_attach_beep_device);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
|
||||
|
||||
void snd_hda_detach_beep_device(struct hda_codec *codec)
|
||||
{
|
||||
@ -243,7 +243,7 @@ void snd_hda_detach_beep_device(struct hda_codec *codec)
|
||||
kfree(beep);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
|
||||
|
||||
static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
|
||||
{
|
||||
@ -265,7 +265,7 @@ int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
|
||||
}
|
||||
return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get_beep);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep);
|
||||
|
||||
int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
@ -288,4 +288,4 @@ int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
|
||||
return 0;
|
||||
return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep);
|
||||
|
||||
@ -84,7 +84,7 @@ int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
|
||||
mutex_unlock(&preset_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
|
||||
|
||||
int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
|
||||
{
|
||||
@ -93,7 +93,7 @@ int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
|
||||
mutex_unlock(&preset_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#define codec_in_pm(codec) ((codec)->in_pm)
|
||||
@ -152,7 +152,7 @@ const char *snd_hda_get_jack_location(u32 cfg)
|
||||
}
|
||||
return "UNKNOWN";
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
|
||||
|
||||
/**
|
||||
* snd_hda_get_jack_connectivity - Give a connectivity string of the jack
|
||||
@ -167,7 +167,7 @@ const char *snd_hda_get_jack_connectivity(u32 cfg)
|
||||
|
||||
return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
|
||||
|
||||
/**
|
||||
* snd_hda_get_jack_type - Give a type string of the jack
|
||||
@ -188,7 +188,7 @@ const char *snd_hda_get_jack_type(u32 cfg)
|
||||
return jack_types[(cfg & AC_DEFCFG_DEVICE)
|
||||
>> AC_DEFCFG_DEVICE_SHIFT];
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
|
||||
|
||||
/*
|
||||
* Compose a 32bit command word to be sent to the HD-audio controller
|
||||
@ -284,7 +284,7 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
|
||||
return -1;
|
||||
return res;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_read);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_read);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_write - send a single command without waiting for response
|
||||
@ -306,7 +306,7 @@ int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
|
||||
return codec_exec_verb(codec, cmd, flags,
|
||||
codec->bus->sync_write ? &res : NULL);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_write);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_write);
|
||||
|
||||
/**
|
||||
* snd_hda_sequence_write - sequence writes
|
||||
@ -321,7 +321,7 @@ void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
|
||||
for (; seq->nid; seq++)
|
||||
snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
|
||||
|
||||
/**
|
||||
* snd_hda_get_sub_nodes - get the range of sub nodes
|
||||
@ -343,7 +343,7 @@ int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
|
||||
*start_id = (parm >> 16) & 0x7fff;
|
||||
return (int)(parm & 0x7fff);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
|
||||
|
||||
/* connection list element */
|
||||
struct hda_conn_list {
|
||||
@ -453,7 +453,7 @@ int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
|
||||
added = true;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
|
||||
|
||||
/**
|
||||
* snd_hda_get_connections - copy connection list
|
||||
@ -485,7 +485,7 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
|
||||
return len;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_connections);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_connections);
|
||||
|
||||
/* return CONNLIST_LEN parameter of the given widget */
|
||||
static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
|
||||
@ -634,7 +634,7 @@ int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
|
||||
|
||||
return add_conn_list(codec, nid, len, list);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
|
||||
|
||||
/**
|
||||
* snd_hda_get_conn_index - get the connection index of the given NID
|
||||
@ -673,7 +673,7 @@ int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
|
||||
|
||||
|
||||
/* return DEVLIST_LEN parameter of the given widget */
|
||||
@ -769,7 +769,7 @@ int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
|
||||
|
||||
/*
|
||||
* process queued unsolicited events
|
||||
@ -930,7 +930,7 @@ int snd_hda_bus_new(struct snd_card *card,
|
||||
*busp = bus;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_bus_new);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_bus_new);
|
||||
|
||||
#ifdef CONFIG_SND_HDA_GENERIC
|
||||
#define is_generic_config(codec) \
|
||||
@ -1170,7 +1170,7 @@ int snd_hda_codec_set_pincfg(struct hda_codec *codec,
|
||||
{
|
||||
return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_get_pincfg - Obtain a pin-default configuration
|
||||
@ -1205,7 +1205,7 @@ unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
|
||||
return pin->cfg;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
|
||||
|
||||
/* remember the current pinctl target value */
|
||||
int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
|
||||
@ -1219,7 +1219,7 @@ int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
|
||||
pin->target = val;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
|
||||
|
||||
/* return the current pinctl target value */
|
||||
int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
|
||||
@ -1231,7 +1231,7 @@ int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
|
||||
return 0;
|
||||
return pin->target;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
|
||||
|
||||
/**
|
||||
* snd_hda_shutup_pins - Shut up all pins
|
||||
@ -1256,7 +1256,7 @@ void snd_hda_shutup_pins(struct hda_codec *codec)
|
||||
}
|
||||
codec->pins_shutup = 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
|
||||
@ -1544,7 +1544,7 @@ int snd_hda_codec_new(struct hda_bus *bus,
|
||||
snd_hda_codec_free(codec);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_new);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_new);
|
||||
|
||||
int snd_hda_codec_update_widgets(struct hda_codec *codec)
|
||||
{
|
||||
@ -1567,7 +1567,7 @@ int snd_hda_codec_update_widgets(struct hda_codec *codec)
|
||||
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
|
||||
|
||||
|
||||
#ifdef CONFIG_SND_HDA_CODEC_HDMI
|
||||
@ -1651,7 +1651,7 @@ int snd_hda_codec_configure(struct hda_codec *codec)
|
||||
"%s %s", codec->vendor_name, codec->chip_name);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
|
||||
|
||||
/* update the stream-id if changed */
|
||||
static void update_pcm_stream_id(struct hda_codec *codec,
|
||||
@ -1738,7 +1738,7 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
|
||||
|
||||
static void really_cleanup_stream(struct hda_codec *codec,
|
||||
struct hda_cvt_setup *q);
|
||||
@ -1773,7 +1773,7 @@ void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
|
||||
p->active = 0;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
|
||||
EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
|
||||
|
||||
static void really_cleanup_stream(struct hda_codec *codec,
|
||||
struct hda_cvt_setup *q)
|
||||
@ -1961,7 +1961,7 @@ u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
|
||||
HDA_HASH_KEY(nid, direction, 0),
|
||||
read_amp_cap);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(query_amp_caps);
|
||||
EXPORT_SYMBOL_GPL(query_amp_caps);
|
||||
|
||||
/**
|
||||
* snd_hda_override_amp_caps - Override the AMP capabilities
|
||||
@ -1981,7 +1981,7 @@ int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
|
||||
{
|
||||
return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
|
||||
|
||||
static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
|
||||
int dir)
|
||||
@ -2005,7 +2005,7 @@ u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
|
||||
return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
|
||||
read_pin_cap);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
|
||||
|
||||
/**
|
||||
* snd_hda_override_pin_caps - Override the pin capabilities
|
||||
@ -2022,7 +2022,7 @@ int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
|
||||
{
|
||||
return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
|
||||
|
||||
/* read or sync the hash value with the current value;
|
||||
* call within hash_mutex
|
||||
@ -2103,7 +2103,7 @@ int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
|
||||
mutex_unlock(&codec->hash_mutex);
|
||||
return val;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
|
||||
|
||||
static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
|
||||
int direction, int idx, int mask, int val,
|
||||
@ -2155,7 +2155,7 @@ int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
|
||||
{
|
||||
return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_amp_stereo - update the AMP stereo values
|
||||
@ -2181,7 +2181,7 @@ int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
|
||||
idx, mask, val);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
|
||||
|
||||
/* Works like snd_hda_codec_amp_update() but it writes the value only at
|
||||
* the first access. If the amp was already initialized / updated beforehand,
|
||||
@ -2192,7 +2192,7 @@ int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
|
||||
{
|
||||
return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
|
||||
|
||||
int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
|
||||
int dir, int idx, int mask, int val)
|
||||
@ -2206,7 +2206,7 @@ int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
|
||||
idx, mask, val);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_resume_amp - Resume all AMP commands from the cache
|
||||
@ -2249,7 +2249,7 @@ void snd_hda_codec_resume_amp(struct hda_codec *codec)
|
||||
}
|
||||
mutex_unlock(&codec->hash_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
|
||||
|
||||
static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
|
||||
unsigned int ofs)
|
||||
@ -2289,7 +2289,7 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
|
||||
|
||||
|
||||
static inline unsigned int
|
||||
@ -2346,7 +2346,7 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
|
||||
*valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
|
||||
@ -2376,7 +2376,7 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
|
||||
snd_hda_power_down(codec);
|
||||
return change;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
|
||||
@ -2414,7 +2414,7 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
|
||||
|
||||
/**
|
||||
* snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
|
||||
@ -2442,7 +2442,7 @@ void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
|
||||
tlv[2] = -nums * step;
|
||||
tlv[3] = step;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
|
||||
|
||||
/* find a mixer control element with the given name */
|
||||
static struct snd_kcontrol *
|
||||
@ -2471,7 +2471,7 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
|
||||
{
|
||||
return find_mixer_ctl(codec, name, 0, 0);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
|
||||
|
||||
static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
|
||||
int start_idx)
|
||||
@ -2531,7 +2531,7 @@ int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
|
||||
item->flags = flags;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
|
||||
|
||||
/**
|
||||
* snd_hda_add_nid - Assign a NID to a control element
|
||||
@ -2562,7 +2562,7 @@ int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
|
||||
kctl->id.name, kctl->id.index, index);
|
||||
return -EINVAL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_nid);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_nid);
|
||||
|
||||
/**
|
||||
* snd_hda_ctls_clear - Clear all controls assigned to the given codec
|
||||
@ -2613,7 +2613,7 @@ int snd_hda_lock_devices(struct hda_bus *bus)
|
||||
spin_unlock(&card->files_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
|
||||
|
||||
void snd_hda_unlock_devices(struct hda_bus *bus)
|
||||
{
|
||||
@ -2624,7 +2624,7 @@ void snd_hda_unlock_devices(struct hda_bus *bus)
|
||||
card->shutdown = 0;
|
||||
spin_unlock(&card->files_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_reset - Clear all objects assigned to the codec
|
||||
@ -2848,7 +2848,7 @@ int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
|
||||
*ctl_ret = kctl;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
|
||||
EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
|
||||
|
||||
/*
|
||||
* mute-LED control using vmaster
|
||||
@ -2925,7 +2925,7 @@ int snd_hda_add_vmaster_hook(struct hda_codec *codec,
|
||||
return -ENOMEM;
|
||||
return snd_hda_ctl_add(codec, 0, kctl);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
|
||||
|
||||
/*
|
||||
* Call the hook with the current value for synchronization
|
||||
@ -2949,7 +2949,7 @@ void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
|
||||
break;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
|
||||
|
||||
|
||||
/**
|
||||
@ -2969,7 +2969,7 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
|
||||
uinfo->value.integer.max = 1;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
|
||||
@ -2995,7 +2995,7 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
|
||||
HDA_AMP_MUTE) ? 0 : 1;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
|
||||
@ -3029,7 +3029,7 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
|
||||
snd_hda_power_down(codec);
|
||||
return change;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
|
||||
|
||||
/*
|
||||
* bound volume controls
|
||||
@ -3061,7 +3061,7 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
|
||||
@ -3091,7 +3091,7 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err < 0 ? err : change;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
|
||||
@ -3114,7 +3114,7 @@ int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
|
||||
@ -3137,7 +3137,7 @@ int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
|
||||
@ -3166,7 +3166,7 @@ int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err < 0 ? err : change;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
|
||||
|
||||
/**
|
||||
* snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
|
||||
@ -3189,7 +3189,7 @@ int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
||||
mutex_unlock(&codec->control_mutex);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
|
||||
|
||||
struct hda_ctl_ops snd_hda_bind_vol = {
|
||||
.info = snd_hda_mixer_amp_volume_info,
|
||||
@ -3197,7 +3197,7 @@ struct hda_ctl_ops snd_hda_bind_vol = {
|
||||
.put = snd_hda_mixer_amp_volume_put,
|
||||
.tlv = snd_hda_mixer_amp_tlv
|
||||
};
|
||||
EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
|
||||
|
||||
struct hda_ctl_ops snd_hda_bind_sw = {
|
||||
.info = snd_hda_mixer_amp_switch_info,
|
||||
@ -3205,7 +3205,7 @@ struct hda_ctl_ops snd_hda_bind_sw = {
|
||||
.put = snd_hda_mixer_amp_switch_put,
|
||||
.tlv = snd_hda_mixer_amp_tlv
|
||||
};
|
||||
EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
|
||||
|
||||
/*
|
||||
* SPDIF out controls
|
||||
@ -3509,7 +3509,7 @@ int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
|
||||
spdif->status = convert_to_spdif_status(spdif->ctls);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
|
||||
|
||||
/* get the hda_spdif_out entry from the given NID
|
||||
* call within spdif_mutex lock
|
||||
@ -3526,7 +3526,7 @@ struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
|
||||
|
||||
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
|
||||
{
|
||||
@ -3537,7 +3537,7 @@ void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
|
||||
spdif->nid = (u16)-1;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
|
||||
|
||||
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
|
||||
{
|
||||
@ -3553,7 +3553,7 @@ void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
|
||||
|
||||
/*
|
||||
* SPDIF sharing with analog output
|
||||
@ -3601,7 +3601,7 @@ int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
|
||||
/* ATTENTION: here mout is passed as private_data, instead of codec */
|
||||
return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
|
||||
|
||||
/*
|
||||
* SPDIF input
|
||||
@ -3709,7 +3709,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
|
||||
AC_DIG1_ENABLE;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
|
||||
|
||||
/*
|
||||
* command cache
|
||||
@ -3760,7 +3760,7 @@ int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
|
||||
mutex_unlock(&codec->bus->cmd_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_update_cache - check cache and write the cmd only when needed
|
||||
@ -3795,7 +3795,7 @@ int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
|
||||
mutex_unlock(&codec->bus->cmd_mutex);
|
||||
return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_resume_cache - Resume the all commands from the cache
|
||||
@ -3827,7 +3827,7 @@ void snd_hda_codec_resume_cache(struct hda_codec *codec)
|
||||
}
|
||||
mutex_unlock(&codec->hash_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
|
||||
|
||||
/**
|
||||
* snd_hda_sequence_write_cache - sequence writes with caching
|
||||
@ -3845,7 +3845,7 @@ void snd_hda_sequence_write_cache(struct hda_codec *codec,
|
||||
snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
|
||||
seq->param);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
|
||||
|
||||
/**
|
||||
* snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
|
||||
@ -3856,7 +3856,7 @@ void snd_hda_codec_flush_cache(struct hda_codec *codec)
|
||||
snd_hda_codec_resume_amp(codec);
|
||||
snd_hda_codec_resume_cache(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
|
||||
|
||||
void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
|
||||
unsigned int power_state)
|
||||
@ -3878,7 +3878,7 @@ void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
|
||||
state);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
|
||||
|
||||
/*
|
||||
* supported power states check
|
||||
@ -3937,7 +3937,7 @@ unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
|
||||
}
|
||||
return power_state;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_eapd_power_filter);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
|
||||
|
||||
/*
|
||||
* set power state of the codec, and return the power state
|
||||
@ -4124,7 +4124,7 @@ int snd_hda_build_controls(struct hda_bus *bus)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_build_controls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_build_controls);
|
||||
|
||||
/*
|
||||
* add standard channel maps if not specified
|
||||
@ -4297,7 +4297,7 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
|
||||
|
||||
return val;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
|
||||
|
||||
static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
|
||||
int dir)
|
||||
@ -4443,7 +4443,7 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
|
||||
|
||||
/**
|
||||
* snd_hda_is_supported_format - Check the validity of the format
|
||||
@ -4510,7 +4510,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
|
||||
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
|
||||
|
||||
/*
|
||||
* PCM stuff
|
||||
@ -4588,7 +4588,7 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->bus->prepare_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
|
||||
|
||||
void snd_hda_codec_cleanup(struct hda_codec *codec,
|
||||
struct hda_pcm_stream *hinfo,
|
||||
@ -4598,7 +4598,7 @@ void snd_hda_codec_cleanup(struct hda_codec *codec,
|
||||
hinfo->ops.cleanup(hinfo, codec, substream);
|
||||
mutex_unlock(&codec->bus->prepare_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
|
||||
|
||||
/* global */
|
||||
const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
|
||||
@ -4756,7 +4756,7 @@ int snd_hda_build_pcms(struct hda_bus *bus)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
|
||||
|
||||
/**
|
||||
* snd_hda_check_board_config - compare the current codec with the config table
|
||||
@ -4812,7 +4812,7 @@ int snd_hda_check_board_config(struct hda_codec *codec,
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
|
||||
|
||||
/**
|
||||
* snd_hda_check_board_codec_sid_config - compare the current codec
|
||||
@ -4873,7 +4873,7 @@ int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_check_board_codec_sid_config);
|
||||
|
||||
/**
|
||||
* snd_hda_add_new_ctls - create controls from the array
|
||||
@ -4923,7 +4923,7 @@ int snd_hda_add_new_ctls(struct hda_codec *codec,
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static void hda_power_work(struct work_struct *work)
|
||||
@ -5045,7 +5045,7 @@ void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
|
||||
__snd_hda_power_down(codec);
|
||||
spin_unlock(&codec->power_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_power_save);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_power_save);
|
||||
|
||||
/**
|
||||
* snd_hda_check_amp_list_power - Check the amp list and update the power
|
||||
@ -5095,7 +5095,7 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec,
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -5119,7 +5119,7 @@ int snd_hda_ch_mode_info(struct hda_codec *codec,
|
||||
chmode[uinfo->value.enumerated.item].channels);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
|
||||
|
||||
/**
|
||||
* snd_hda_ch_mode_get - Get callback helper for the channel mode enum
|
||||
@ -5140,7 +5140,7 @@ int snd_hda_ch_mode_get(struct hda_codec *codec,
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
|
||||
|
||||
/**
|
||||
* snd_hda_ch_mode_put - Put callback helper for the channel mode enum
|
||||
@ -5164,7 +5164,7 @@ int snd_hda_ch_mode_put(struct hda_codec *codec,
|
||||
snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
|
||||
|
||||
/*
|
||||
* input MUX helper
|
||||
@ -5189,7 +5189,7 @@ int snd_hda_input_mux_info(const struct hda_input_mux *imux,
|
||||
strcpy(uinfo->value.enumerated.name, imux->items[index].label);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
|
||||
|
||||
/**
|
||||
* snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
|
||||
@ -5214,7 +5214,7 @@ int snd_hda_input_mux_put(struct hda_codec *codec,
|
||||
*cur_val = idx;
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
|
||||
|
||||
|
||||
/*
|
||||
@ -5243,7 +5243,7 @@ int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
|
||||
texts[uinfo->value.enumerated.item]);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
|
||||
|
||||
/*
|
||||
* Multi-channel / digital-out PCM helper functions
|
||||
@ -5309,7 +5309,7 @@ void snd_hda_bus_reboot_notify(struct hda_bus *bus)
|
||||
codec->patch_ops.reboot_notify(codec);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
|
||||
@ -5325,7 +5325,7 @@ int snd_hda_multi_out_dig_open(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_dig_prepare - prepare the digital out stream
|
||||
@ -5341,7 +5341,7 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
|
||||
@ -5354,7 +5354,7 @@ int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_dig_close - release the digital out stream
|
||||
@ -5367,7 +5367,7 @@ int snd_hda_multi_out_dig_close(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_analog_open - open analog outputs
|
||||
@ -5417,7 +5417,7 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
|
||||
return snd_pcm_hw_constraint_step(substream->runtime, 0,
|
||||
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
|
||||
@ -5494,7 +5494,7 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
|
||||
|
||||
/**
|
||||
* snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
|
||||
@ -5525,7 +5525,7 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
|
||||
|
||||
/**
|
||||
* snd_hda_get_default_vref - Get the default (mic) VREF pin bits
|
||||
@ -5552,7 +5552,7 @@ unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
|
||||
return AC_PINCTL_VREF_GRD;
|
||||
return AC_PINCTL_VREF_HIZ;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
|
||||
|
||||
/* correct the pin ctl value for matching with the pin cap */
|
||||
unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
|
||||
@ -5603,7 +5603,7 @@ unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
|
||||
|
||||
return val;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
|
||||
|
||||
int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
|
||||
unsigned int val, bool cached)
|
||||
@ -5617,7 +5617,7 @@ int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
|
||||
return snd_hda_codec_write(codec, pin, 0,
|
||||
AC_VERB_SET_PIN_WIDGET_CONTROL, val);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
|
||||
EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
|
||||
|
||||
/**
|
||||
* snd_hda_add_imux_item - Add an item to input_mux
|
||||
@ -5651,7 +5651,7 @@ int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
|
||||
imux->num_items++;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
|
||||
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
@ -5697,7 +5697,7 @@ int snd_hda_suspend(struct hda_bus *bus)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_suspend);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_suspend);
|
||||
|
||||
/**
|
||||
* snd_hda_resume - resume the codecs
|
||||
@ -5722,7 +5722,7 @@ int snd_hda_resume(struct hda_bus *bus)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_resume);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_resume);
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
/*
|
||||
@ -5756,7 +5756,7 @@ void *snd_array_new(struct snd_array *array)
|
||||
}
|
||||
return snd_array_elem(array, array->used++);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_array_new);
|
||||
EXPORT_SYMBOL_GPL(snd_array_new);
|
||||
|
||||
/**
|
||||
* snd_array_free - free the given array elements
|
||||
@ -5769,7 +5769,7 @@ void snd_array_free(struct snd_array *array)
|
||||
array->alloced = 0;
|
||||
array->list = NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_array_free);
|
||||
EXPORT_SYMBOL_GPL(snd_array_free);
|
||||
|
||||
/**
|
||||
* snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
|
||||
@ -5790,7 +5790,7 @@ void snd_print_pcm_bits(int pcm, char *buf, int buflen)
|
||||
|
||||
buf[j] = '\0'; /* necessary when j == 0 */
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
|
||||
EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
|
||||
|
||||
MODULE_DESCRIPTION("HDA codec core");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
@ -48,7 +48,7 @@ int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
|
||||
mutex_init(&spec->pcm_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
|
||||
|
||||
struct snd_kcontrol_new *
|
||||
snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
|
||||
@ -66,7 +66,7 @@ snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
|
||||
return NULL;
|
||||
return knew;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
|
||||
|
||||
static void free_kctls(struct hda_gen_spec *spec)
|
||||
{
|
||||
@ -87,7 +87,7 @@ void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
|
||||
snd_array_free(&spec->paths);
|
||||
snd_array_free(&spec->loopback_list);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_spec_free);
|
||||
|
||||
/*
|
||||
* store user hints
|
||||
@ -267,7 +267,7 @@ struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
|
||||
{
|
||||
return get_nid_path(codec, from_nid, to_nid, 0);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_nid_path);
|
||||
|
||||
/* get the index number corresponding to the path instance;
|
||||
* the index starts from 1, for easier checking the invalid value
|
||||
@ -285,7 +285,7 @@ int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
|
||||
return 0;
|
||||
return idx + 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_path_idx);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
|
||||
|
||||
/* get the path instance corresponding to the given index number */
|
||||
struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
|
||||
@ -296,7 +296,7 @@ struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
|
||||
return NULL;
|
||||
return snd_array_elem(&spec->paths, idx - 1);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
|
||||
|
||||
/* check whether the given DAC is already found in any existing paths */
|
||||
static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
|
||||
@ -433,7 +433,7 @@ bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
|
||||
}
|
||||
return false;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_parse_nid_path);
|
||||
|
||||
/*
|
||||
* parse the path between the given NIDs and add to the path list.
|
||||
@ -464,7 +464,7 @@ snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
|
||||
spec->paths.used--;
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
|
||||
|
||||
/* clear the given path as invalid so that it won't be picked up later */
|
||||
static void invalidate_nid_path(struct hda_codec *codec, int idx)
|
||||
@ -774,7 +774,7 @@ void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
|
||||
if (enable)
|
||||
path->active = true;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_activate_path);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_activate_path);
|
||||
|
||||
/* if the given path is inactive, put widgets into D3 (only if suitable) */
|
||||
static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
|
||||
@ -1150,7 +1150,7 @@ const struct badness_table hda_main_out_badness = {
|
||||
.shared_clfe = BAD_SHARED_CLFE,
|
||||
.shared_surr_main = BAD_SHARED_SURROUND,
|
||||
};
|
||||
EXPORT_SYMBOL_HDA(hda_main_out_badness);
|
||||
EXPORT_SYMBOL_GPL(hda_main_out_badness);
|
||||
|
||||
const struct badness_table hda_extra_out_badness = {
|
||||
.no_primary_dac = BAD_NO_DAC,
|
||||
@ -1160,7 +1160,7 @@ const struct badness_table hda_extra_out_badness = {
|
||||
.shared_clfe = BAD_SHARED_EXTRA_SURROUND,
|
||||
.shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
|
||||
};
|
||||
EXPORT_SYMBOL_HDA(hda_extra_out_badness);
|
||||
EXPORT_SYMBOL_GPL(hda_extra_out_badness);
|
||||
|
||||
/* get the DAC of the primary output corresponding to the given array index */
|
||||
static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
|
||||
@ -3921,7 +3921,7 @@ void snd_hda_gen_update_outputs(struct hda_codec *codec)
|
||||
do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
|
||||
spec->autocfg.line_out_pins, paths, on);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
|
||||
|
||||
static void call_update_outputs(struct hda_codec *codec)
|
||||
{
|
||||
@ -3954,7 +3954,7 @@ void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
|
||||
return;
|
||||
call_update_outputs(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
|
||||
|
||||
/* standard line-out-automute helper */
|
||||
void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
|
||||
@ -3974,7 +3974,7 @@ void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jac
|
||||
return;
|
||||
call_update_outputs(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
|
||||
|
||||
/* standard mic auto-switch helper */
|
||||
void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
|
||||
@ -3997,7 +3997,7 @@ void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *ja
|
||||
}
|
||||
mux_select(codec, 0, spec->am_entry[0].idx);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
|
||||
|
||||
/* call appropriate hooks */
|
||||
static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
|
||||
@ -4513,7 +4513,7 @@ int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
|
||||
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
|
||||
|
||||
|
||||
/*
|
||||
@ -4595,7 +4595,7 @@ int snd_hda_gen_build_controls(struct hda_codec *codec)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
|
||||
|
||||
|
||||
/*
|
||||
@ -5128,7 +5128,7 @@ int snd_hda_gen_build_pcms(struct hda_codec *codec)
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
|
||||
|
||||
|
||||
/*
|
||||
@ -5339,7 +5339,7 @@ int snd_hda_gen_init(struct hda_codec *codec)
|
||||
hda_call_check_power_status(codec, 0x01);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_init);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_init);
|
||||
|
||||
/*
|
||||
* free the generic spec;
|
||||
@ -5352,7 +5352,7 @@ void snd_hda_gen_free(struct hda_codec *codec)
|
||||
kfree(codec->spec);
|
||||
codec->spec = NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_free);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_free);
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
/*
|
||||
@ -5364,7 +5364,7 @@ int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
|
||||
struct hda_gen_spec *spec = codec->spec;
|
||||
return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
|
||||
#endif
|
||||
|
||||
|
||||
@ -5409,7 +5409,7 @@ int snd_hda_parse_generic_codec(struct hda_codec *codec)
|
||||
snd_hda_gen_free(codec);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_parse_generic_codec);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Generic HD-audio codec parser");
|
||||
|
||||
@ -616,7 +616,7 @@ const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
|
||||
struct hda_hint *hint = get_hint(codec, key);
|
||||
return hint ? hint->val : NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_hint);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_hint);
|
||||
|
||||
int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
|
||||
{
|
||||
@ -642,7 +642,7 @@ int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_bool_hint);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_bool_hint);
|
||||
|
||||
int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
|
||||
{
|
||||
@ -663,7 +663,7 @@ int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_int_hint);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_int_hint);
|
||||
#endif /* CONFIG_SND_HDA_RECONFIG */
|
||||
|
||||
#ifdef CONFIG_SND_HDA_PATCH_LOADER
|
||||
@ -851,5 +851,5 @@ int snd_hda_load_patch(struct hda_bus *bus, size_t fw_size, const void *fw_buf)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_load_patch);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_load_patch);
|
||||
#endif /* CONFIG_SND_HDA_PATCH_LOADER */
|
||||
|
||||
@ -34,7 +34,7 @@ bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(is_jack_detectable);
|
||||
EXPORT_SYMBOL_GPL(is_jack_detectable);
|
||||
|
||||
/* execute pin sense measurement */
|
||||
static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
|
||||
@ -71,7 +71,7 @@ snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
|
||||
return jack;
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
|
||||
@ -89,7 +89,7 @@ snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
|
||||
return jack;
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_tbl_new - create a jack-table entry for the given NID
|
||||
@ -108,7 +108,7 @@ snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
|
||||
jack->tag = codec->jacktbl.used;
|
||||
return jack;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_new);
|
||||
|
||||
void snd_hda_jack_tbl_clear(struct hda_codec *codec)
|
||||
{
|
||||
@ -172,7 +172,7 @@ void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
|
||||
if (jack->nid)
|
||||
jack->jack_dirty = 1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
|
||||
|
||||
/**
|
||||
* snd_hda_pin_sense - execute pin sense measurement
|
||||
@ -191,7 +191,7 @@ u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
|
||||
}
|
||||
return read_pin_sense(codec, nid);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_pin_sense);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_detect_state - query pin Presence Detect status
|
||||
@ -211,7 +211,7 @@ int snd_hda_jack_detect_state(struct hda_codec *codec, hda_nid_t nid)
|
||||
else
|
||||
return HDA_JACK_NOT_PRESENT;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_detect_state);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_detect_enable - enable the jack-detection
|
||||
@ -236,14 +236,14 @@ int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
|
||||
AC_VERB_SET_UNSOLICITED_ENABLE,
|
||||
AC_USRSP_EN | jack->tag);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback);
|
||||
|
||||
int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
|
||||
unsigned char action)
|
||||
{
|
||||
return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_set_gating_jack - Set gating jack.
|
||||
@ -264,7 +264,7 @@ int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_set_gating_jack);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
|
||||
|
||||
/**
|
||||
* snd_hda_jack_report_sync - sync the states of all jacks and report if changed
|
||||
@ -297,7 +297,7 @@ void snd_hda_jack_report_sync(struct hda_codec *codec)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
|
||||
|
||||
#ifdef CONFIG_SND_HDA_INPUT_JACK
|
||||
/* guess the jack type from the pin-config */
|
||||
@ -377,7 +377,7 @@ int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
|
||||
{
|
||||
return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl);
|
||||
|
||||
/* get the unique index number for the given kctl name */
|
||||
static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
|
||||
@ -493,7 +493,7 @@ int snd_hda_jack_add_kctls(struct hda_codec *codec,
|
||||
return err;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
|
||||
|
||||
static void call_jack_callback(struct hda_codec *codec,
|
||||
struct hda_jack_tbl *jack)
|
||||
@ -521,7 +521,7 @@ void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
|
||||
call_jack_callback(codec, event);
|
||||
snd_hda_jack_report_sync(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
|
||||
|
||||
void snd_hda_jack_poll_all(struct hda_codec *codec)
|
||||
{
|
||||
@ -542,5 +542,5 @@ void snd_hda_jack_poll_all(struct hda_codec *codec)
|
||||
if (changes)
|
||||
snd_hda_jack_report_sync(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_jack_poll_all);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
|
||||
|
||||
|
||||
@ -3217,7 +3217,7 @@ int snd_hda_parse_hdmi_codec(struct hda_codec *codec)
|
||||
{
|
||||
return patch_generic_hdmi(codec);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_parse_hdmi_codec);
|
||||
EXPORT_SYMBOL_GPL(snd_hda_parse_hdmi_codec);
|
||||
|
||||
/*
|
||||
* patch entries
|
||||
|
||||
Loading…
Reference in New Issue
Block a user