Piteball/android_kernel_samsung_msm8976
1
1
Fork 0
mirror of https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git synced 2024-11-01 10:33:27 +00:00
Code Issues Projects Releases Wiki Activity

ASoC: Remove snd_soc_suspend_device()

Browse source 
The PM core will grow pm_link infrastructure in 2.6.33 which can be
used to implement the intended functionality of the ASoC-specific
device suspend and resume callbacks so drop them.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
This commit is contained in:
Mark Brown 2009-10-13 17:39:56 +01:00
parent ed9d040d40
commit d2058b0cd0
18 changed files with 0 additions and 388 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
include/sound/soc.h
View file

@ -223,11 +223,6 @@ int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
int addr_bits, int data_bits, int addr_bits, int data_bits,
enum snd_soc_control_type control); enum snd_soc_control_type control);
#ifdef CONFIG_PM
int snd_soc_suspend_device(struct device *dev);
int snd_soc_resume_device(struct device *dev);
#endif
/* pcm <-> DAI connect */ /* pcm <-> DAI connect */
void snd_soc_free_pcms(struct snd_soc_device *socdev); void snd_soc_free_pcms(struct snd_soc_device *socdev);
int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid); int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid);

20
sound/soc/codecs/cs4270.c
View file

@ -802,22 +802,6 @@ MODULE_DEVICE_TABLE(i2c, cs4270_id);
* and all registers are written back to the hardware when resuming. * and all registers are written back to the hardware when resuming.
*/ */
static int cs4270_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
{
struct cs4270_private *cs4270 = i2c_get_clientdata(client);
struct snd_soc_codec *codec = &cs4270->codec;
return snd_soc_suspend_device(codec->dev);
}
static int cs4270_i2c_resume(struct i2c_client *client)
{
struct cs4270_private *cs4270 = i2c_get_clientdata(client);
struct snd_soc_codec *codec = &cs4270->codec;
return snd_soc_resume_device(codec->dev);
}
static int cs4270_soc_suspend(struct platform_device *pdev, pm_message_t mesg) static int cs4270_soc_suspend(struct platform_device *pdev, pm_message_t mesg)
{ {
struct snd_soc_codec *codec = cs4270_codec; struct snd_soc_codec *codec = cs4270_codec;
@ -853,8 +837,6 @@ static int cs4270_soc_resume(struct platform_device *pdev)
return snd_soc_write(codec, CS4270_PWRCTL, reg); return snd_soc_write(codec, CS4270_PWRCTL, reg);
} }
#else #else
#define cs4270_i2c_suspend NULL
#define cs4270_i2c_resume NULL
#define cs4270_soc_suspend NULL #define cs4270_soc_suspend NULL
#define cs4270_soc_resume NULL #define cs4270_soc_resume NULL
#endif /* CONFIG_PM */ #endif /* CONFIG_PM */
@ -873,8 +855,6 @@ static struct i2c_driver cs4270_i2c_driver = {
.id_table = cs4270_id, .id_table = cs4270_id,
.probe = cs4270_i2c_probe, .probe = cs4270_i2c_probe,
.remove = cs4270_i2c_remove, .remove = cs4270_i2c_remove,
.suspend = cs4270_i2c_suspend,
.resume = cs4270_i2c_resume,
}; };
/* /*

17
sound/soc/codecs/wm8350.c
View file

@ -1680,21 +1680,6 @@ static int __devexit wm8350_codec_remove(struct platform_device *pdev)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8350_codec_suspend(struct platform_device *pdev, pm_message_t m)
{
return snd_soc_suspend_device(&pdev->dev);
}
static int wm8350_codec_resume(struct platform_device *pdev)
{
return snd_soc_resume_device(&pdev->dev);
}
#else
#define wm8350_codec_suspend NULL
#define wm8350_codec_resume NULL
#endif
static struct platform_driver wm8350_codec_driver = { static struct platform_driver wm8350_codec_driver = {
.driver = { .driver = {
.name = "wm8350-codec", .name = "wm8350-codec",
@ -1702,8 +1687,6 @@ static struct platform_driver wm8350_codec_driver = {
}, },
.probe = wm8350_codec_probe, .probe = wm8350_codec_probe,
.remove = __devexit_p(wm8350_codec_remove), .remove = __devexit_p(wm8350_codec_remove),
.suspend = wm8350_codec_suspend,
.resume = wm8350_codec_resume,
}; };
static __init int wm8350_init(void) static __init int wm8350_init(void)

17
sound/soc/codecs/wm8400.c
View file

@ -1559,21 +1559,6 @@ static int __exit wm8400_codec_remove(struct platform_device *dev)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8400_pdev_suspend(struct platform_device *pdev, pm_message_t msg)
{
return snd_soc_suspend_device(&pdev->dev);
}
static int wm8400_pdev_resume(struct platform_device *pdev)
{
return snd_soc_resume_device(&pdev->dev);
}
#else
#define wm8400_pdev_suspend NULL
#define wm8400_pdev_resume NULL
#endif
static struct platform_driver wm8400_codec_driver = { static struct platform_driver wm8400_codec_driver = {
.driver = { .driver = {
.name = "wm8400-codec", .name = "wm8400-codec",
@ -1581,8 +1566,6 @@ static struct platform_driver wm8400_codec_driver = {
}, },
.probe = wm8400_codec_probe, .probe = wm8400_codec_probe,
.remove = __exit_p(wm8400_codec_remove), .remove = __exit_p(wm8400_codec_remove),
.suspend = wm8400_pdev_suspend,
.resume = wm8400_pdev_resume,
}; };
static int __init wm8400_codec_init(void) static int __init wm8400_codec_init(void)

17
sound/soc/codecs/wm8523.c
View file

@ -638,21 +638,6 @@ static __devexit int wm8523_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8523_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
{
return snd_soc_suspend_device(&i2c->dev);
}
static int wm8523_i2c_resume(struct i2c_client *i2c)
{
return snd_soc_resume_device(&i2c->dev);
}
#else
#define wm8523_i2c_suspend NULL
#define wm8523_i2c_resume NULL
#endif
static const struct i2c_device_id wm8523_i2c_id[] = { static const struct i2c_device_id wm8523_i2c_id[] = {
{ "wm8523", 0 }, { "wm8523", 0 },
{ } { }
@ -666,8 +651,6 @@ static struct i2c_driver wm8523_i2c_driver = {
}, },
.probe = wm8523_i2c_probe, .probe = wm8523_i2c_probe,
.remove = __devexit_p(wm8523_i2c_remove), .remove = __devexit_p(wm8523_i2c_remove),
.suspend = wm8523_i2c_suspend,
.resume = wm8523_i2c_resume,
.id_table = wm8523_i2c_id, .id_table = wm8523_i2c_id,
}; };
#endif #endif

17
sound/soc/codecs/wm8580.c
View file

@ -961,21 +961,6 @@ static int wm8580_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8580_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8580_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8580_i2c_suspend NULL
#define wm8580_i2c_resume NULL
#endif
static const struct i2c_device_id wm8580_i2c_id[] = { static const struct i2c_device_id wm8580_i2c_id[] = {
{ "wm8580", 0 }, { "wm8580", 0 },
{ } { }
@ -989,8 +974,6 @@ static struct i2c_driver wm8580_i2c_driver = {
}, },
.probe = wm8580_i2c_probe, .probe = wm8580_i2c_probe,
.remove = wm8580_i2c_remove, .remove = wm8580_i2c_remove,
.suspend = wm8580_i2c_suspend,
.resume = wm8580_i2c_resume,
.id_table = wm8580_i2c_id, .id_table = wm8580_i2c_id,
}; };
#endif #endif

17
sound/soc/codecs/wm8711.c
View file

@ -548,21 +548,6 @@ static int __devexit wm8711_spi_remove(struct spi_device *spi)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8711_spi_suspend(struct spi_device *spi, pm_message_t msg)
{
return snd_soc_suspend_device(&spi->dev);
}
static int wm8711_spi_resume(struct spi_device *spi)
{
return snd_soc_resume_device(&spi->dev);
}
#else
#define wm8711_spi_suspend NULL
#define wm8711_spi_resume NULL
#endif
static struct spi_driver wm8711_spi_driver = { static struct spi_driver wm8711_spi_driver = {
.driver = { .driver = {
.name = "wm8711", .name = "wm8711",
@ -570,8 +555,6 @@ static struct spi_driver wm8711_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.probe = wm8711_spi_probe, .probe = wm8711_spi_probe,
.suspend = wm8711_spi_suspend,
.resume = wm8711_spi_resume,
.remove = __devexit_p(wm8711_spi_remove), .remove = __devexit_p(wm8711_spi_remove),
}; };
#endif /* CONFIG_SPI_MASTER */ #endif /* CONFIG_SPI_MASTER */

