Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Unverified Commit ef050bec authored by Charles Keepax's avatar Charles Keepax Committed by Mark Brown
Browse files

ASoC: Remove platform code now everything is componentised 



As all drivers have been moved over to the new generic component
code remove the now unused platform specific code.

Signed-off-by: default avatarCharles Keepax <ckeepax@opensource.cirrus.com>
Acked-by: default avatarVinod Koul <vkoul@kernel.org>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent c0c0be9d

include/sound/soc.h

+3 −100
Original line number Diff line number Diff line
@@ -401,9 +401,7 @@ struct snd_soc_ops; 
struct snd_soc_pcm_runtime;

struct snd_soc_dai;

struct snd_soc_dai_driver;

struct snd_soc_platform;

struct snd_soc_dai_link;

struct snd_soc_platform_driver;

struct snd_soc_codec;

struct snd_soc_codec_driver;

struct snd_soc_component;
@@ -455,15 +453,6 @@ static inline int snd_soc_resume(struct device *dev) 
}

#endif

int snd_soc_poweroff(struct device *dev);

int snd_soc_register_platform(struct device *dev,

		const struct snd_soc_platform_driver *platform_drv);

int devm_snd_soc_register_platform(struct device *dev,

		const struct snd_soc_platform_driver *platform_drv);

void snd_soc_unregister_platform(struct device *dev);

int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,

		const struct snd_soc_platform_driver *platform_drv);

void snd_soc_remove_platform(struct snd_soc_platform *platform);

struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev);

int snd_soc_register_codec(struct device *dev,

		const struct snd_soc_codec_driver *codec_drv,

		struct snd_soc_dai_driver *dai_drv, int num_dai);
@@ -485,10 +474,6 @@ struct snd_soc_component *snd_soc_lookup_component(struct device *dev, 
int snd_soc_cache_init(struct snd_soc_codec *codec);

int snd_soc_cache_exit(struct snd_soc_codec *codec);



int snd_soc_platform_read(struct snd_soc_platform *platform,

					unsigned int reg);

int snd_soc_platform_write(struct snd_soc_platform *platform,

					unsigned int reg, unsigned int val);

int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);

#ifdef CONFIG_SND_SOC_COMPRESS

int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
@@ -628,8 +613,6 @@ int snd_soc_add_component_controls(struct snd_soc_component *component, 
	const struct snd_kcontrol_new *controls, unsigned int num_controls);

int snd_soc_add_codec_controls(struct snd_soc_codec *codec,

	const struct snd_kcontrol_new *controls, unsigned int num_controls);

int snd_soc_add_platform_controls(struct snd_soc_platform *platform,

	const struct snd_kcontrol_new *controls, unsigned int num_controls);

int snd_soc_add_card_controls(struct snd_soc_card *soc_card,

	const struct snd_kcontrol_new *controls, int num_controls);

int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
@@ -996,39 +979,12 @@ struct snd_soc_codec_driver { 
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */

};



/* SoC platform interface */

struct snd_soc_platform_driver {



	int (*probe)(struct snd_soc_platform *);

	int (*remove)(struct snd_soc_platform *);

	struct snd_soc_component_driver component_driver;



	/* pcm creation and destruction */

	int (*pcm_new)(struct snd_soc_pcm_runtime *);

	void (*pcm_free)(struct snd_pcm *);



	/* platform stream pcm ops */

	const struct snd_pcm_ops *ops;



	/* platform stream compress ops */

	const struct snd_compr_ops *compr_ops;

};



struct snd_soc_dai_link_component {

	const char *name;

	struct device_node *of_node;

	const char *dai_name;

};



struct snd_soc_platform {

	struct device *dev;

	const struct snd_soc_platform_driver *driver;



	struct list_head list;



	struct snd_soc_component component;

};



struct snd_soc_dai_link {

	/* config - must be set by machine driver */

