ALSA: hda - Use snd_hdac namespace prefix for chmap exported APIs

Signed-off-by: Subhransu S. Prusty <[e-mail]>
Signed-off-by: Vinod Koul <[e-mail]>
Signed-off-by: Takashi Iwai <[e-mail]>

include/sound/hda_chmap.h

···
 
 void snd_hdac_register_chmap_ops(struct hdac_device *hdac,
 				struct hdac_chmap *chmap);
-int hdmi_channel_allocation(struct hdac_device *hdac, int spk_alloc,
+int snd_hdac_channel_allocation(struct hdac_device *hdac, int spk_alloc,
 			int channels, bool chmap_set,
 			bool non_pcm, unsigned char *map);
-int hdmi_get_active_channels(int ca);
-void hdmi_setup_channel_mapping(struct hdac_chmap *chmap,
+int snd_hdac_get_active_channels(int ca);
+void snd_hdac_setup_channel_mapping(struct hdac_chmap *chmap,
 		       hda_nid_t pin_nid, bool non_pcm, int ca,
 		       int channels, unsigned char *map,
 		       bool chmap_set);
-void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
-struct hdac_cea_channel_speaker_allocation *hdmi_get_ch_alloc_from_ca(int ca);
-int to_spk_mask(unsigned char c);
-int spk_to_chmap(int spk);
+void snd_hdac_print_channel_allocation(int spk_alloc, char *buf, int buflen);
+struct hdac_cea_channel_speaker_allocation *snd_hdac_get_ch_alloc_from_ca(int ca);
+int snd_hdac_chmap_to_spk_mask(unsigned char c);
+int snd_hdac_spk_to_chmap(int spk);
 int snd_hdac_add_chmap_ctls(struct snd_pcm *pcm, int pcm_idx,
 				struct hdac_chmap *chmap);
 #endif /* __SOUND_HDA_CHMAP_H */

sound/hda/hdmi_chmap.c

···
 	return i;
 }
 
-void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen)
+void snd_hdac_print_channel_allocation(int spk_alloc, char *buf, int buflen)
 {
 	int i, j;
 
···
 	}
 	buf[j] = '\0';	/* necessary when j == 0 */
 }
-EXPORT_SYMBOL_GPL(snd_print_channel_allocation);
+EXPORT_SYMBOL_GPL(snd_hdac_print_channel_allocation);
 
 /*
  * The transformation takes two steps:
···
 		}
 	}
 
-	snd_print_channel_allocation(spk_alloc, buf, sizeof(buf));
+	snd_hdac_print_channel_allocation(spk_alloc, buf, sizeof(buf));
 	dev_dbg(&codec->dev, "HDMI: select CA 0x%x for %d-channel allocation: %s\n",
 		    ca, channels, buf);
 
···
 };
 
 /* from ALSA API channel position to speaker bit mask */
-int to_spk_mask(unsigned char c)
+int snd_hdac_chmap_to_spk_mask(unsigned char c)
 {
 	struct channel_map_table *t = map_tables;
 
···
 	}
 	return 0;
 }
-EXPORT_SYMBOL_GPL(to_spk_mask);
+EXPORT_SYMBOL_GPL(snd_hdac_chmap_to_spk_mask);
 
 /* from ALSA API channel position to CEA slot */
 static int to_cea_slot(int ordered_ca, unsigned char pos)
 {
-	int mask = to_spk_mask(pos);
+	int mask = snd_hdac_chmap_to_spk_mask(pos);
 	int i;
 
 	if (mask) {
···
 }
 
 /* from speaker bit mask to ALSA API channel position */
-int spk_to_chmap(int spk)
+int snd_hdac_spk_to_chmap(int spk)
 {
 	struct channel_map_table *t = map_tables;
 
···
 	}
 	return 0;
 }
-EXPORT_SYMBOL_GPL(spk_to_chmap);
+EXPORT_SYMBOL_GPL(snd_hdac_spk_to_chmap);
 
 /* from CEA slot to ALSA API channel position */
 static int from_cea_slot(int ordered_ca, unsigned char slot)
 {
 	int mask = channel_allocations[ordered_ca].speakers[7 - slot];
 
-	return spk_to_chmap(mask);
+	return snd_hdac_spk_to_chmap(mask);
 }
 
 /* get the CA index corresponding to the given ALSA API channel map */
···
 	int i, spks = 0, spk_mask = 0;
 
 	for (i = 0; i < chs; i++) {
-		int mask = to_spk_mask(map[i]);
+		int mask = snd_hdac_chmap_to_spk_mask(map[i]);
 
 		if (mask) {
 			spk_mask |= mask;
···
 	}
 }
 
-void hdmi_setup_channel_mapping(struct hdac_chmap *chmap,
+void snd_hdac_setup_channel_mapping(struct hdac_chmap *chmap,
 				       hda_nid_t pin_nid, bool non_pcm, int ca,
 				       int channels, unsigned char *map,
 				       bool chmap_set)
···
 
 	hdmi_debug_channel_mapping(chmap, pin_nid);
 }