34
sound/soc/codecs/wm8731.c
View file

@ -623,21 +623,6 @@ static int __devexit wm8731_spi_remove(struct spi_device *spi)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8731_spi_suspend(struct spi_device *spi, pm_message_t msg)
{
return snd_soc_suspend_device(&spi->dev);
}
static int wm8731_spi_resume(struct spi_device *spi)
{
return snd_soc_resume_device(&spi->dev);
}
#else
#define wm8731_spi_suspend NULL
#define wm8731_spi_resume NULL
#endif
static struct spi_driver wm8731_spi_driver = { static struct spi_driver wm8731_spi_driver = {
.driver = { .driver = {
.name = "wm8731", .name = "wm8731",
@ -645,8 +630,6 @@ static struct spi_driver wm8731_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.probe = wm8731_spi_probe, .probe = wm8731_spi_probe,
.suspend = wm8731_spi_suspend,
.resume = wm8731_spi_resume,
.remove = __devexit_p(wm8731_spi_remove), .remove = __devexit_p(wm8731_spi_remove),
}; };
#endif /* CONFIG_SPI_MASTER */ #endif /* CONFIG_SPI_MASTER */
@ -679,21 +662,6 @@ static __devexit int wm8731_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8731_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
{
return snd_soc_suspend_device(&i2c->dev);
}
static int wm8731_i2c_resume(struct i2c_client *i2c)
{
return snd_soc_resume_device(&i2c->dev);
}
#else
#define wm8731_i2c_suspend NULL
#define wm8731_i2c_resume NULL
#endif
static const struct i2c_device_id wm8731_i2c_id[] = { static const struct i2c_device_id wm8731_i2c_id[] = {
{ "wm8731", 0 }, { "wm8731", 0 },
{ } { }
@ -707,8 +675,6 @@ static struct i2c_driver wm8731_i2c_driver = {
}, },
.probe = wm8731_i2c_probe, .probe = wm8731_i2c_probe,
.remove = __devexit_p(wm8731_i2c_remove), .remove = __devexit_p(wm8731_i2c_remove),
.suspend = wm8731_i2c_suspend,
.resume = wm8731_i2c_resume,
.id_table = wm8731_i2c_id, .id_table = wm8731_i2c_id,
}; };
#endif #endif

35
sound/soc/codecs/wm8753.c
View file

@ -1767,21 +1767,6 @@ static int wm8753_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8753_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8753_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8753_i2c_suspend NULL
#define wm8753_i2c_resume NULL
#endif
static const struct i2c_device_id wm8753_i2c_id[] = { static const struct i2c_device_id wm8753_i2c_id[] = {
{ "wm8753", 0 }, { "wm8753", 0 },
{ } { }
@ -1795,8 +1780,6 @@ static struct i2c_driver wm8753_i2c_driver = {
}, },
.probe = wm8753_i2c_probe, .probe = wm8753_i2c_probe,
.remove = wm8753_i2c_remove, .remove = wm8753_i2c_remove,
.suspend = wm8753_i2c_suspend,
.resume = wm8753_i2c_resume,
.id_table = wm8753_i2c_id, .id_table = wm8753_i2c_id,
}; };
#endif #endif
@ -1852,22 +1835,6 @@ static int __devexit wm8753_spi_remove(struct spi_device *spi)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8753_spi_suspend(struct spi_device *spi, pm_message_t msg)
{
return snd_soc_suspend_device(&spi->dev);
}
static int wm8753_spi_resume(struct spi_device *spi)
{
return snd_soc_resume_device(&spi->dev);
}
#else
#define wm8753_spi_suspend NULL
#define wm8753_spi_resume NULL
#endif
static struct spi_driver wm8753_spi_driver = { static struct spi_driver wm8753_spi_driver = {
.driver = { .driver = {
.name = "wm8753", .name = "wm8753",
@ -1876,8 +1843,6 @@ static struct spi_driver wm8753_spi_driver = {
}, },
.probe = wm8753_spi_probe, .probe = wm8753_spi_probe,
.remove = __devexit_p(wm8753_spi_remove), .remove = __devexit_p(wm8753_spi_remove),
.suspend = wm8753_spi_suspend,
.resume = wm8753_spi_resume,
}; };
#endif #endif

34
sound/soc/codecs/wm8776.c
View file

@ -616,21 +616,6 @@ static int __devexit wm8776_spi_remove(struct spi_device *spi)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8776_spi_suspend(struct spi_device *spi, pm_message_t msg)
{
return snd_soc_suspend_device(&spi->dev);
}
static int wm8776_spi_resume(struct spi_device *spi)
{
return snd_soc_resume_device(&spi->dev);
}
#else
#define wm8776_spi_suspend NULL
#define wm8776_spi_resume NULL
#endif
static struct spi_driver wm8776_spi_driver = { static struct spi_driver wm8776_spi_driver = {
.driver = { .driver = {
.name = "wm8776", .name = "wm8776",
@ -638,8 +623,6 @@ static struct spi_driver wm8776_spi_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}, },
.probe = wm8776_spi_probe, .probe = wm8776_spi_probe,
.suspend = wm8776_spi_suspend,
.resume = wm8776_spi_resume,
.remove = __devexit_p(wm8776_spi_remove), .remove = __devexit_p(wm8776_spi_remove),
}; };
#endif /* CONFIG_SPI_MASTER */ #endif /* CONFIG_SPI_MASTER */
@ -673,21 +656,6 @@ static __devexit int wm8776_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8776_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
{
return snd_soc_suspend_device(&i2c->dev);
}
static int wm8776_i2c_resume(struct i2c_client *i2c)
{
return snd_soc_resume_device(&i2c->dev);
}
#else
#define wm8776_i2c_suspend NULL
#define wm8776_i2c_resume NULL
#endif
static const struct i2c_device_id wm8776_i2c_id[] = { static const struct i2c_device_id wm8776_i2c_id[] = {
{ "wm8776", 0 }, { "wm8776", 0 },
{ } { }
@ -701,8 +669,6 @@ static struct i2c_driver wm8776_i2c_driver = {
}, },
.probe = wm8776_i2c_probe, .probe = wm8776_i2c_probe,
.remove = __devexit_p(wm8776_i2c_remove), .remove = __devexit_p(wm8776_i2c_remove),
.suspend = wm8776_i2c_suspend,
.resume = wm8776_i2c_resume,
.id_table = wm8776_i2c_id, .id_table = wm8776_i2c_id,
}; };
#endif #endif