	const char *name;			/* Codec name */
@@ -1277,7 +1233,6 @@ struct snd_soc_pcm_runtime { 
	struct snd_pcm *pcm;

	struct snd_compr *compr;

	struct snd_soc_codec *codec;

	struct snd_soc_platform *platform; /* will be removed */

	struct snd_soc_dai *codec_dai;

	struct snd_soc_dai *cpu_dai;
@@ -1358,19 +1313,6 @@ static inline struct snd_soc_codec *snd_soc_component_to_codec( 
	return container_of(component, struct snd_soc_codec, component);

}



/**

 * snd_soc_component_to_platform() - Casts a component to the platform it is embedded in

 * @component: The component to cast to a platform

 *

 * This function must only be used on components that are known to be platforms.

 * Otherwise the behavior is undefined.

 */

static inline struct snd_soc_platform *snd_soc_component_to_platform(

	struct snd_soc_component *component)

{

	return container_of(component, struct snd_soc_platform, component);

}



/**

 * snd_soc_dapm_to_component() - Casts a DAPM context to the component it is

 *  embedded in
@@ -1399,20 +1341,6 @@ static inline struct snd_soc_codec *snd_soc_dapm_to_codec( 
	return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));

}



/**

 * snd_soc_dapm_to_platform() - Casts a DAPM context to the platform it is

 *  embedded in

 * @dapm: The DAPM context to cast to the platform.

 *

 * This function must only be used on DAPM contexts that are known to be part of

 * a platform (e.g. in a platform driver). Otherwise the behavior is undefined.

 */

static inline struct snd_soc_platform *snd_soc_dapm_to_platform(

	struct snd_soc_dapm_context *dapm)

{

	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));

}



/**

 * snd_soc_component_get_dapm() - Returns the DAPM context associated with a

 *  component
@@ -1673,17 +1601,6 @@ static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec) 
	return snd_soc_component_get_drvdata(&codec->component);

}



static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,

		void *data)

{

	snd_soc_component_set_drvdata(&platform->component, data);

}



static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)

{

	return snd_soc_component_get_drvdata(&platform->component);

}



static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)

{

	INIT_LIST_HEAD(&card->widgets);
@@ -1746,9 +1663,9 @@ static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec) 
 * @kcontrol: The control for which to get the component

 *

 * Note: This function will work correctly if the control has been registered

 * for a component. Either with snd_soc_add_codec_controls() or

 * snd_soc_add_platform_controls() or via  table based setup for either a

 * CODEC, a platform or component driver. Otherwise the behavior is undefined.

 * for a component. With snd_soc_add_codec_controls() or via table based

 * setup for either a CODEC or component driver. Otherwise the behavior is

 * undefined.

 */

static inline struct snd_soc_component *snd_soc_kcontrol_component(

	struct snd_kcontrol *kcontrol)
@@ -1770,20 +1687,6 @@ static inline struct snd_soc_codec *snd_soc_kcontrol_codec( 
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));

}



/**

 * snd_soc_kcontrol_platform() - Returns the platform that registered the control

 * @kcontrol: The control for which to get the platform

 *

 * Note: This function will only work correctly if the control has been

 * registered with snd_soc_add_platform_controls() or via table based setup of

 * a snd_soc_platform_driver. Otherwise the behavior is undefined.

 */

static inline struct snd_soc_platform *snd_soc_kcontrol_platform(

	struct snd_kcontrol *kcontrol)

{

	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));

}



int snd_soc_util_init(void);

void snd_soc_util_exit(void);

sound/soc/soc-compress.c

+6 −221
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ 
static int soc_compr_open(struct snd_compr_stream *cstream)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -47,23 +46,9 @@ static int soc_compr_open(struct snd_compr_stream *cstream) 
		}

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {

		ret = platform->driver->compr_ops->open(cstream);

		if (ret < 0) {

			dev_err(platform->dev,

				"Compress ASoC: can't open platform %s: %d\n",

				platform->component.name, ret);

			goto plat_err;

		}

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->open)

			continue;
@@ -101,10 +86,6 @@ static int soc_compr_open(struct snd_compr_stream *cstream) 
		if (err_comp == component)

			break;



		/* ignore duplication for now */

		if (platform && (err_comp == &platform->component))

			continue;



		if (!err_comp->driver->compr_ops ||

		    !err_comp->driver->compr_ops->free)

			continue;