-EXPORT_SYMBOL_GPL(hdmi_setup_channel_mapping);
+EXPORT_SYMBOL_GPL(snd_hdac_setup_channel_mapping);
 
-int hdmi_get_active_channels(int ca)
+int snd_hdac_get_active_channels(int ca)
 {
 	int ordered_ca = get_channel_allocation_order(ca);
 
 	return channel_allocations[ordered_ca].channels;
 }
-EXPORT_SYMBOL_GPL(hdmi_get_active_channels);
+EXPORT_SYMBOL_GPL(snd_hdac_get_active_channels);
 
-struct hdac_cea_channel_speaker_allocation *hdmi_get_ch_alloc_from_ca(int ca)
+struct hdac_cea_channel_speaker_allocation *snd_hdac_get_ch_alloc_from_ca(int ca)
 {
 	return &channel_allocations[get_channel_allocation_order(ca)];
 }
-EXPORT_SYMBOL_GPL(hdmi_get_ch_alloc_from_ca);
+EXPORT_SYMBOL_GPL(snd_hdac_get_ch_alloc_from_ca);
 
-int hdmi_channel_allocation(struct hdac_device *hdac, int spk_alloc,
+int snd_hdac_channel_allocation(struct hdac_device *hdac, int spk_alloc,
 		int channels, bool chmap_set, bool non_pcm, unsigned char *map)
 {
 	int ca;
···
 
 	return ca;
 }
-EXPORT_SYMBOL_GPL(hdmi_channel_allocation);
+EXPORT_SYMBOL_GPL(snd_hdac_channel_allocation);
 
 /*
  * ALSA API channel-map control callbacks
···
 		if (!spk)
 			continue;
 
-		chmap[count++] = spk_to_chmap(spk);
+		chmap[count++] = snd_hdac_spk_to_chmap(spk);
 	}
 
 	WARN_ON(count != channels);

sound/pci/hda/hda_eld.c

···
 
 	if (e->spk_alloc) {
 		char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
-		snd_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
+		snd_hdac_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
 		codec_dbg(codec, "HDMI: available speakers:%s\n", buf);
 	}
 
···
 	snd_iprintf(buffer, "support_ai\t\t%d\n", e->support_ai);
 	snd_iprintf(buffer, "audio_sync_delay\t%d\n", e->aud_synch_delay);
 
-	snd_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
+	snd_hdac_print_channel_allocation(e->spk_alloc, buf, sizeof(buf));
 	snd_iprintf(buffer, "speakers\t\t[0x%x]%s\n", e->spk_alloc, buf);
 
 	snd_iprintf(buffer, "sad_count\t\t%d\n", e->sad_count);

sound/pci/hda/patch_hdmi.c

···
 
 	eld = &per_pin->sink_eld;
 
-	ca = hdmi_channel_allocation(&codec->core,
+	ca = snd_hdac_channel_allocation(&codec->core,
 			eld->info.spk_alloc, channels,
 			per_pin->chmap_set, non_pcm, per_pin->chmap);
 
-	active_channels = hdmi_get_active_channels(ca);
+	active_channels = snd_hdac_get_active_channels(ca);
 
 	chmap->ops.set_channel_count(&codec->core, per_pin->cvt_nid,
 						active_channels);
···
 	 * always configure channel mapping, it may have been changed by the
 	 * user in the meantime
 	 */
-	hdmi_setup_channel_mapping(&spec->chmap,
+	snd_hdac_setup_channel_mapping(&spec->chmap,
 				pin_nid, non_pcm, ca, channels,
 				per_pin->chmap, per_pin->chmap_set);
 
···
 
 	/* check that only channel pairs need to be remapped on old pre-rev3 ATI/AMD */
 
-	cap = hdmi_get_ch_alloc_from_ca(ca);
+	cap = snd_hdac_get_ch_alloc_from_ca(ca);
 	for (i = 0; i < chs; ++i) {
-		int mask = to_spk_mask(map[i]);
+		int mask = snd_hdac_chmap_to_spk_mask(map[i]);
 		bool ok = false;
 		bool companion_ok = false;
 
···
 				if (i % 2 == 0 && i + 1 < chs) {
 					/* even channel, check the odd companion */
 					int comp_chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j + 1);
-					int comp_mask_req = to_spk_mask(map[i+1]);
+					int comp_mask_req = snd_hdac_chmap_to_spk_mask(map[i+1]);
 					int comp_mask_act = cap->speakers[comp_chan_idx];
 
 					if (comp_mask_req == comp_mask_act)
···
 			continue;
 		}
 
-		chmap[count++] = spk_to_chmap(spk);
+		chmap[count++] = snd_hdac_spk_to_chmap(spk);
 	}
 
 	WARN_ON(count != channels);