17
sound/soc/codecs/wm8900.c
View file

@ -1312,21 +1312,6 @@ static __devexit int wm8900_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8900_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8900_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8900_i2c_suspend NULL
#define wm8900_i2c_resume NULL
#endif
static const struct i2c_device_id wm8900_i2c_id[] = { static const struct i2c_device_id wm8900_i2c_id[] = {
{ "wm8900", 0 }, { "wm8900", 0 },
{ } { }
@ -1340,8 +1325,6 @@ static struct i2c_driver wm8900_i2c_driver = {
}, },
.probe = wm8900_i2c_probe, .probe = wm8900_i2c_probe,
.remove = __devexit_p(wm8900_i2c_remove), .remove = __devexit_p(wm8900_i2c_remove),
.suspend = wm8900_i2c_suspend,
.resume = wm8900_i2c_resume,
.id_table = wm8900_i2c_id, .id_table = wm8900_i2c_id,
}; };

17
sound/soc/codecs/wm8903.c
View file

@ -1655,21 +1655,6 @@ static __devexit int wm8903_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8903_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8903_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8903_i2c_suspend NULL
#define wm8903_i2c_resume NULL
#endif
/* i2c codec control layer */ /* i2c codec control layer */
static const struct i2c_device_id wm8903_i2c_id[] = { static const struct i2c_device_id wm8903_i2c_id[] = {
{ "wm8903", 0 }, { "wm8903", 0 },
@ -1684,8 +1669,6 @@ static struct i2c_driver wm8903_i2c_driver = {
}, },
.probe = wm8903_i2c_probe, .probe = wm8903_i2c_probe,
.remove = __devexit_p(wm8903_i2c_remove), .remove = __devexit_p(wm8903_i2c_remove),
.suspend = wm8903_i2c_suspend,
.resume = wm8903_i2c_resume,
.id_table = wm8903_i2c_id, .id_table = wm8903_i2c_id,
}; };