@@ -112,9 +93,6 @@ static int soc_compr_open(struct snd_compr_stream *cstream) 
		err_comp->driver->compr_ops->free(cstream);

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);

plat_err:

	if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)

		cpu_dai->driver->cops->shutdown(cstream, cpu_dai);

out:
@@ -127,7 +105,6 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream) 
	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_pcm_substream *fe_substream =

		 fe->pcm->streams[cstream->direction].substream;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = fe->cpu_dai;
@@ -153,23 +130,9 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream) 
		}

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {

		ret = platform->driver->compr_ops->open(cstream);

		if (ret < 0) {

			dev_err(platform->dev,

				"Compress ASoC: can't open platform %s: %d\n",

				platform->component.name, ret);

			goto plat_err;

		}

	}



	for_each_rtdcom(fe, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->open)

			continue;
@@ -242,10 +205,6 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream) 
		if (err_comp == component)

			break;



		/* ignore duplication for now */

		if (platform && (err_comp == &platform->component))

			continue;



		if (!err_comp->driver->compr_ops ||

		    !err_comp->driver->compr_ops->free)

			continue;
@@ -253,9 +212,6 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream) 
		err_comp->driver->compr_ops->free(cstream);

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);

plat_err:

	if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)

		cpu_dai->driver->cops->shutdown(cstream, cpu_dai);

out:
@@ -296,7 +252,6 @@ static void close_delayed_work(struct work_struct *work) 
static int soc_compr_free(struct snd_compr_stream *cstream)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -326,10 +281,6 @@ static int soc_compr_free(struct snd_compr_stream *cstream) 
	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->free)

			continue;
@@ -337,9 +288,6 @@ static int soc_compr_free(struct snd_compr_stream *cstream) 
		component->driver->compr_ops->free(cstream);

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);



	if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)

		cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
@@ -368,7 +316,6 @@ static int soc_compr_free(struct snd_compr_stream *cstream) 
static int soc_compr_free_fe(struct snd_compr_stream *cstream)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = fe->cpu_dai;
@@ -408,16 +355,9 @@ static int soc_compr_free_fe(struct snd_compr_stream *cstream) 
	if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)

		fe->dai_link->compr_ops->shutdown(cstream);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);



	for_each_rtdcom(fe, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->free)

			continue;
