aboutsummaryrefslogtreecommitdiffstats
path: root/sound
diff options
context:
space:
mode:
authorTakashi Iwai <tiwai@suse.de>2013-12-18 01:45:52 -0500
committerTakashi Iwai <tiwai@suse.de>2013-12-19 08:36:19 -0500
commit2698ea98059bb01a9b5d9cfd20e23d55f68c0a17 (patch)
tree1d4ade3359fe48565f5c1799590ed9379252d9b5 /sound
parent595fe1b702c3fa739ab395ab0471054875f20b90 (diff)
ALSA: hda - Kill EXPORT_SYMBOL_HDA()
Replace all with the standard EXPORT_SYMBOL_GPL(). Signed-off-by: Takashi Iwai <tiwai@suse.de>
Diffstat (limited to 'sound')
-rw-r--r--sound/pci/hda/hda_auto_parser.c18
-rw-r--r--sound/pci/hda/hda_beep.c10
-rw-r--r--sound/pci/hda/hda_codec.c214
-rw-r--r--sound/pci/hda/hda_generic.c44
-rw-r--r--sound/pci/hda/hda_hwdep.c8
-rw-r--r--sound/pci/hda/hda_jack.c30
-rw-r--r--sound/pci/hda/patch_hdmi.c2
7 files changed, 163 insertions, 163 deletions
diff --git a/sound/pci/hda/hda_auto_parser.c b/sound/pci/hda/hda_auto_parser.c
index 853c6a69e29e..47ad31c6aa70 100644
--- a/sound/pci/hda/hda_auto_parser.c
+++ b/sound/pci/hda/hda_auto_parser.c
@@ -414,7 +414,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
414 414
415 return 0; 415 return 0;
416} 416}
417EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg); 417EXPORT_SYMBOL_GPL(snd_hda_parse_pin_defcfg);
418 418
419int snd_hda_get_input_pin_attr(unsigned int def_conf) 419int snd_hda_get_input_pin_attr(unsigned int def_conf)
420{ 420{
@@ -435,7 +435,7 @@ int snd_hda_get_input_pin_attr(unsigned int def_conf)
435 return INPUT_PIN_ATTR_FRONT; 435 return INPUT_PIN_ATTR_FRONT;
436 return INPUT_PIN_ATTR_NORMAL; 436 return INPUT_PIN_ATTR_NORMAL;
437} 437}
438EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr); 438EXPORT_SYMBOL_GPL(snd_hda_get_input_pin_attr);
439 439
440/** 440/**
441 * hda_get_input_pin_label - Give a label for the given input pin 441 * 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,
547 cfg->inputs[input].pin, 547 cfg->inputs[input].pin,
548 has_multiple_pins); 548 has_multiple_pins);
549} 549}
550EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label); 550EXPORT_SYMBOL_GPL(hda_get_autocfg_input_label);
551 551
552/* return the position of NID in the list, or -1 if not found */ 552/* return the position of NID in the list, or -1 if not found */
553static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 553static 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,
721 strlcpy(label, name, maxlen); 721 strlcpy(label, name, maxlen);
722 return 1; 722 return 1;
723} 723}
724EXPORT_SYMBOL_HDA(snd_hda_get_pin_label); 724EXPORT_SYMBOL_GPL(snd_hda_get_pin_label);
725 725
726int snd_hda_add_verbs(struct hda_codec *codec, 726int snd_hda_add_verbs(struct hda_codec *codec,
727 const struct hda_verb *list) 727 const struct hda_verb *list)
@@ -733,7 +733,7 @@ int snd_hda_add_verbs(struct hda_codec *codec,
733 *v = list; 733 *v = list;
734 return 0; 734 return 0;
735} 735}
736EXPORT_SYMBOL_HDA(snd_hda_add_verbs); 736EXPORT_SYMBOL_GPL(snd_hda_add_verbs);
737 737
738void snd_hda_apply_verbs(struct hda_codec *codec) 738void snd_hda_apply_verbs(struct hda_codec *codec)
739{ 739{
@@ -743,7 +743,7 @@ void snd_hda_apply_verbs(struct hda_codec *codec)
743 snd_hda_sequence_write(codec, *v); 743 snd_hda_sequence_write(codec, *v);
744 } 744 }
745} 745}
746EXPORT_SYMBOL_HDA(snd_hda_apply_verbs); 746EXPORT_SYMBOL_GPL(snd_hda_apply_verbs);
747 747
748void snd_hda_apply_pincfgs(struct hda_codec *codec, 748void snd_hda_apply_pincfgs(struct hda_codec *codec,
749 const struct hda_pintbl *cfg) 749 const struct hda_pintbl *cfg)
@@ -751,7 +751,7 @@ void snd_hda_apply_pincfgs(struct hda_codec *codec,
751 for (; cfg->nid; cfg++) 751 for (; cfg->nid; cfg++)
752 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val); 752 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
753} 753}
754EXPORT_SYMBOL_HDA(snd_hda_apply_pincfgs); 754EXPORT_SYMBOL_GPL(snd_hda_apply_pincfgs);
755 755
756static void set_pin_targets(struct hda_codec *codec, 756static void set_pin_targets(struct hda_codec *codec,
757 const struct hda_pintbl *cfg) 757 const struct hda_pintbl *cfg)
@@ -822,7 +822,7 @@ void snd_hda_apply_fixup(struct hda_codec *codec, int action)
822 if (codec->fixup_list) 822 if (codec->fixup_list)
823 apply_fixup(codec, codec->fixup_id, action, 0); 823 apply_fixup(codec, codec->fixup_id, action, 0);
824} 824}
825EXPORT_SYMBOL_HDA(snd_hda_apply_fixup); 825EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);
826 826
827void snd_hda_pick_fixup(struct hda_codec *codec, 827void snd_hda_pick_fixup(struct hda_codec *codec,
828 const struct hda_model_fixup *models, 828 const struct hda_model_fixup *models,
@@ -880,4 +880,4 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
880 codec->fixup_name = name; 880 codec->fixup_name = name;
881 } 881 }
882} 882}
883EXPORT_SYMBOL_HDA(snd_hda_pick_fixup); 883EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 98bce9830be0..0589b39cda6e 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -194,7 +194,7 @@ int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
194 } 194 }
195 return 0; 195 return 0;
196} 196}
197EXPORT_SYMBOL_HDA(snd_hda_enable_beep_device); 197EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
198 198
199int snd_hda_attach_beep_device(struct hda_codec *codec, int nid) 199int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
200{ 200{
@@ -231,7 +231,7 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
231 231
232 return 0; 232 return 0;
233} 233}
234EXPORT_SYMBOL_HDA(snd_hda_attach_beep_device); 234EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
235 235
236void snd_hda_detach_beep_device(struct hda_codec *codec) 236void snd_hda_detach_beep_device(struct hda_codec *codec)
237{ 237{
@@ -243,7 +243,7 @@ void snd_hda_detach_beep_device(struct hda_codec *codec)
243 kfree(beep); 243 kfree(beep);
244 } 244 }
245} 245}
246EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device); 246EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
247 247
248static bool ctl_has_mute(struct snd_kcontrol *kcontrol) 248static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
249{ 249{
@@ -265,7 +265,7 @@ int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
265 } 265 }
266 return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); 266 return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
267} 267}
268EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get_beep); 268EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep);
269 269
270int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, 270int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
271 struct snd_ctl_elem_value *ucontrol) 271 struct snd_ctl_elem_value *ucontrol)
@@ -288,4 +288,4 @@ int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
288 return 0; 288 return 0;
289 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 289 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
290} 290}
291EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep); 291EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep);
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 2e090c8d7144..ab2a991d916f 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -84,7 +84,7 @@ int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
84 mutex_unlock(&preset_mutex); 84 mutex_unlock(&preset_mutex);
85 return 0; 85 return 0;
86} 86}
87EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset); 87EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
88 88
89int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset) 89int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
90{ 90{
@@ -93,7 +93,7 @@ int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
93 mutex_unlock(&preset_mutex); 93 mutex_unlock(&preset_mutex);
94 return 0; 94 return 0;
95} 95}
96EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset); 96EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
97 97
98#ifdef CONFIG_PM 98#ifdef CONFIG_PM
99#define codec_in_pm(codec) ((codec)->in_pm) 99#define codec_in_pm(codec) ((codec)->in_pm)
@@ -152,7 +152,7 @@ const char *snd_hda_get_jack_location(u32 cfg)
152 } 152 }
153 return "UNKNOWN"; 153 return "UNKNOWN";
154} 154}
155EXPORT_SYMBOL_HDA(snd_hda_get_jack_location); 155EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
156 156
157/** 157/**
158 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack 158 * 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)
167 167
168 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3]; 168 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
169} 169}
170EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity); 170EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
171 171
172/** 172/**
173 * snd_hda_get_jack_type - Give a type string of the jack 173 * 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)
188 return jack_types[(cfg & AC_DEFCFG_DEVICE) 188 return jack_types[(cfg & AC_DEFCFG_DEVICE)
189 >> AC_DEFCFG_DEVICE_SHIFT]; 189 >> AC_DEFCFG_DEVICE_SHIFT];
190} 190}
191EXPORT_SYMBOL_HDA(snd_hda_get_jack_type); 191EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
192 192
193/* 193/*
194 * Compose a 32bit command word to be sent to the HD-audio controller 194 * 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,
284 return -1; 284 return -1;
285 return res; 285 return res;
286} 286}
287EXPORT_SYMBOL_HDA(snd_hda_codec_read); 287EXPORT_SYMBOL_GPL(snd_hda_codec_read);
288 288
289/** 289/**
290 * snd_hda_codec_write - send a single command without waiting for response 290 * 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,
306 return codec_exec_verb(codec, cmd, flags, 306 return codec_exec_verb(codec, cmd, flags,
307 codec->bus->sync_write ? &res : NULL); 307 codec->bus->sync_write ? &res : NULL);
308} 308}
309EXPORT_SYMBOL_HDA(snd_hda_codec_write); 309EXPORT_SYMBOL_GPL(snd_hda_codec_write);
310 310
311/** 311/**
312 * snd_hda_sequence_write - sequence writes 312 * snd_hda_sequence_write - sequence writes
@@ -321,7 +321,7 @@ void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
321 for (; seq->nid; seq++) 321 for (; seq->nid; seq++)
322 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param); 322 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
323} 323}
324EXPORT_SYMBOL_HDA(snd_hda_sequence_write); 324EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
325 325
326/** 326/**
327 * snd_hda_get_sub_nodes - get the range of sub nodes 327 * 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,
343 *start_id = (parm >> 16) & 0x7fff; 343 *start_id = (parm >> 16) & 0x7fff;
344 return (int)(parm & 0x7fff); 344 return (int)(parm & 0x7fff);
345} 345}
346EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes); 346EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
347 347
348/* connection list element */ 348/* connection list element */
349struct hda_conn_list { 349struct hda_conn_list {
@@ -453,7 +453,7 @@ int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
453 added = true; 453 added = true;
454 } 454 }
455} 455}
456EXPORT_SYMBOL_HDA(snd_hda_get_conn_list); 456EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
457 457
458/** 458/**
459 * snd_hda_get_connections - copy connection list 459 * snd_hda_get_connections - copy connection list
@@ -485,7 +485,7 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
485 485
486 return len; 486 return len;
487} 487}
488EXPORT_SYMBOL_HDA(snd_hda_get_connections); 488EXPORT_SYMBOL_GPL(snd_hda_get_connections);
489 489
490/* return CONNLIST_LEN parameter of the given widget */ 490/* return CONNLIST_LEN parameter of the given widget */
491static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid) 491static 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,
634 634
635 return add_conn_list(codec, nid, len, list); 635 return add_conn_list(codec, nid, len, list);
636} 636}
637EXPORT_SYMBOL_HDA(snd_hda_override_conn_list); 637EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
638 638
639/** 639/**
640 * snd_hda_get_conn_index - get the connection index of the given NID 640 * 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,
673 } 673 }
674 return -1; 674 return -1;
675} 675}
676EXPORT_SYMBOL_HDA(snd_hda_get_conn_index); 676EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
677 677
678 678
679/* return DEVLIST_LEN parameter of the given widget */ 679/* 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)
769 769
770 return 0; 770 return 0;
771} 771}
772EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event); 772EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
773 773
774/* 774/*
775 * process queued unsolicited events 775 * process queued unsolicited events
@@ -930,7 +930,7 @@ int snd_hda_bus_new(struct snd_card *card,
930 *busp = bus; 930 *busp = bus;
931 return 0; 931 return 0;
932} 932}
933EXPORT_SYMBOL_HDA(snd_hda_bus_new); 933EXPORT_SYMBOL_GPL(snd_hda_bus_new);
934 934
935#ifdef CONFIG_SND_HDA_GENERIC 935#ifdef CONFIG_SND_HDA_GENERIC
936#define is_generic_config(codec) \ 936#define is_generic_config(codec) \
@@ -1170,7 +1170,7 @@ int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1170{ 1170{
1171 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg); 1171 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1172} 1172}
1173EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg); 1173EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
1174 1174
1175/** 1175/**
1176 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration 1176 * 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)
1205 return pin->cfg; 1205 return pin->cfg;
1206 return 0; 1206 return 0;
1207} 1207}
1208EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg); 1208EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
1209 1209
1210/* remember the current pinctl target value */ 1210/* remember the current pinctl target value */
1211int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, 1211int 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,
1219 pin->target = val; 1219 pin->target = val;
1220 return 0; 1220 return 0;
1221} 1221}
1222EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target); 1222EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
1223 1223
1224/* return the current pinctl target value */ 1224/* return the current pinctl target value */
1225int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid) 1225int 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)
1231 return 0; 1231 return 0;
1232 return pin->target; 1232 return pin->target;
1233} 1233}
1234EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target); 1234EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
1235 1235
1236/** 1236/**
1237 * snd_hda_shutup_pins - Shut up all pins 1237 * snd_hda_shutup_pins - Shut up all pins
@@ -1256,7 +1256,7 @@ void snd_hda_shutup_pins(struct hda_codec *codec)
1256 } 1256 }
1257 codec->pins_shutup = 1; 1257 codec->pins_shutup = 1;
1258} 1258}
1259EXPORT_SYMBOL_HDA(snd_hda_shutup_pins); 1259EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
1260 1260
1261#ifdef CONFIG_PM 1261#ifdef CONFIG_PM
1262/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */ 1262/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
@@ -1544,7 +1544,7 @@ int snd_hda_codec_new(struct hda_bus *bus,
1544 snd_hda_codec_free(codec); 1544 snd_hda_codec_free(codec);
1545 return err; 1545 return err;
1546} 1546}
1547EXPORT_SYMBOL_HDA(snd_hda_codec_new); 1547EXPORT_SYMBOL_GPL(snd_hda_codec_new);
1548 1548
1549int snd_hda_codec_update_widgets(struct hda_codec *codec) 1549int snd_hda_codec_update_widgets(struct hda_codec *codec)
1550{ 1550{
@@ -1567,7 +1567,7 @@ int snd_hda_codec_update_widgets(struct hda_codec *codec)
1567 1567
1568 return err; 1568 return err;
1569} 1569}
1570EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets); 1570EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1571 1571
1572 1572
1573#ifdef CONFIG_SND_HDA_CODEC_HDMI 1573#ifdef CONFIG_SND_HDA_CODEC_HDMI
@@ -1651,7 +1651,7 @@ int snd_hda_codec_configure(struct hda_codec *codec)
1651 "%s %s", codec->vendor_name, codec->chip_name); 1651 "%s %s", codec->vendor_name, codec->chip_name);
1652 return 0; 1652 return 0;
1653} 1653}
1654EXPORT_SYMBOL_HDA(snd_hda_codec_configure); 1654EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
1655 1655
1656/* update the stream-id if changed */ 1656/* update the stream-id if changed */
1657static void update_pcm_stream_id(struct hda_codec *codec, 1657static 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,
1738 } 1738 }
1739 } 1739 }
1740} 1740}
1741EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream); 1741EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1742 1742
1743static void really_cleanup_stream(struct hda_codec *codec, 1743static void really_cleanup_stream(struct hda_codec *codec,
1744 struct hda_cvt_setup *q); 1744 struct hda_cvt_setup *q);
@@ -1773,7 +1773,7 @@ void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1773 p->active = 0; 1773 p->active = 0;
1774 } 1774 }
1775} 1775}
1776EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream); 1776EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1777 1777
1778static void really_cleanup_stream(struct hda_codec *codec, 1778static void really_cleanup_stream(struct hda_codec *codec,
1779 struct hda_cvt_setup *q) 1779 struct hda_cvt_setup *q)
@@ -1961,7 +1961,7 @@ u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1961 HDA_HASH_KEY(nid, direction, 0), 1961 HDA_HASH_KEY(nid, direction, 0),
1962 read_amp_cap); 1962 read_amp_cap);
1963} 1963}
1964EXPORT_SYMBOL_HDA(query_amp_caps); 1964EXPORT_SYMBOL_GPL(query_amp_caps);
1965 1965
1966/** 1966/**
1967 * snd_hda_override_amp_caps - Override the AMP capabilities 1967 * 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,
1981{ 1981{
1982 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps); 1982 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1983} 1983}
1984EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps); 1984EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1985 1985
1986static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid, 1986static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1987 int dir) 1987 int dir)
@@ -2005,7 +2005,7 @@ u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
2005 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid), 2005 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
2006 read_pin_cap); 2006 read_pin_cap);
2007} 2007}
2008EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps); 2008EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
2009 2009
2010/** 2010/**
2011 * snd_hda_override_pin_caps - Override the pin capabilities 2011 * 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,
2022{ 2022{
2023 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps); 2023 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
2024} 2024}
2025EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps); 2025EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
2026 2026
2027/* read or sync the hash value with the current value; 2027/* read or sync the hash value with the current value;
2028 * call within hash_mutex 2028 * call within hash_mutex
@@ -2103,7 +2103,7 @@ int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2103 mutex_unlock(&codec->hash_mutex); 2103 mutex_unlock(&codec->hash_mutex);
2104 return val; 2104 return val;
2105} 2105}
2106EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read); 2106EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
2107 2107
2108static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 2108static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2109 int direction, int idx, int mask, int val, 2109 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,
2155{ 2155{
2156 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false); 2156 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2157} 2157}
2158EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update); 2158EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
2159 2159
2160/** 2160/**
2161 * snd_hda_codec_amp_stereo - update the AMP stereo values 2161 * 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,
2181 idx, mask, val); 2181 idx, mask, val);
2182 return ret; 2182 return ret;
2183} 2183}
2184EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo); 2184EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
2185 2185
2186/* Works like snd_hda_codec_amp_update() but it writes the value only at 2186/* Works like snd_hda_codec_amp_update() but it writes the value only at
2187 * the first access. If the amp was already initialized / updated beforehand, 2187 * 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,
2192{ 2192{
2193 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true); 2193 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2194} 2194}
2195EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init); 2195EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
2196 2196
2197int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid, 2197int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2198 int dir, int idx, int mask, int val) 2198 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,
2206 idx, mask, val); 2206 idx, mask, val);
2207 return ret; 2207 return ret;
2208} 2208}
2209EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo); 2209EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
2210 2210
2211/** 2211/**
2212 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache 2212 * 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)
2249 } 2249 }
2250 mutex_unlock(&codec->hash_mutex); 2250 mutex_unlock(&codec->hash_mutex);
2251} 2251}
2252EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp); 2252EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
2253 2253
2254static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir, 2254static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2255 unsigned int ofs) 2255 unsigned int ofs)
@@ -2289,7 +2289,7 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2289 } 2289 }
2290 return 0; 2290 return 0;
2291} 2291}
2292EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info); 2292EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
2293 2293
2294 2294
2295static inline unsigned int 2295static inline unsigned int
@@ -2346,7 +2346,7 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2346 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs); 2346 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2347 return 0; 2347 return 0;
2348} 2348}
2349EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get); 2349EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
2350 2350
2351/** 2351/**
2352 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume 2352 * 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,
2376 snd_hda_power_down(codec); 2376 snd_hda_power_down(codec);
2377 return change; 2377 return change;
2378} 2378}
2379EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put); 2379EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
2380 2380
2381/** 2381/**
2382 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume 2382 * 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,
2414 return -EFAULT; 2414 return -EFAULT;
2415 return 0; 2415 return 0;
2416} 2416}
2417EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv); 2417EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
2418 2418
2419/** 2419/**
2420 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control 2420 * 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,
2442 tlv[2] = -nums * step; 2442 tlv[2] = -nums * step;
2443 tlv[3] = step; 2443 tlv[3] = step;
2444} 2444}
2445EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv); 2445EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
2446 2446
2447/* find a mixer control element with the given name */ 2447/* find a mixer control element with the given name */
2448static struct snd_kcontrol * 2448static struct snd_kcontrol *
@@ -2471,7 +2471,7 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2471{ 2471{
2472 return find_mixer_ctl(codec, name, 0, 0); 2472 return find_mixer_ctl(codec, name, 0, 0);
2473} 2473}
2474EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl); 2474EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
2475 2475
2476static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name, 2476static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2477 int start_idx) 2477 int start_idx)
@@ -2531,7 +2531,7 @@ int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2531 item->flags = flags; 2531 item->flags = flags;
2532 return 0; 2532 return 0;
2533} 2533}
2534EXPORT_SYMBOL_HDA(snd_hda_ctl_add); 2534EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
2535 2535
2536/** 2536/**
2537 * snd_hda_add_nid - Assign a NID to a control element 2537 * 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,
2562 kctl->id.name, kctl->id.index, index); 2562 kctl->id.name, kctl->id.index, index);
2563 return -EINVAL; 2563 return -EINVAL;
2564} 2564}
2565EXPORT_SYMBOL_HDA(snd_hda_add_nid); 2565EXPORT_SYMBOL_GPL(snd_hda_add_nid);
2566 2566
2567/** 2567/**
2568 * snd_hda_ctls_clear - Clear all controls assigned to the given codec 2568 * 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)
2613 spin_unlock(&card->files_lock); 2613 spin_unlock(&card->files_lock);
2614 return -EINVAL; 2614 return -EINVAL;
2615} 2615}
2616EXPORT_SYMBOL_HDA(snd_hda_lock_devices); 2616EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
2617 2617
2618void snd_hda_unlock_devices(struct hda_bus *bus) 2618void snd_hda_unlock_devices(struct hda_bus *bus)
2619{ 2619{
@@ -2624,7 +2624,7 @@ void snd_hda_unlock_devices(struct hda_bus *bus)
2624 card->shutdown = 0; 2624 card->shutdown = 0;
2625 spin_unlock(&card->files_lock); 2625 spin_unlock(&card->files_lock);
2626} 2626}
2627EXPORT_SYMBOL_HDA(snd_hda_unlock_devices); 2627EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
2628 2628
2629/** 2629/**
2630 * snd_hda_codec_reset - Clear all objects assigned to the codec 2630 * 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,
2848 *ctl_ret = kctl; 2848 *ctl_ret = kctl;
2849 return 0; 2849 return 0;
2850} 2850}
2851EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster); 2851EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2852 2852
2853/* 2853/*
2854 * mute-LED control using vmaster 2854 * mute-LED control using vmaster
@@ -2925,7 +2925,7 @@ int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2925 return -ENOMEM; 2925 return -ENOMEM;
2926 return snd_hda_ctl_add(codec, 0, kctl); 2926 return snd_hda_ctl_add(codec, 0, kctl);
2927} 2927}
2928EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook); 2928EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2929 2929
2930/* 2930/*
2931 * Call the hook with the current value for synchronization 2931 * 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)
2949 break; 2949 break;
2950 } 2950 }
2951} 2951}
2952EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook); 2952EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2953 2953
2954 2954
2955/** 2955/**
@@ -2969,7 +2969,7 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2969 uinfo->value.integer.max = 1; 2969 uinfo->value.integer.max = 1;
2970 return 0; 2970 return 0;
2971} 2971}
2972EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info); 2972EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2973 2973
2974/** 2974/**
2975 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch 2975 * 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,
2995 HDA_AMP_MUTE) ? 0 : 1; 2995 HDA_AMP_MUTE) ? 0 : 1;
2996 return 0; 2996 return 0;
2997} 2997}
2998EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get); 2998EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
2999 2999
3000/** 3000/**
3001 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch 3001 * 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,
3029 snd_hda_power_down(codec); 3029 snd_hda_power_down(codec);
3030 return change; 3030 return change;
3031} 3031}
3032EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put); 3032EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
3033 3033
3034/* 3034/*
3035 * bound volume controls 3035 * bound volume controls
@@ -3061,7 +3061,7 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
3061 mutex_unlock(&codec->control_mutex); 3061 mutex_unlock(&codec->control_mutex);
3062 return err; 3062 return err;
3063} 3063}
3064EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get); 3064EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
3065 3065
3066/** 3066/**
3067 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control 3067 * 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,
3091 mutex_unlock(&codec->control_mutex); 3091 mutex_unlock(&codec->control_mutex);
3092 return err < 0 ? err : change; 3092 return err < 0 ? err : change;
3093} 3093}
3094EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put); 3094EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
3095 3095
3096/** 3096/**
3097 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control 3097 * 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,
3114 mutex_unlock(&codec->control_mutex); 3114 mutex_unlock(&codec->control_mutex);
3115 return err; 3115 return err;
3116} 3116}
3117EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info); 3117EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
3118 3118
3119/** 3119/**
3120 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control 3120 * 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,
3137 mutex_unlock(&codec->control_mutex); 3137 mutex_unlock(&codec->control_mutex);
3138 return err; 3138 return err;
3139} 3139}
3140EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get); 3140EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
3141 3141
3142/** 3142/**
3143 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control 3143 * 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,
3166 mutex_unlock(&codec->control_mutex); 3166 mutex_unlock(&codec->control_mutex);
3167 return err < 0 ? err : change; 3167 return err < 0 ? err : change;
3168} 3168}
3169EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put); 3169EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
3170 3170
3171/** 3171/**
3172 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control 3172 * 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,
3189 mutex_unlock(&codec->control_mutex); 3189 mutex_unlock(&codec->control_mutex);
3190 return err; 3190 return err;
3191} 3191}
3192EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv); 3192EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
3193 3193
3194struct hda_ctl_ops snd_hda_bind_vol = { 3194struct hda_ctl_ops snd_hda_bind_vol = {
3195 .info = snd_hda_mixer_amp_volume_info, 3195 .info = snd_hda_mixer_amp_volume_info,
@@ -3197,7 +3197,7 @@ struct hda_ctl_ops snd_hda_bind_vol = {
3197 .put = snd_hda_mixer_amp_volume_put, 3197 .put = snd_hda_mixer_amp_volume_put,
3198 .tlv = snd_hda_mixer_amp_tlv 3198 .tlv = snd_hda_mixer_amp_tlv
3199}; 3199};
3200EXPORT_SYMBOL_HDA(snd_hda_bind_vol); 3200EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
3201 3201
3202struct hda_ctl_ops snd_hda_bind_sw = { 3202struct hda_ctl_ops snd_hda_bind_sw = {
3203 .info = snd_hda_mixer_amp_switch_info, 3203 .info = snd_hda_mixer_amp_switch_info,
@@ -3205,7 +3205,7 @@ struct hda_ctl_ops snd_hda_bind_sw = {
3205 .put = snd_hda_mixer_amp_switch_put, 3205 .put = snd_hda_mixer_amp_switch_put,
3206 .tlv = snd_hda_mixer_amp_tlv 3206 .tlv = snd_hda_mixer_amp_tlv
3207}; 3207};
3208EXPORT_SYMBOL_HDA(snd_hda_bind_sw); 3208EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
3209 3209
3210/* 3210/*
3211 * SPDIF out controls 3211 * SPDIF out controls
@@ -3509,7 +3509,7 @@ int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3509 spdif->status = convert_to_spdif_status(spdif->ctls); 3509 spdif->status = convert_to_spdif_status(spdif->ctls);
3510 return 0; 3510 return 0;
3511} 3511}
3512EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls); 3512EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
3513 3513
3514/* get the hda_spdif_out entry from the given NID 3514/* get the hda_spdif_out entry from the given NID
3515 * call within spdif_mutex lock 3515 * call within spdif_mutex lock
@@ -3526,7 +3526,7 @@ struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3526 } 3526 }
3527 return NULL; 3527 return NULL;
3528} 3528}
3529EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid); 3529EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
3530 3530
3531void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx) 3531void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3532{ 3532{
@@ -3537,7 +3537,7 @@ void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3537 spdif->nid = (u16)-1; 3537 spdif->nid = (u16)-1;
3538 mutex_unlock(&codec->spdif_mutex); 3538 mutex_unlock(&codec->spdif_mutex);
3539} 3539}
3540EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign); 3540EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
3541 3541
3542void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid) 3542void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3543{ 3543{
@@ -3553,7 +3553,7 @@ void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3553 } 3553 }
3554 mutex_unlock(&codec->spdif_mutex); 3554 mutex_unlock(&codec->spdif_mutex);
3555} 3555}
3556EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign); 3556EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
3557 3557
3558/* 3558/*
3559 * SPDIF sharing with analog output 3559 * SPDIF sharing with analog output
@@ -3601,7 +3601,7 @@ int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3601 /* ATTENTION: here mout is passed as private_data, instead of codec */ 3601 /* ATTENTION: here mout is passed as private_data, instead of codec */
3602 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl); 3602 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3603} 3603}
3604EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw); 3604EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
3605 3605
3606/* 3606/*
3607 * SPDIF input 3607 * SPDIF input
@@ -3709,7 +3709,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3709 AC_DIG1_ENABLE; 3709 AC_DIG1_ENABLE;
3710 return 0; 3710 return 0;
3711} 3711}
3712EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls); 3712EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
3713 3713
3714/* 3714/*
3715 * command cache 3715 * command cache
@@ -3760,7 +3760,7 @@ int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3760 mutex_unlock(&codec->bus->cmd_mutex); 3760 mutex_unlock(&codec->bus->cmd_mutex);
3761 return 0; 3761 return 0;
3762} 3762}
3763EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache); 3763EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
3764 3764
3765/** 3765/**
3766 * snd_hda_codec_update_cache - check cache and write the cmd only when needed 3766 * 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,
3795 mutex_unlock(&codec->bus->cmd_mutex); 3795 mutex_unlock(&codec->bus->cmd_mutex);
3796 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm); 3796 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
3797} 3797}
3798EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache); 3798EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
3799 3799
3800/** 3800/**
3801 * snd_hda_codec_resume_cache - Resume the all commands from the cache 3801 * 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)
3827 } 3827 }
3828 mutex_unlock(&codec->hash_mutex); 3828 mutex_unlock(&codec->hash_mutex);
3829} 3829}
3830EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache); 3830EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
3831 3831
3832/** 3832/**
3833 * snd_hda_sequence_write_cache - sequence writes with caching 3833 * snd_hda_sequence_write_cache - sequence writes with caching
@@ -3845,7 +3845,7 @@ void snd_hda_sequence_write_cache(struct hda_codec *codec,
3845 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb, 3845 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3846 seq->param); 3846 seq->param);
3847} 3847}
3848EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache); 3848EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
3849 3849
3850/** 3850/**
3851 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs 3851 * 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)
3856 snd_hda_codec_resume_amp(codec); 3856 snd_hda_codec_resume_amp(codec);
3857 snd_hda_codec_resume_cache(codec); 3857 snd_hda_codec_resume_cache(codec);
3858} 3858}
3859EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache); 3859EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
3860 3860
3861void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg, 3861void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3862 unsigned int power_state) 3862 unsigned int power_state)
@@ -3878,7 +3878,7 @@ void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3878 state); 3878 state);
3879 } 3879 }
3880} 3880}
3881EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all); 3881EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
3882 3882
3883/* 3883/*
3884 * supported power states check 3884 * supported power states check
@@ -3937,7 +3937,7 @@ unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3937 } 3937 }
3938 return power_state; 3938 return power_state;
3939} 3939}
3940EXPORT_SYMBOL_HDA(snd_hda_codec_eapd_power_filter); 3940EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
3941 3941
3942/* 3942/*
3943 * set power state of the codec, and return the power state 3943 * set power state of the codec, and return the power state
@@ -4124,7 +4124,7 @@ int snd_hda_build_controls(struct hda_bus *bus)
4124 } 4124 }
4125 return 0; 4125 return 0;
4126} 4126}
4127EXPORT_SYMBOL_HDA(snd_hda_build_controls); 4127EXPORT_SYMBOL_GPL(snd_hda_build_controls);
4128 4128
4129/* 4129/*
4130 * add standard channel maps if not specified 4130 * add standard channel maps if not specified
@@ -4297,7 +4297,7 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
4297 4297
4298 return val; 4298 return val;
4299} 4299}
4300EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format); 4300EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
4301 4301
4302static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid, 4302static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4303 int dir) 4303 int dir)
@@ -4443,7 +4443,7 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4443 4443
4444 return 0; 4444 return 0;
4445} 4445}
4446EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm); 4446EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
4447 4447
4448/** 4448/**
4449 * snd_hda_is_supported_format - Check the validity of the format 4449 * 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,
4510 4510
4511 return 1; 4511 return 1;
4512} 4512}
4513EXPORT_SYMBOL_HDA(snd_hda_is_supported_format); 4513EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
4514 4514
4515/* 4515/*
4516 * PCM stuff 4516 * PCM stuff
@@ -4588,7 +4588,7 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
4588 mutex_unlock(&codec->bus->prepare_mutex); 4588 mutex_unlock(&codec->bus->prepare_mutex);
4589 return ret; 4589 return ret;
4590} 4590}
4591EXPORT_SYMBOL_HDA(snd_hda_codec_prepare); 4591EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
4592 4592
4593void snd_hda_codec_cleanup(struct hda_codec *codec, 4593void snd_hda_codec_cleanup(struct hda_codec *codec,
4594 struct hda_pcm_stream *hinfo, 4594 struct hda_pcm_stream *hinfo,
@@ -4598,7 +4598,7 @@ void snd_hda_codec_cleanup(struct hda_codec *codec,
4598 hinfo->ops.cleanup(hinfo, codec, substream); 4598 hinfo->ops.cleanup(hinfo, codec, substream);
4599 mutex_unlock(&codec->bus->prepare_mutex); 4599 mutex_unlock(&codec->bus->prepare_mutex);
4600} 4600}
4601EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup); 4601EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
4602 4602
4603/* global */ 4603/* global */
4604const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = { 4604const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
@@ -4756,7 +4756,7 @@ int snd_hda_build_pcms(struct hda_bus *bus)
4756 } 4756 }
4757 return 0; 4757 return 0;
4758} 4758}
4759EXPORT_SYMBOL_HDA(snd_hda_build_pcms); 4759EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
4760 4760
4761/** 4761/**
4762 * snd_hda_check_board_config - compare the current codec with the config table 4762 * 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,
4812 } 4812 }
4813 return -1; 4813 return -1;
4814} 4814}
4815EXPORT_SYMBOL_HDA(snd_hda_check_board_config); 4815EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
4816 4816
4817/** 4817/**
4818 * snd_hda_check_board_codec_sid_config - compare the current codec 4818 * 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,
4873 } 4873 }
4874 return -1; 4874 return -1;
4875} 4875}
4876EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config); 4876EXPORT_SYMBOL_GPL(snd_hda_check_board_codec_sid_config);
4877 4877
4878/** 4878/**
4879 * snd_hda_add_new_ctls - create controls from the array 4879 * snd_hda_add_new_ctls - create controls from the array
@@ -4923,7 +4923,7 @@ int snd_hda_add_new_ctls(struct hda_codec *codec,
4923 } 4923 }
4924 return 0; 4924 return 0;
4925} 4925}
4926EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls); 4926EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
4927 4927
4928#ifdef CONFIG_PM 4928#ifdef CONFIG_PM
4929static void hda_power_work(struct work_struct *work) 4929static 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)
5045 __snd_hda_power_down(codec); 5045 __snd_hda_power_down(codec);
5046 spin_unlock(&codec->power_lock); 5046 spin_unlock(&codec->power_lock);
5047} 5047}
5048EXPORT_SYMBOL_HDA(snd_hda_power_save); 5048EXPORT_SYMBOL_GPL(snd_hda_power_save);
5049 5049
5050/** 5050/**
5051 * snd_hda_check_amp_list_power - Check the amp list and update the power 5051 * 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,
5095 } 5095 }
5096 return 0; 5096 return 0;
5097} 5097}
5098EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power); 5098EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
5099#endif 5099#endif
5100 5100
5101/* 5101/*
@@ -5119,7 +5119,7 @@ int snd_hda_ch_mode_info(struct hda_codec *codec,
5119 chmode[uinfo->value.enumerated.item].channels); 5119 chmode[uinfo->value.enumerated.item].channels);
5120 return 0; 5120 return 0;
5121} 5121}
5122EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); 5122EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
5123 5123
5124/** 5124/**
5125 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum 5125 * 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,
5140 } 5140 }
5141 return 0; 5141 return 0;
5142} 5142}
5143EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); 5143EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
5144 5144
5145/** 5145/**
5146 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum 5146 * 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,
5164 snd_hda_sequence_write_cache(codec, chmode[mode].sequence); 5164 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5165 return 1; 5165 return 1;
5166} 5166}
5167EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put); 5167EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
5168 5168
5169/* 5169/*
5170 * input MUX helper 5170 * input MUX helper
@@ -5189,7 +5189,7 @@ int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5189 strcpy(uinfo->value.enumerated.name, imux->items[index].label); 5189 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5190 return 0; 5190 return 0;
5191} 5191}
5192EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); 5192EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
5193 5193
5194/** 5194/**
5195 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum 5195 * 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,
5214 *cur_val = idx; 5214 *cur_val = idx;
5215 return 1; 5215 return 1;
5216} 5216}
5217EXPORT_SYMBOL_HDA(snd_hda_input_mux_put); 5217EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
5218 5218
5219 5219
5220/* 5220/*
@@ -5243,7 +5243,7 @@ int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5243 texts[uinfo->value.enumerated.item]); 5243 texts[uinfo->value.enumerated.item]);
5244 return 0; 5244 return 0;
5245} 5245}
5246EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info); 5246EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
5247 5247
5248/* 5248/*
5249 * Multi-channel / digital-out PCM helper functions 5249 * Multi-channel / digital-out PCM helper functions
@@ -5309,7 +5309,7 @@ void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5309 codec->patch_ops.reboot_notify(codec); 5309 codec->patch_ops.reboot_notify(codec);
5310 } 5310 }
5311} 5311}
5312EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify); 5312EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
5313 5313
5314/** 5314/**
5315 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode 5315 * 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,
5325 mutex_unlock(&codec->spdif_mutex); 5325 mutex_unlock(&codec->spdif_mutex);
5326 return 0; 5326 return 0;
5327} 5327}
5328EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); 5328EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
5329 5329
5330/** 5330/**
5331 * snd_hda_multi_out_dig_prepare - prepare the digital out stream 5331 * 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,
5341 mutex_unlock(&codec->spdif_mutex); 5341 mutex_unlock(&codec->spdif_mutex);
5342 return 0; 5342 return 0;
5343} 5343}
5344EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); 5344EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
5345 5345
5346/** 5346/**
5347 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream 5347 * 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,
5354 mutex_unlock(&codec->spdif_mutex); 5354 mutex_unlock(&codec->spdif_mutex);
5355 return 0; 5355 return 0;
5356} 5356}
5357EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); 5357EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
5358 5358
5359/** 5359/**
5360 * snd_hda_multi_out_dig_close - release the digital out stream 5360 * 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,
5367 mutex_unlock(&codec->spdif_mutex); 5367 mutex_unlock(&codec->spdif_mutex);
5368 return 0; 5368 return 0;
5369} 5369}
5370EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); 5370EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
5371 5371
5372/** 5372/**
5373 * snd_hda_multi_out_analog_open - open analog outputs 5373 * snd_hda_multi_out_analog_open - open analog outputs
@@ -5417,7 +5417,7 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5417 return snd_pcm_hw_constraint_step(substream->runtime, 0, 5417 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5418 SNDRV_PCM_HW_PARAM_CHANNELS, 2); 5418 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5419} 5419}
5420EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); 5420EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
5421 5421
5422/** 5422/**
5423 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs. 5423 * 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,
5494 5494
5495 return 0; 5495 return 0;
5496} 5496}
5497EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); 5497EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
5498 5498
5499/** 5499/**
5500 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out 5500 * 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,
5525 mutex_unlock(&codec->spdif_mutex); 5525 mutex_unlock(&codec->spdif_mutex);
5526 return 0; 5526 return 0;
5527} 5527}
5528EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup); 5528EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
5529 5529
5530/** 5530/**
5531 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits 5531 * 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)
5552 return AC_PINCTL_VREF_GRD; 5552 return AC_PINCTL_VREF_GRD;
5553 return AC_PINCTL_VREF_HIZ; 5553 return AC_PINCTL_VREF_HIZ;
5554} 5554}
5555EXPORT_SYMBOL_HDA(snd_hda_get_default_vref); 5555EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
5556 5556
5557/* correct the pin ctl value for matching with the pin cap */ 5557/* correct the pin ctl value for matching with the pin cap */
5558unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec, 5558unsigned 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,
5603 5603
5604 return val; 5604 return val;
5605} 5605}
5606EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl); 5606EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
5607 5607
5608int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 5608int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5609 unsigned int val, bool cached) 5609 unsigned int val, bool cached)
@@ -5617,7 +5617,7 @@ int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5617 return snd_hda_codec_write(codec, pin, 0, 5617 return snd_hda_codec_write(codec, pin, 0,
5618 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 5618 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5619} 5619}
5620EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl); 5620EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
5621 5621
5622/** 5622/**
5623 * snd_hda_add_imux_item - Add an item to input_mux 5623 * 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,
5651 imux->num_items++; 5651 imux->num_items++;
5652 return 0; 5652 return 0;
5653} 5653}
5654EXPORT_SYMBOL_HDA(snd_hda_add_imux_item); 5654EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
5655 5655
5656 5656
5657#ifdef CONFIG_PM 5657#ifdef CONFIG_PM
@@ -5697,7 +5697,7 @@ int snd_hda_suspend(struct hda_bus *bus)
5697 5697
5698 return 0; 5698 return 0;
5699} 5699}
5700EXPORT_SYMBOL_HDA(snd_hda_suspend); 5700EXPORT_SYMBOL_GPL(snd_hda_suspend);
5701 5701
5702/** 5702/**
5703 * snd_hda_resume - resume the codecs 5703 * snd_hda_resume - resume the codecs
@@ -5722,7 +5722,7 @@ int snd_hda_resume(struct hda_bus *bus)
5722 5722
5723 return 0; 5723 return 0;
5724} 5724}
5725EXPORT_SYMBOL_HDA(snd_hda_resume); 5725EXPORT_SYMBOL_GPL(snd_hda_resume);
5726#endif /* CONFIG_PM */ 5726#endif /* CONFIG_PM */
5727 5727
5728/* 5728/*
@@ -5756,7 +5756,7 @@ void *snd_array_new(struct snd_array *array)
5756 } 5756 }
5757 return snd_array_elem(array, array->used++); 5757 return snd_array_elem(array, array->used++);
5758} 5758}
5759EXPORT_SYMBOL_HDA(snd_array_new); 5759EXPORT_SYMBOL_GPL(snd_array_new);
5760 5760
5761/** 5761/**
5762 * snd_array_free - free the given array elements 5762 * snd_array_free - free the given array elements
@@ -5769,7 +5769,7 @@ void snd_array_free(struct snd_array *array)
5769 array->alloced = 0; 5769 array->alloced = 0;
5770 array->list = NULL; 5770 array->list = NULL;
5771} 5771}
5772EXPORT_SYMBOL_HDA(snd_array_free); 5772EXPORT_SYMBOL_GPL(snd_array_free);
5773 5773
5774/** 5774/**
5775 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer 5775 * 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)
5790 5790
5791 buf[j] = '\0'; /* necessary when j == 0 */ 5791 buf[j] = '\0'; /* necessary when j == 0 */
5792} 5792}
5793EXPORT_SYMBOL_HDA(snd_print_pcm_bits); 5793EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
5794 5794
5795MODULE_DESCRIPTION("HDA codec core"); 5795MODULE_DESCRIPTION("HDA codec core");
5796MODULE_LICENSE("GPL"); 5796MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c
index 8cebdcfdcfdc..ce004326d54b 100644
--- a/sound/pci/hda/hda_generic.c
+++ b/sound/pci/hda/hda_generic.c
@@ -48,7 +48,7 @@ int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
48 mutex_init(&spec->pcm_mutex); 48 mutex_init(&spec->pcm_mutex);
49 return 0; 49 return 0;
50} 50}
51EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init); 51EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
52 52
53struct snd_kcontrol_new * 53struct snd_kcontrol_new *
54snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name, 54snd_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,
66 return NULL; 66 return NULL;
67 return knew; 67 return knew;
68} 68}
69EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl); 69EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
70 70
71static void free_kctls(struct hda_gen_spec *spec) 71static void free_kctls(struct hda_gen_spec *spec)
72{ 72{
@@ -87,7 +87,7 @@ void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
87 snd_array_free(&spec->paths); 87 snd_array_free(&spec->paths);
88 snd_array_free(&spec->loopback_list); 88 snd_array_free(&spec->loopback_list);
89} 89}
90EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free); 90EXPORT_SYMBOL_GPL(snd_hda_gen_spec_free);
91 91
92/* 92/*
93 * store user hints 93 * store user hints
@@ -267,7 +267,7 @@ struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
267{ 267{
268 return get_nid_path(codec, from_nid, to_nid, 0); 268 return get_nid_path(codec, from_nid, to_nid, 0);
269} 269}
270EXPORT_SYMBOL_HDA(snd_hda_get_nid_path); 270EXPORT_SYMBOL_GPL(snd_hda_get_nid_path);
271 271
272/* get the index number corresponding to the path instance; 272/* get the index number corresponding to the path instance;
273 * the index starts from 1, for easier checking the invalid value 273 * 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)
285 return 0; 285 return 0;
286 return idx + 1; 286 return idx + 1;
287} 287}
288EXPORT_SYMBOL_HDA(snd_hda_get_path_idx); 288EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
289 289
290/* get the path instance corresponding to the given index number */ 290/* get the path instance corresponding to the given index number */
291struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx) 291struct 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)
296 return NULL; 296 return NULL;
297 return snd_array_elem(&spec->paths, idx - 1); 297 return snd_array_elem(&spec->paths, idx - 1);
298} 298}
299EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx); 299EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
300 300
301/* check whether the given DAC is already found in any existing paths */ 301/* check whether the given DAC is already found in any existing paths */
302static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid) 302static 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,
433 } 433 }
434 return false; 434 return false;
435} 435}
436EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path); 436EXPORT_SYMBOL_GPL(snd_hda_parse_nid_path);
437 437
438/* 438/*
439 * parse the path between the given NIDs and add to the path list. 439 * 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,
464 spec->paths.used--; 464 spec->paths.used--;
465 return NULL; 465 return NULL;
466} 466}
467EXPORT_SYMBOL_HDA(snd_hda_add_new_path); 467EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
468 468
469/* clear the given path as invalid so that it won't be picked up later */ 469/* clear the given path as invalid so that it won't be picked up later */
470static void invalidate_nid_path(struct hda_codec *codec, int idx) 470static 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,
774 if (enable) 774 if (enable)
775 path->active = true; 775 path->active = true;
776} 776}
777EXPORT_SYMBOL_HDA(snd_hda_activate_path); 777EXPORT_SYMBOL_GPL(snd_hda_activate_path);
778 778
779/* if the given path is inactive, put widgets into D3 (only if suitable) */ 779/* if the given path is inactive, put widgets into D3 (only if suitable) */
780static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path) 780static 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 = {
1150 .shared_clfe = BAD_SHARED_CLFE, 1150 .shared_clfe = BAD_SHARED_CLFE,
1151 .shared_surr_main = BAD_SHARED_SURROUND, 1151 .shared_surr_main = BAD_SHARED_SURROUND,
1152}; 1152};
1153EXPORT_SYMBOL_HDA(hda_main_out_badness); 1153EXPORT_SYMBOL_GPL(hda_main_out_badness);
1154 1154
1155const struct badness_table hda_extra_out_badness = { 1155const struct badness_table hda_extra_out_badness = {
1156 .no_primary_dac = BAD_NO_DAC, 1156 .no_primary_dac = BAD_NO_DAC,
@@ -1160,7 +1160,7 @@ const struct badness_table hda_extra_out_badness = {
1160 .shared_clfe = BAD_SHARED_EXTRA_SURROUND, 1160 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1161 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC, 1161 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1162}; 1162};
1163EXPORT_SYMBOL_HDA(hda_extra_out_badness); 1163EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1164 1164
1165/* get the DAC of the primary output corresponding to the given array index */ 1165/* get the DAC of the primary output corresponding to the given array index */
1166static hda_nid_t get_primary_out(struct hda_codec *codec, int idx) 1166static 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)
3921 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 3921 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3922 spec->autocfg.line_out_pins, paths, on); 3922 spec->autocfg.line_out_pins, paths, on);
3923} 3923}
3924EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs); 3924EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
3925 3925
3926static void call_update_outputs(struct hda_codec *codec) 3926static void call_update_outputs(struct hda_codec *codec)
3927{ 3927{
@@ -3954,7 +3954,7 @@ void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3954 return; 3954 return;
3955 call_update_outputs(codec); 3955 call_update_outputs(codec);
3956} 3956}
3957EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute); 3957EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
3958 3958
3959/* standard line-out-automute helper */ 3959/* standard line-out-automute helper */
3960void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack) 3960void 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
3974 return; 3974 return;
3975 call_update_outputs(codec); 3975 call_update_outputs(codec);
3976} 3976}
3977EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute); 3977EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
3978 3978
3979/* standard mic auto-switch helper */ 3979/* standard mic auto-switch helper */
3980void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack) 3980void 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
3997 } 3997 }
3998 mux_select(codec, 0, spec->am_entry[0].idx); 3998 mux_select(codec, 0, spec->am_entry[0].idx);
3999} 3999}
4000EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch); 4000EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4001 4001
4002/* call appropriate hooks */ 4002/* call appropriate hooks */
4003static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack) 4003static 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,
4513 4513
4514 return 1; 4514 return 1;
4515} 4515}
4516EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config); 4516EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
4517 4517
4518 4518
4519/* 4519/*
@@ -4595,7 +4595,7 @@ int snd_hda_gen_build_controls(struct hda_codec *codec)
4595 4595
4596 return 0; 4596 return 0;
4597} 4597}
4598EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls); 4598EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
4599 4599
4600 4600
4601/* 4601/*
@@ -5128,7 +5128,7 @@ int snd_hda_gen_build_pcms(struct hda_codec *codec)
5128 5128
5129 return 0; 5129 return 0;
5130} 5130}
5131EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms); 5131EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5132 5132
5133 5133
5134/* 5134/*
@@ -5339,7 +5339,7 @@ int snd_hda_gen_init(struct hda_codec *codec)
5339 hda_call_check_power_status(codec, 0x01); 5339 hda_call_check_power_status(codec, 0x01);
5340 return 0; 5340 return 0;
5341} 5341}
5342EXPORT_SYMBOL_HDA(snd_hda_gen_init); 5342EXPORT_SYMBOL_GPL(snd_hda_gen_init);
5343 5343
5344/* 5344/*
5345 * free the generic spec; 5345 * free the generic spec;
@@ -5352,7 +5352,7 @@ void snd_hda_gen_free(struct hda_codec *codec)
5352 kfree(codec->spec); 5352 kfree(codec->spec);
5353 codec->spec = NULL; 5353 codec->spec = NULL;
5354} 5354}
5355EXPORT_SYMBOL_HDA(snd_hda_gen_free); 5355EXPORT_SYMBOL_GPL(snd_hda_gen_free);
5356 5356
5357#ifdef CONFIG_PM 5357#ifdef CONFIG_PM
5358/* 5358/*
@@ -5364,7 +5364,7 @@ int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
5364 struct hda_gen_spec *spec = codec->spec; 5364 struct hda_gen_spec *spec = codec->spec;
5365 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 5365 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
5366} 5366}
5367EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status); 5367EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
5368#endif 5368#endif
5369 5369
5370 5370
@@ -5409,7 +5409,7 @@ error:
5409 snd_hda_gen_free(codec); 5409 snd_hda_gen_free(codec);
5410 return err; 5410 return err;
5411} 5411}
5412EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec); 5412EXPORT_SYMBOL_GPL(snd_hda_parse_generic_codec);
5413 5413
5414MODULE_LICENSE("GPL"); 5414MODULE_LICENSE("GPL");
5415MODULE_DESCRIPTION("Generic HD-audio codec parser"); 5415MODULE_DESCRIPTION("Generic HD-audio codec parser");
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index fe0bda19de15..0ec6fb1e9846 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -616,7 +616,7 @@ const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
616 struct hda_hint *hint = get_hint(codec, key); 616 struct hda_hint *hint = get_hint(codec, key);
617 return hint ? hint->val : NULL; 617 return hint ? hint->val : NULL;
618} 618}
619EXPORT_SYMBOL_HDA(snd_hda_get_hint); 619EXPORT_SYMBOL_GPL(snd_hda_get_hint);
620 620
621int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 621int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
622{ 622{
@@ -642,7 +642,7 @@ int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
642 mutex_unlock(&codec->user_mutex); 642 mutex_unlock(&codec->user_mutex);
643 return ret; 643 return ret;
644} 644}
645EXPORT_SYMBOL_HDA(snd_hda_get_bool_hint); 645EXPORT_SYMBOL_GPL(snd_hda_get_bool_hint);
646 646
647int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp) 647int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
648{ 648{
@@ -663,7 +663,7 @@ int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
663 mutex_unlock(&codec->user_mutex); 663 mutex_unlock(&codec->user_mutex);
664 return ret; 664 return ret;
665} 665}
666EXPORT_SYMBOL_HDA(snd_hda_get_int_hint); 666EXPORT_SYMBOL_GPL(snd_hda_get_int_hint);
667#endif /* CONFIG_SND_HDA_RECONFIG */ 667#endif /* CONFIG_SND_HDA_RECONFIG */
668 668
669#ifdef CONFIG_SND_HDA_PATCH_LOADER 669#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)
851 } 851 }
852 return 0; 852 return 0;
853} 853}
854EXPORT_SYMBOL_HDA(snd_hda_load_patch); 854EXPORT_SYMBOL_GPL(snd_hda_load_patch);
855#endif /* CONFIG_SND_HDA_PATCH_LOADER */ 855#endif /* CONFIG_SND_HDA_PATCH_LOADER */
diff --git a/sound/pci/hda/hda_jack.c b/sound/pci/hda/hda_jack.c
index afe594411a56..9746d73cec52 100644
--- a/sound/pci/hda/hda_jack.c
+++ b/sound/pci/hda/hda_jack.c
@@ -34,7 +34,7 @@ bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
34 return false; 34 return false;
35 return true; 35 return true;
36} 36}
37EXPORT_SYMBOL_HDA(is_jack_detectable); 37EXPORT_SYMBOL_GPL(is_jack_detectable);
38 38
39/* execute pin sense measurement */ 39/* execute pin sense measurement */
40static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid) 40static 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)
71 return jack; 71 return jack;
72 return NULL; 72 return NULL;
73} 73}
74EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get); 74EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get);
75 75
76/** 76/**
77 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag 77 * 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)
89 return jack; 89 return jack;
90 return NULL; 90 return NULL;
91} 91}
92EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag); 92EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
93 93
94/** 94/**
95 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID 95 * 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)
108 jack->tag = codec->jacktbl.used; 108 jack->tag = codec->jacktbl.used;
109 return jack; 109 return jack;
110} 110}
111EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new); 111EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_new);
112 112
113void snd_hda_jack_tbl_clear(struct hda_codec *codec) 113void snd_hda_jack_tbl_clear(struct hda_codec *codec)
114{ 114{
@@ -172,7 +172,7 @@ void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
172 if (jack->nid) 172 if (jack->nid)
173 jack->jack_dirty = 1; 173 jack->jack_dirty = 1;
174} 174}
175EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all); 175EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
176 176
177/** 177/**
178 * snd_hda_pin_sense - execute pin sense measurement 178 * 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)
191 } 191 }
192 return read_pin_sense(codec, nid); 192 return read_pin_sense(codec, nid);
193} 193}
194EXPORT_SYMBOL_HDA(snd_hda_pin_sense); 194EXPORT_SYMBOL_GPL(snd_hda_pin_sense);
195 195
196/** 196/**
197 * snd_hda_jack_detect_state - query pin Presence Detect status 197 * 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)
211 else 211 else
212 return HDA_JACK_NOT_PRESENT; 212 return HDA_JACK_NOT_PRESENT;
213} 213}
214EXPORT_SYMBOL_HDA(snd_hda_jack_detect_state); 214EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state);
215 215
216/** 216/**
217 * snd_hda_jack_detect_enable - enable the jack-detection 217 * 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,
236 AC_VERB_SET_UNSOLICITED_ENABLE, 236 AC_VERB_SET_UNSOLICITED_ENABLE,
237 AC_USRSP_EN | jack->tag); 237 AC_USRSP_EN | jack->tag);
238} 238}
239EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback); 239EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback);
240 240
241int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid, 241int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
242 unsigned char action) 242 unsigned char action)
243{ 243{
244 return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL); 244 return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
245} 245}
246EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable); 246EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
247 247
248/** 248/**
249 * snd_hda_jack_set_gating_jack - Set gating jack. 249 * 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,
264 264
265 return 0; 265 return 0;
266} 266}
267EXPORT_SYMBOL_HDA(snd_hda_jack_set_gating_jack); 267EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
268 268
269/** 269/**
270 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed 270 * 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)
297#endif 297#endif
298 } 298 }
299} 299}
300EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync); 300EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
301 301
302#ifdef CONFIG_SND_HDA_INPUT_JACK 302#ifdef CONFIG_SND_HDA_INPUT_JACK
303/* guess the jack type from the pin-config */ 303/* 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,
377{ 377{
378 return __snd_hda_jack_add_kctl(codec, nid, name, idx, false); 378 return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
379} 379}
380EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl); 380EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl);
381 381
382/* get the unique index number for the given kctl name */ 382/* get the unique index number for the given kctl name */
383static int get_unique_index(struct hda_codec *codec, const char *name, int idx) 383static 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,
493 return err; 493 return err;
494 return 0; 494 return 0;
495} 495}
496EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls); 496EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
497 497
498static void call_jack_callback(struct hda_codec *codec, 498static void call_jack_callback(struct hda_codec *codec,
499 struct hda_jack_tbl *jack) 499 struct hda_jack_tbl *jack)
@@ -521,7 +521,7 @@ void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
521 call_jack_callback(codec, event); 521 call_jack_callback(codec, event);
522 snd_hda_jack_report_sync(codec); 522 snd_hda_jack_report_sync(codec);
523} 523}
524EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event); 524EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
525 525
526void snd_hda_jack_poll_all(struct hda_codec *codec) 526void snd_hda_jack_poll_all(struct hda_codec *codec)
527{ 527{
@@ -542,5 +542,5 @@ void snd_hda_jack_poll_all(struct hda_codec *codec)
542 if (changes) 542 if (changes)
543 snd_hda_jack_report_sync(codec); 543 snd_hda_jack_report_sync(codec);
544} 544}
545EXPORT_SYMBOL_HDA(snd_hda_jack_poll_all); 545EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
546 546
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 977db17db26c..59b83f4085a8 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -3217,7 +3217,7 @@ int snd_hda_parse_hdmi_codec(struct hda_codec *codec)
3217{ 3217{
3218 return patch_generic_hdmi(codec); 3218 return patch_generic_hdmi(codec);
3219} 3219}
3220EXPORT_SYMBOL_HDA(snd_hda_parse_hdmi_codec); 3220EXPORT_SYMBOL_GPL(snd_hda_parse_hdmi_codec);
3221 3221
3222/* 3222/*
3223 * patch entries 3223 * patch entries
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-22 18:57:37 -0500