17
sound/soc/codecs/wm8940.c
View file

@ -877,21 +877,6 @@ static int __devexit wm8940_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8940_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8940_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8940_i2c_suspend NULL
#define wm8940_i2c_resume NULL
#endif
static const struct i2c_device_id wm8940_i2c_id[] = { static const struct i2c_device_id wm8940_i2c_id[] = {
{ "wm8940", 0 }, { "wm8940", 0 },
{ } { }
@ -905,8 +890,6 @@ static struct i2c_driver wm8940_i2c_driver = {
}, },
.probe = wm8940_i2c_probe, .probe = wm8940_i2c_probe,
.remove = __devexit_p(wm8940_i2c_remove), .remove = __devexit_p(wm8940_i2c_remove),
.suspend = wm8940_i2c_suspend,
.resume = wm8940_i2c_resume,
.id_table = wm8940_i2c_id, .id_table = wm8940_i2c_id,
}; };

17
sound/soc/codecs/wm8960.c
View file

@ -883,21 +883,6 @@ static __devexit int wm8960_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8960_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8960_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8960_i2c_suspend NULL
#define wm8960_i2c_resume NULL
#endif
static const struct i2c_device_id wm8960_i2c_id[] = { static const struct i2c_device_id wm8960_i2c_id[] = {
{ "wm8960", 0 }, { "wm8960", 0 },
{ } { }
@ -911,8 +896,6 @@ static struct i2c_driver wm8960_i2c_driver = {
}, },
.probe = wm8960_i2c_probe, .probe = wm8960_i2c_probe,
.remove = __devexit_p(wm8960_i2c_remove), .remove = __devexit_p(wm8960_i2c_remove),
.suspend = wm8960_i2c_suspend,
.resume = wm8960_i2c_resume,
.id_table = wm8960_i2c_id, .id_table = wm8960_i2c_id,
}; };