@@ -436,7 +376,6 @@ static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 
{



	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *codec_dai = rtd->codec_dai;
@@ -445,19 +384,9 @@ static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 


	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {

		ret = platform->driver->compr_ops->trigger(cstream, cmd);

		if (ret < 0)

			goto out;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->trigger)

			continue;
@@ -489,7 +418,6 @@ static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd) 
static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = fe->cpu_dai;
@@ -498,19 +426,9 @@ static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) 
	if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||

		cmd == SND_COMPR_TRIGGER_DRAIN) {



		if (platform &&

		    platform->driver->compr_ops &&

		    platform->driver->compr_ops->trigger)

			return platform->driver->compr_ops->trigger(cstream,

								    cmd);



		for_each_rtdcom(fe, rtdcom) {

			component = rtdcom->component;



			/* ignore duplication for now */

			if (platform && (component == &platform->component))

				continue;



			if (!component->driver->compr_ops ||

			    !component->driver->compr_ops->trigger)

				continue;
@@ -536,19 +454,9 @@ static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd) 
			goto out;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {

		ret = platform->driver->compr_ops->trigger(cstream, cmd);

		if (ret < 0)

			goto out;

	}



	for_each_rtdcom(fe, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->trigger)

			continue;
@@ -589,7 +497,6 @@ static int soc_compr_set_params(struct snd_compr_stream *cstream, 
					struct snd_compr_params *params)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -597,11 +504,12 @@ static int soc_compr_set_params(struct snd_compr_stream *cstream, 


	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);



	/* first we call set_params for the platform driver

	 * this should configure the soc side

	 * if the machine has compressed ops then we call that as well

	 * expectation is that platform and machine will configure everything

	 * for this compress path, like configuring pcm port for codec

	/*

	 * First we call set_params for the CPU DAI, then the component

	 * driver this should configure the SoC side. If the machine has

	 * compressed ops then we call that as well. The expectation is

	 * that these callbacks will configure everything for this compress

	 * path, like configuring a PCM port for a CODEC.

	 */

	if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {

		ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
@@ -609,19 +517,9 @@ static int soc_compr_set_params(struct snd_compr_stream *cstream, 
			goto err;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {

		ret = platform->driver->compr_ops->set_params(cstream, params);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->set_params)

			continue;
@@ -665,7 +563,6 @@ static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, 
	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_pcm_substream *fe_substream =

		 fe->pcm->streams[cstream->direction].substream;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = fe->cpu_dai;
@@ -684,19 +581,9 @@ static int soc_compr_set_params_fe(struct snd_compr_stream *cstream, 
			goto out;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {

		ret = platform->driver->compr_ops->set_params(cstream, params);

		if (ret < 0)

			goto out;

	}



	for_each_rtdcom(fe, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->set_params)

			continue;
@@ -745,7 +632,6 @@ static int soc_compr_get_params(struct snd_compr_stream *cstream, 
					struct snd_codec *params)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -759,19 +645,9 @@ static int soc_compr_get_params(struct snd_compr_stream *cstream, 
			goto err;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) {

		ret = platform->driver->compr_ops->get_params(cstream, params);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->get_params)

			continue;
@@ -790,26 +666,15 @@ static int soc_compr_get_caps(struct snd_compr_stream *cstream, 
				struct snd_compr_caps *caps)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	int ret = 0, __ret;



	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) {

		ret = platform->driver->compr_ops->get_caps(cstream, caps);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->get_caps)

			continue;
@@ -819,7 +684,6 @@ static int soc_compr_get_caps(struct snd_compr_stream *cstream, 
			ret = __ret;

	}



err:

	mutex_unlock(&rtd->pcm_mutex);

	return ret;

}
@@ -828,26 +692,15 @@ static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, 
				struct snd_compr_codec_caps *codec)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	int ret = 0, __ret;



	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) {

		ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->get_codec_caps)

			continue;
@@ -857,7 +710,6 @@ static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, 
			ret = __ret;

	}



err:

	mutex_unlock(&rtd->pcm_mutex);

	return ret;

}
@@ -865,7 +717,6 @@ static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream, 
static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -879,19 +730,9 @@ static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes) 
			goto err;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) {

		ret = platform->driver->compr_ops->ack(cstream, bytes);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->ack)

			continue;
@@ -910,7 +751,6 @@ static int soc_compr_pointer(struct snd_compr_stream *cstream, 
			struct snd_compr_tstamp *tstamp)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	int ret = 0, __ret;
@@ -921,19 +761,9 @@ static int soc_compr_pointer(struct snd_compr_stream *cstream, 
	if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer)

		cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) {

		ret = platform->driver->compr_ops->pointer(cstream, tstamp);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->pointer)

			continue;
@@ -943,7 +773,6 @@ static int soc_compr_pointer(struct snd_compr_stream *cstream, 
			ret = __ret;

	}



err:

	mutex_unlock(&rtd->pcm_mutex);

	return ret;

}
@@ -952,26 +781,15 @@ static int soc_compr_copy(struct snd_compr_stream *cstream, 
			  char __user *buf, size_t count)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	int ret = 0;



	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) {

		ret = platform->driver->compr_ops->copy(cstream, buf, count);

		if (ret < 0)

			goto err;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->copy)

			continue;
@@ -980,7 +798,6 @@ static int soc_compr_copy(struct snd_compr_stream *cstream, 
		break;

	}