17
sound/soc/codecs/wm8961.c
View file

@ -1206,21 +1206,6 @@ static __devexit int wm8961_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8961_i2c_suspend(struct i2c_client *client, pm_message_t state)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8961_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8961_i2c_suspend NULL
#define wm8961_i2c_resume NULL
#endif
static const struct i2c_device_id wm8961_i2c_id[] = { static const struct i2c_device_id wm8961_i2c_id[] = {
{ "wm8961", 0 }, { "wm8961", 0 },
{ } { }
@ -1234,8 +1219,6 @@ static struct i2c_driver wm8961_i2c_driver = {
}, },
.probe = wm8961_i2c_probe, .probe = wm8961_i2c_probe,
.remove = __devexit_p(wm8961_i2c_remove), .remove = __devexit_p(wm8961_i2c_remove),
.suspend = wm8961_i2c_suspend,
.resume = wm8961_i2c_resume,
.id_table = wm8961_i2c_id, .id_table = wm8961_i2c_id,
}; };

34
sound/soc/codecs/wm8988.c
View file

@ -944,21 +944,6 @@ static int wm8988_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8988_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm8988_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm8988_i2c_suspend NULL
#define wm8988_i2c_resume NULL
#endif
static const struct i2c_device_id wm8988_i2c_id[] = { static const struct i2c_device_id wm8988_i2c_id[] = {
{ "wm8988", 0 }, { "wm8988", 0 },
{ } { }
@ -972,8 +957,6 @@ static struct i2c_driver wm8988_i2c_driver = {
}, },
.probe = wm8988_i2c_probe, .probe = wm8988_i2c_probe,
.remove = wm8988_i2c_remove, .remove = wm8988_i2c_remove,
.suspend = wm8988_i2c_suspend,
.resume = wm8988_i2c_resume,
.id_table = wm8988_i2c_id, .id_table = wm8988_i2c_id,
}; };
#endif #endif
@ -1006,21 +989,6 @@ static int __devexit wm8988_spi_remove(struct spi_device *spi)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm8988_spi_suspend(struct spi_device *spi, pm_message_t msg)
{
return snd_soc_suspend_device(&spi->dev);
}
static int wm8988_spi_resume(struct spi_device *spi)
{
return snd_soc_resume_device(&spi->dev);
}
#else
#define wm8988_spi_suspend NULL
#define wm8988_spi_resume NULL
#endif
static struct spi_driver wm8988_spi_driver = { static struct spi_driver wm8988_spi_driver = {
.driver = { .driver = {
.name = "wm8988", .name = "wm8988",
@ -1029,8 +997,6 @@ static struct spi_driver wm8988_spi_driver = {
}, },
.probe = wm8988_spi_probe, .probe = wm8988_spi_probe,
.remove = __devexit_p(wm8988_spi_remove), .remove = __devexit_p(wm8988_spi_remove),
.suspend = wm8988_spi_suspend,
.resume = wm8988_spi_resume,
}; };
#endif #endif

17
sound/soc/codecs/wm9081.c
View file

@ -1452,21 +1452,6 @@ static __devexit int wm9081_i2c_remove(struct i2c_client *client)
return 0; return 0;
} }
#ifdef CONFIG_PM
static int wm9081_i2c_suspend(struct i2c_client *client, pm_message_t msg)
{
return snd_soc_suspend_device(&client->dev);
}
static int wm9081_i2c_resume(struct i2c_client *client)
{
return snd_soc_resume_device(&client->dev);
}
#else
#define wm9081_i2c_suspend NULL
#define wm9081_i2c_resume NULL
#endif
static const struct i2c_device_id wm9081_i2c_id[] = { static const struct i2c_device_id wm9081_i2c_id[] = {
{ "wm9081", 0 }, { "wm9081", 0 },
{ } { }
@ -1480,8 +1465,6 @@ static struct i2c_driver wm9081_i2c_driver = {
}, },
.probe = wm9081_i2c_probe, .probe = wm9081_i2c_probe,
.remove = __devexit_p(wm9081_i2c_remove), .remove = __devexit_p(wm9081_i2c_remove),
.suspend = wm9081_i2c_suspend,
.resume = wm9081_i2c_resume,
.id_table = wm9081_i2c_id, .id_table = wm9081_i2c_id,
}; };

39
sound/soc/soc-core.c
View file

@ -790,45 +790,6 @@ static int soc_resume(struct device *dev)
return 0; return 0;
} }
/**
* snd_soc_suspend_device: Notify core of device suspend
*
* @dev: Device being suspended.
*
* In order to ensure that the entire audio subsystem is suspended in a
* coordinated fashion ASoC devices should suspend themselves when
* called by ASoC. When the standard kernel suspend process asks the
* device to suspend it should call this function to initiate a suspend
* of the entire ASoC card.
*
* \note Currently this function is stubbed out.
*/
int snd_soc_suspend_device(struct device *dev)
{
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_suspend_device);
/**
* snd_soc_resume_device: Notify core of device resume
*
* @dev: Device being resumed.
*
* In order to ensure that the entire audio subsystem is resumed in a
* coordinated fashion ASoC devices should resume themselves when called
* by ASoC. When the standard kernel resume process asks the device
* to resume it should call this function. Once all the components of
* the card have notified that they are ready to be resumed the card
* will be resumed.
*
* \note Currently this function is stubbed out.
*/
int snd_soc_resume_device(struct device *dev)
{
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_resume_device);
#else #else
#define soc_suspend NULL #define soc_suspend NULL
#define soc_resume NULL #define soc_resume NULL