err:

	mutex_unlock(&rtd->pcm_mutex);

	return ret;

}
@@ -989,7 +806,6 @@ static int soc_compr_set_metadata(struct snd_compr_stream *cstream, 
				struct snd_compr_metadata *metadata)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -1001,19 +817,9 @@ static int soc_compr_set_metadata(struct snd_compr_stream *cstream, 
			return ret;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) {

		ret = platform->driver->compr_ops->set_metadata(cstream, metadata);

		if (ret < 0)

			return ret;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->set_metadata)

			continue;
@@ -1030,7 +836,6 @@ static int soc_compr_get_metadata(struct snd_compr_stream *cstream, 
				struct snd_compr_metadata *metadata)

{

	struct snd_soc_pcm_runtime *rtd = cstream->private_data;

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
@@ -1042,19 +847,9 @@ static int soc_compr_get_metadata(struct snd_compr_stream *cstream, 
			return ret;

	}



	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) {

		ret = platform->driver->compr_ops->get_metadata(cstream, metadata);

		if (ret < 0)

			return ret;

	}



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->get_metadata)

			continue;
@@ -1107,7 +902,6 @@ static struct snd_compr_ops soc_compr_dyn_ops = { 
 */

int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)

{

	struct snd_soc_platform *platform = rtd->platform;

	struct snd_soc_component *component;

	struct snd_soc_rtdcom_list *rtdcom;

	struct snd_soc_dai *codec_dai = rtd->codec_dai;
@@ -1188,18 +982,9 @@ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 
		memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));

	}





	/* Add copy callback for not memory mapped DSPs */

	if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy)

		compr->ops->copy = soc_compr_copy;



	for_each_rtdcom(rtd, rtdcom) {

		component = rtdcom->component;



		/* ignore duplication for now */

		if (platform && (component == &platform->component))

			continue;



		if (!component->driver->compr_ops ||

		    !component->driver->compr_ops->copy)

			continue;

sound/soc/soc-core.c

+0 −214

File changed.

Preview size limit exceeded, changes collapsed.

sound/soc/soc-devres.c

+0 −35
Original line number Diff line number Diff line
@@ -52,41 +52,6 @@ int devm_snd_soc_register_component(struct device *dev, 
}

EXPORT_SYMBOL_GPL(devm_snd_soc_register_component);



static void devm_platform_release(struct device *dev, void *res)

{

	snd_soc_unregister_platform(*(struct device **)res);

}



/**

 * devm_snd_soc_register_platform - resource managed platform registration

 * @dev: Device used to manage platform

 * @platform_drv: platform to register

 *

 * Register a platform driver with automatic unregistration when the device is

 * unregistered.

 */

int devm_snd_soc_register_platform(struct device *dev,

			const struct snd_soc_platform_driver *platform_drv)

{

	struct device **ptr;

	int ret;



	ptr = devres_alloc(devm_platform_release, sizeof(*ptr), GFP_KERNEL);

	if (!ptr)

		return -ENOMEM;



	ret = snd_soc_register_platform(dev, platform_drv);

	if (ret == 0) {

		*ptr = dev;

		devres_add(dev, ptr);

	} else {

		devres_free(ptr);

	}



	return ret;

}

EXPORT_SYMBOL_GPL(devm_snd_soc_register_platform);



static void devm_card_release(struct device *dev, void *res)

{

	snd_soc_unregister_card(*(struct snd_soc_card **)res);

sound/soc/soc-io.c

+0 −21
Original line number Diff line number Diff line
@@ -267,24 +267,3 @@ int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg, 
	return snd_soc_component_test_bits(&codec->component, reg, mask, value);

}

EXPORT_SYMBOL_GPL(snd_soc_test_bits);
 


int snd_soc_platform_read(struct snd_soc_platform *platform,

					unsigned int reg)

{

	unsigned int val;

	int ret;



	ret = snd_soc_component_read(&platform->component, reg, &val);

	if (ret < 0)

		return -1;



	return val;

}

EXPORT_SYMBOL_GPL(snd_soc_platform_read);



int snd_soc_platform_write(struct snd_soc_platform *platform,

					 unsigned int reg, unsigned int val)

{

	return snd_soc_component_write(&platform->component, reg, val);

}

EXPORT_SYMBOL_GPL(snd_soc_platform_write);