Merge branch 'upstream' into topic/asoc
Takashi Iwai [Mon, 1 Dec 2008 17:02:17 +0000 (18:02 +0100)]
1  2 
MAINTAINERS
sound/soc/soc-core.c

diff --combined MAINTAINERS
@@@ -347,7 -347,7 +347,7 @@@ S: Maintaine
  ALI1563 I2C DRIVER
  P:    Rudolf Marek
  M:    r.marek@assembler.cz
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  ALPHA PORT
@@@ -610,6 -610,11 +610,11 @@@ P:       Philipp Zabe
  M:    philipp.zabel@gmail.com
  S:    Maintained
  
+ ARM/NEC MOBILEPRO 900/c MACHINE SUPPORT
+ P:    Michael Petchkovsky
+ M:    mkpetch@internode.on.net
+ S:    Maintained
  ARM/TOSA MACHINE SUPPORT
  P:    Dmitry Baryshkov
  M:    dbaryshkov@gmail.com
@@@ -716,7 -721,7 +721,7 @@@ W: http://sourceforge.net/projects/acpi
  W:    http://xf.iksaif.net/acpi4asus
  S:    Maintained
  
- ASYNCHRONOUS TRANSFERS/TRANSFORMS API
+ ASYNCHRONOUS TRANSFERS/TRANSFORMS (IOAT) API
  P:    Dan Williams
  M:    dan.j.williams@intel.com
  P:    Maciej Sosnowski
@@@ -738,6 -743,8 +743,8 @@@ P: Nick Kossifidi
  M:    mickflemm@gmail.com
  P:    Luis R. Rodriguez
  M:    mcgrof@gmail.com
+ P:    Bob Copeland
+ M:    me@bobcopeland.com
  L:    linux-wireless@vger.kernel.org
  L:    ath5k-devel@lists.ath5k.org
  S:    Maintained
@@@ -1749,7 -1756,7 +1756,7 @@@ FREESCALE I2C CPM DRIVE
  P:    Jochen Friedrich
  M:    jochen@scram.de
  L:    linuxppc-dev@ozlabs.org
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  FREESCALE SOC FS_ENET DRIVER
@@@ -1802,7 -1809,7 +1809,7 @@@ S:      Maintaine
  
  FTRACE
  P:    Steven Rostedt
- M:    srostedt@redhat.com
+ M:    rostedt@goodmis.org
  S:    Maintained
  
  FUJITSU FR-V (FRV) PORT
@@@ -1872,6 -1879,37 +1879,37 @@@ M:    linux-kernel@vger.kernel.or
  W:    http://www.kernel.org/pub/linux/kernel/people/rml/hdaps/
  S:    Maintained
  
+ GSPCA FINEPIX SUBDRIVER
+ P:    Frank Zago
+ M:    frank@zago.net
+ L:    video4linux-list@redhat.com
+ S:    Maintained
+ GSPCA M5602 SUBDRIVER
+ P:    Erik Andren
+ M:    erik.andren@gmail.com
+ L:    video4linux-list@redhat.com
+ S:    Maintained
+ GSPCA PAC207 SONIXB SUBDRIVER
+ P:    Hans de Goede
+ M:    hdegoede@redhat.com
+ L:    video4linux-list@redhat.com
+ S:    Maintained
+ GSPCA T613 SUBDRIVER
+ P:    Leandro Costantino
+ M:    lcostantino@gmail.com
+ L:    video4linux-list@redhat.com
+ S:    Maintained
+ GSPCA USB WEBCAM DRIVER
+ P:    Jean-Francois Moine
+ M:    moinejf@free.fr
+ W:    http://moinejf.free.fr
+ L:    video4linux-list@redhat.com
+ S:    Maintained
  HARDWARE MONITORING
  L:    lm-sensors@lm-sensors.org
  W:    http://www.lm-sensors.org/
@@@ -2022,7 -2060,7 +2060,7 @@@ S:      Maintaine
  I2C/SMBUS STUB DRIVER
  P:    Mark M. Hoffman
  M:    mhoffman@lightlink.com
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  I2C SUBSYSTEM
@@@ -2030,14 -2068,14 +2068,14 @@@ P:   Jean Delvare (PC drivers, core
  M:    khali@linux-fr.org
  P:    Ben Dooks (embedded platforms)
  M:    ben-linux@fluff.org
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  T:    quilt http://khali.linux-fr.org/devel/linux-2.6/jdelvare-i2c/
  S:    Maintained
  
  I2C-TINY-USB DRIVER
  P:    Till Harbaum
  M:    till@harbaum.org
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  T:    http://www.harbaum.org/till/i2c_tiny_usb
  S:    Maintained
  
@@@ -2178,6 -2216,13 +2216,13 @@@ M:    adaplas@gmail.co
  L:    linux-fbdev-devel@lists.sourceforge.net (moderated for non-subscribers)
  S:    Maintained
  
+ INTEL MENLOW THERMAL DRIVER
+ P:    Sujith Thomas
+ M:    sujith.thomas@intel.com
+ L:    linux-acpi@vger.kernel.org
+ W:    http://www.lesswatts.org/projects/acpi/
+ S:    Supported
  INTEL IA32 MICROCODE UPDATE SUPPORT
  P:    Tigran Aivazian
  M:    tigran@aivazian.fsnet.co.uk
@@@ -2658,6 -2703,11 +2703,11 @@@ P:    Arnaldo Carvalho de Mel
  M:    acme@ghostprotocols.net
  S:    Maintained
  
+ LIS3LV02D ACCELEROMETER DRIVER
+ P:    Eric Piel
+ M:    eric.piel@tremplin-utc.net
+ S:    Maintained
  LM83 HARDWARE MONITOR DRIVER
  P:    Jean Delvare
  M:    khali@linux-fr.org
@@@ -2701,6 -2751,16 +2751,16 @@@ M:    matthew@wil.c
  L:    linux-scsi@vger.kernel.org
  S:    Maintained
  
+ LTP (Linux Test Project)
+ P:    Subrata Modak
+ M:    subrata@linux.vnet.ibm.com
+ P:    Mike Frysinger
+ M:    vapier@gentoo.org
+ L:    ltp-list@lists.sourceforge.net (subscribers-only)
+ W:    http://ltp.sourceforge.net/
+ T:    git kernel.org/pub/scm/linux/kernel/git/galak/ltp.git
+ S:    Maintained
  M32R ARCHITECTURE
  P:    Hirokazu Takata
  M:    takata@linux-m32r.org
@@@ -3143,7 -3203,7 +3203,7 @@@ S:      Maintaine
  OPENCORES I2C BUS DRIVER
  P:    Peter Korsgaard
  M:    jacmet@sunsite.dk
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  OPROFILE
@@@ -3190,7 -3250,7 +3250,7 @@@ S:      Maintaine
  PA SEMI SMBUS DRIVER
  P:    Olof Johansson
  M:    olof@lixom.net
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  PANASONIC LAPTOP ACPI EXTRAS DRIVER
@@@ -3329,13 -3389,15 +3389,15 @@@ S:   Maintaine
  
  PNP SUPPORT
  P:    Adam Belay
- M:    ambx1@neo.rr.com
+ M:    abelay@mit.edu
+ P:    Bjorn Helgaas
+ M:    bjorn.helgaas@hp.com
  S:    Maintained
  
  PNXxxxx I2C DRIVER
  P:    Vitaly Wool
  M:    vitalywool@gmail.com
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  PPP PROTOCOL DRIVERS AND COMPRESSORS
@@@ -3799,7 -3861,7 +3861,7 @@@ S:      Maintaine
  SIS 96X I2C/SMBUS DRIVER
  P:    Mark M. Hoffman
  M:    mhoffman@lightlink.com
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  SIS FRAMEBUFFER DRIVER
@@@ -3866,8 -3928,6 +3928,6 @@@ M:      bootc@bootc.ne
  S:    Maintained
  
  SOFTWARE RAID (Multiple Disks) SUPPORT
- P:    Ingo Molnar
- M:    mingo@redhat.com
  P:    Neil Brown
  M:    neilb@suse.de
  L:    linux-raid@vger.kernel.org
@@@ -3907,7 -3967,7 +3967,7 @@@ M:      tiwai@suse.d
  L:    alsa-devel@alsa-project.org (subscribers-only)
  S:    Maintained
  
 -SOUND - SOC LAYER / DYNAMIC AUDIO POWER MANAGEMENT
 +SOUND - SOC LAYER / DYNAMIC AUDIO POWER MANAGEMENT (ASoC)
  P:    Liam Girdwood
  M:    lrg@slimlogic.co.uk
  P:    Mark Brown
@@@ -4546,7 -4606,7 +4606,7 @@@ S:      Maintaine
  VIAPRO SMBUS DRIVER
  P:    Jean Delvare
  M:    khali@linux-fr.org
- L:    i2c@lm-sensors.org
+ L:    linux-i2c@vger.kernel.org
  S:    Maintained
  
  VIA UNICHROME(PRO)/CHROME9 FRAMEBUFFER DRIVER
diff --combined sound/soc/soc-core.c
@@@ -26,7 -26,6 +26,7 @@@
  #include <linux/delay.h>
  #include <linux/pm.h>
  #include <linux/bitops.h>
 +#include <linux/debugfs.h>
  #include <linux/platform_device.h>
  #include <sound/core.h>
  #include <sound/pcm.h>
  #include <sound/soc-dapm.h>
  #include <sound/initval.h>
  
 -/* debug */
 -#define SOC_DEBUG 0
 -#if SOC_DEBUG
 -#define dbg(format, arg...) printk(format, ## arg)
 -#else
 -#define dbg(format, arg...)
 -#endif
 -
  static DEFINE_MUTEX(pcm_mutex);
  static DEFINE_MUTEX(io_mutex);
  static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
@@@ -88,8 -95,8 +88,8 @@@ static int soc_ac97_dev_register(struc
        codec->ac97->dev.parent = NULL;
        codec->ac97->dev.release = soc_ac97_device_release;
  
-       snprintf(codec->ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
-                codec->card->number, 0, codec->name);
+       dev_set_name(&codec->ac97->dev, "%d-%d:%s",
+                    codec->card->number, 0, codec->name);
        err = device_register(&codec->ac97->dev);
        if (err < 0) {
                snd_printk(KERN_ERR "Can't register ac97 bus\n");
  }
  #endif
  
 -static inline const char *get_dai_name(int type)
 -{
 -      switch (type) {
 -      case SND_SOC_DAI_AC97_BUS:
 -      case SND_SOC_DAI_AC97:
 -              return "AC97";
 -      case SND_SOC_DAI_I2S:
 -              return "I2S";
 -      case SND_SOC_DAI_PCM:
 -              return "PCM";
 -      }
 -      return NULL;
 -}
 -
  /*
   * Called by ALSA when a PCM substream is opened, the runtime->hw record is
   * then initialized and any private data can be allocated. This also calls
@@@ -120,7 -141,7 +120,7 @@@ static int soc_pcm_open(struct snd_pcm_
  
        /* startup the audio subsystem */
        if (cpu_dai->ops.startup) {
 -              ret = cpu_dai->ops.startup(substream);
 +              ret = cpu_dai->ops.startup(substream, cpu_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: can't open interface %s\n",
                                cpu_dai->name);
        }
  
        if (codec_dai->ops.startup) {
 -              ret = codec_dai->ops.startup(substream);
 +              ret = codec_dai->ops.startup(substream, codec_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: can't open codec %s\n",
                                codec_dai->name);
                goto machine_err;
        }
  
 -      dbg("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
 -      dbg("asoc: rate mask 0x%x\n", runtime->hw.rates);
 -      dbg("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
 -              runtime->hw.channels_max);
 -      dbg("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
 -              runtime->hw.rate_max);
 +      pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
 +      pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
 +      pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
 +               runtime->hw.channels_max);
 +      pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
 +               runtime->hw.rate_max);
  
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                cpu_dai->playback.active = codec_dai->playback.active = 1;
@@@ -234,7 -255,7 +234,7 @@@ codec_dai_err
  
  platform_err:
        if (cpu_dai->ops.shutdown)
 -              cpu_dai->ops.shutdown(substream);
 +              cpu_dai->ops.shutdown(substream, cpu_dai);
  out:
        mutex_unlock(&pcm_mutex);
        return ret;
@@@ -257,18 -278,18 +257,18 @@@ static void close_delayed_work(struct w
        for (i = 0; i < codec->num_dai; i++) {
                codec_dai = &codec->dai[i];
  
 -              dbg("pop wq checking: %s status: %s waiting: %s\n",
 -                      codec_dai->playback.stream_name,
 -                      codec_dai->playback.active ? "active" : "inactive",
 -                      codec_dai->pop_wait ? "yes" : "no");
 +              pr_debug("pop wq checking: %s status: %s waiting: %s\n",
 +                       codec_dai->playback.stream_name,
 +                       codec_dai->playback.active ? "active" : "inactive",
 +                       codec_dai->pop_wait ? "yes" : "no");
  
                /* are we waiting on this codec DAI stream */
                if (codec_dai->pop_wait == 1) {
  
                        /* Reduce power if no longer active */
                        if (codec->active == 0) {
 -                              dbg("pop wq D1 %s %s\n", codec->name,
 -                                      codec_dai->playback.stream_name);
 +                              pr_debug("pop wq D1 %s %s\n", codec->name,
 +                                       codec_dai->playback.stream_name);
                                snd_soc_dapm_set_bias_level(socdev,
                                        SND_SOC_BIAS_PREPARE);
                        }
  
                        /* Fall into standby if no longer active */
                        if (codec->active == 0) {
 -                              dbg("pop wq D3 %s %s\n", codec->name,
 -                                      codec_dai->playback.stream_name);
 +                              pr_debug("pop wq D3 %s %s\n", codec->name,
 +                                       codec_dai->playback.stream_name);
                                snd_soc_dapm_set_bias_level(socdev,
                                        SND_SOC_BIAS_STANDBY);
                        }
@@@ -325,10 -346,10 +325,10 @@@ static int soc_codec_close(struct snd_p
                snd_soc_dai_digital_mute(codec_dai, 1);
  
        if (cpu_dai->ops.shutdown)
 -              cpu_dai->ops.shutdown(substream);
 +              cpu_dai->ops.shutdown(substream, cpu_dai);
  
        if (codec_dai->ops.shutdown)
 -              codec_dai->ops.shutdown(substream);
 +              codec_dai->ops.shutdown(substream, codec_dai);
  
        if (machine->ops && machine->ops->shutdown)
                machine->ops->shutdown(substream);
@@@ -392,7 -413,7 +392,7 @@@ static int soc_pcm_prepare(struct snd_p
        }
  
        if (codec_dai->ops.prepare) {
 -              ret = codec_dai->ops.prepare(substream);
 +              ret = codec_dai->ops.prepare(substream, codec_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: codec DAI prepare error\n");
                        goto out;
        }
  
        if (cpu_dai->ops.prepare) {
 -              ret = cpu_dai->ops.prepare(substream);
 +              ret = cpu_dai->ops.prepare(substream, cpu_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: cpu DAI prepare error\n");
                        goto out;
                }
        }
  
 -      /* we only want to start a DAPM playback stream if we are not waiting
 -       * on an existing one stopping */
 -      if (codec_dai->pop_wait) {
 -              /* we are waiting for the delayed work to start */
 -              if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 -                              snd_soc_dapm_stream_event(socdev->codec,
 -                                      codec_dai->capture.stream_name,
 -                                      SND_SOC_DAPM_STREAM_START);
 -              else {
 -                      codec_dai->pop_wait = 0;
 -                      cancel_delayed_work(&socdev->delayed_work);
 -                      snd_soc_dai_digital_mute(codec_dai, 0);
 -              }
 -      } else {
 -              /* no delayed work - do we need to power up codec */
 -              if (codec->bias_level != SND_SOC_BIAS_ON) {
 +      /* cancel any delayed stream shutdown that is pending */
 +      if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 +          codec_dai->pop_wait) {
 +              codec_dai->pop_wait = 0;
 +              cancel_delayed_work(&socdev->delayed_work);
 +      }
  
 -                      snd_soc_dapm_set_bias_level(socdev,
 -                                                  SND_SOC_BIAS_PREPARE);
 +      /* do we need to power up codec */
 +      if (codec->bias_level != SND_SOC_BIAS_ON) {
 +              snd_soc_dapm_set_bias_level(socdev,
 +                                          SND_SOC_BIAS_PREPARE);
  
 -                      if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 -                              snd_soc_dapm_stream_event(codec,
 +              if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 +                      snd_soc_dapm_stream_event(codec,
                                        codec_dai->playback.stream_name,
                                        SND_SOC_DAPM_STREAM_START);
 -                      else
 -                              snd_soc_dapm_stream_event(codec,
 +              else
 +                      snd_soc_dapm_stream_event(codec,
                                        codec_dai->capture.stream_name,
                                        SND_SOC_DAPM_STREAM_START);
  
 -                      snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_ON);
 -                      snd_soc_dai_digital_mute(codec_dai, 0);
 +              snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_ON);
 +              snd_soc_dai_digital_mute(codec_dai, 0);
  
 -              } else {
 -                      /* codec already powered - power on widgets */
 -                      if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 -                              snd_soc_dapm_stream_event(codec,
 +      } else {
 +              /* codec already powered - power on widgets */
 +              if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 +                      snd_soc_dapm_stream_event(codec,
                                        codec_dai->playback.stream_name,
                                        SND_SOC_DAPM_STREAM_START);
 -                      else
 -                              snd_soc_dapm_stream_event(codec,
 +              else
 +                      snd_soc_dapm_stream_event(codec,
                                        codec_dai->capture.stream_name,
                                        SND_SOC_DAPM_STREAM_START);
  
 -                      snd_soc_dai_digital_mute(codec_dai, 0);
 -              }
 +              snd_soc_dai_digital_mute(codec_dai, 0);
        }
  
  out:
@@@ -477,7 -507,7 +477,7 @@@ static int soc_pcm_hw_params(struct snd
        }
  
        if (codec_dai->ops.hw_params) {
 -              ret = codec_dai->ops.hw_params(substream, params);
 +              ret = codec_dai->ops.hw_params(substream, params, codec_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: can't set codec %s hw params\n",
                                codec_dai->name);
        }
  
        if (cpu_dai->ops.hw_params) {
 -              ret = cpu_dai->ops.hw_params(substream, params);
 +              ret = cpu_dai->ops.hw_params(substream, params, cpu_dai);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: interface %s hw params failed\n",
                                cpu_dai->name);
@@@ -509,11 -539,11 +509,11 @@@ out
  
  platform_err:
        if (cpu_dai->ops.hw_free)
 -              cpu_dai->ops.hw_free(substream);
 +              cpu_dai->ops.hw_free(substream, cpu_dai);
  
  interface_err:
        if (codec_dai->ops.hw_free)
 -              codec_dai->ops.hw_free(substream);
 +              codec_dai->ops.hw_free(substream, codec_dai);
  
  codec_err:
        if (machine->ops && machine->ops->hw_free)
@@@ -552,10 -582,10 +552,10 @@@ static int soc_pcm_hw_free(struct snd_p
  
        /* now free hw params for the DAI's  */
        if (codec_dai->ops.hw_free)
 -              codec_dai->ops.hw_free(substream);
 +              codec_dai->ops.hw_free(substream, codec_dai);
  
        if (cpu_dai->ops.hw_free)
 -              cpu_dai->ops.hw_free(substream);
 +              cpu_dai->ops.hw_free(substream, cpu_dai);
  
        mutex_unlock(&pcm_mutex);
        return 0;
@@@ -572,7 -602,7 +572,7 @@@ static int soc_pcm_trigger(struct snd_p
        int ret;
  
        if (codec_dai->ops.trigger) {
 -              ret = codec_dai->ops.trigger(substream, cmd);
 +              ret = codec_dai->ops.trigger(substream, cmd, codec_dai);
                if (ret < 0)
                        return ret;
        }
        }
  
        if (cpu_dai->ops.trigger) {
 -              ret = cpu_dai->ops.trigger(substream, cmd);
 +              ret = cpu_dai->ops.trigger(substream, cmd, cpu_dai);
                if (ret < 0)
                        return ret;
        }
@@@ -606,7 -636,7 +606,7 @@@ static struct snd_pcm_ops soc_pcm_ops 
  static int soc_suspend(struct platform_device *pdev, pm_message_t state)
  {
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        struct snd_soc_platform *platform = socdev->platform;
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
        struct snd_soc_codec *codec = socdev->codec;
        snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
  
        /* mute any active DAC's */
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
 -              if (dai->dai_ops.digital_mute && dai->playback.active)
 -                      dai->dai_ops.digital_mute(dai, 1);
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
 +              if (dai->ops.digital_mute && dai->playback.active)
 +                      dai->ops.digital_mute(dai, 1);
        }
  
        /* suspend all pcms */
 -      for (i = 0; i < machine->num_links; i++)
 -              snd_pcm_suspend_all(machine->dai_link[i].pcm);
 +      for (i = 0; i < card->num_links; i++)
 +              snd_pcm_suspend_all(card->dai_link[i].pcm);
  
 -      if (machine->suspend_pre)
 -              machine->suspend_pre(pdev, state);
 +      if (card->suspend_pre)
 +              card->suspend_pre(pdev, state);
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai  *cpu_dai = machine->dai_link[i].cpu_dai;
 -              if (cpu_dai->suspend && cpu_dai->type != SND_SOC_DAI_AC97)
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai  *cpu_dai = card->dai_link[i].cpu_dai;
 +              if (cpu_dai->suspend && !cpu_dai->ac97_control)
                        cpu_dai->suspend(pdev, cpu_dai);
                if (platform->suspend)
                        platform->suspend(pdev, cpu_dai);
        if (codec_dev->suspend)
                codec_dev->suspend(pdev, state);
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 -              if (cpu_dai->suspend && cpu_dai->type == SND_SOC_DAI_AC97)
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
 +              if (cpu_dai->suspend && cpu_dai->ac97_control)
                        cpu_dai->suspend(pdev, cpu_dai);
        }
  
 -      if (machine->suspend_post)
 -              machine->suspend_post(pdev, state);
 +      if (card->suspend_post)
 +              card->suspend_post(pdev, state);
  
        return 0;
  }
@@@ -682,7 -712,7 +682,7 @@@ static void soc_resume_deferred(struct 
        struct snd_soc_device *socdev = container_of(work,
                                                     struct snd_soc_device,
                                                     deferred_resume_work);
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        struct snd_soc_platform *platform = socdev->platform;
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
        struct snd_soc_codec *codec = socdev->codec;
         * so userspace apps are blocked from touching us
         */
  
 -      dev_info(socdev->dev, "starting resume work\n");
 +      dev_dbg(socdev->dev, "starting resume work\n");
  
 -      if (machine->resume_pre)
 -              machine->resume_pre(pdev);
 +      if (card->resume_pre)
 +              card->resume_pre(pdev);
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 -              if (cpu_dai->resume && cpu_dai->type == SND_SOC_DAI_AC97)
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
 +              if (cpu_dai->resume && cpu_dai->ac97_control)
                        cpu_dai->resume(pdev, cpu_dai);
        }
  
        }
  
        /* unmute any active DACs */
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
 -              if (dai->dai_ops.digital_mute && dai->playback.active)
 -                      dai->dai_ops.digital_mute(dai, 0);
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
 +              if (dai->ops.digital_mute && dai->playback.active)
 +                      dai->ops.digital_mute(dai, 0);
        }
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 -              if (cpu_dai->resume && cpu_dai->type != SND_SOC_DAI_AC97)
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
 +              if (cpu_dai->resume && !cpu_dai->ac97_control)
                        cpu_dai->resume(pdev, cpu_dai);
                if (platform->resume)
                        platform->resume(pdev, cpu_dai);
        }
  
 -      if (machine->resume_post)
 -              machine->resume_post(pdev);
 +      if (card->resume_post)
 +              card->resume_post(pdev);
  
 -      dev_info(socdev->dev, "resume work completed\n");
 +      dev_dbg(socdev->dev, "resume work completed\n");
  
        /* userspace can access us now we are back as we were before */
        snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
@@@ -747,10 -777,10 +747,10 @@@ static int soc_resume(struct platform_d
  {
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  
 -      dev_info(socdev->dev, "scheduling resume work\n");
 +      dev_dbg(socdev->dev, "scheduling resume work\n");
  
        if (!schedule_work(&socdev->deferred_resume_work))
 -              dev_err(socdev->dev, "work item may be lost\n");
 +              dev_err(socdev->dev, "resume work item may be lost\n");
  
        return 0;
  }
@@@ -765,18 -795,18 +765,18 @@@ static int soc_probe(struct platform_de
  {
        int ret = 0, i;
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        struct snd_soc_platform *platform = socdev->platform;
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
  
 -      if (machine->probe) {
 -              ret = machine->probe(pdev);
 +      if (card->probe) {
 +              ret = card->probe(pdev);
                if (ret < 0)
                        return ret;
        }
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
                if (cpu_dai->probe) {
                        ret = cpu_dai->probe(pdev, cpu_dai);
                        if (ret < 0)
@@@ -811,13 -841,13 +811,13 @@@ platform_err
  
  cpu_dai_err:
        for (i--; i >= 0; i--) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
                if (cpu_dai->remove)
                        cpu_dai->remove(pdev, cpu_dai);
        }
  
 -      if (machine->remove)
 -              machine->remove(pdev);
 +      if (card->remove)
 +              card->remove(pdev);
  
        return ret;
  }
@@@ -827,7 -857,7 +827,7 @@@ static int soc_remove(struct platform_d
  {
        int i;
        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        struct snd_soc_platform *platform = socdev->platform;
        struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
  
        if (codec_dev->remove)
                codec_dev->remove(pdev);
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 +      for (i = 0; i < card->num_links; i++) {
 +              struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
                if (cpu_dai->remove)
                        cpu_dai->remove(pdev, cpu_dai);
        }
  
 -      if (machine->remove)
 -              machine->remove(pdev);
 +      if (card->remove)
 +              card->remove(pdev);
  
        return 0;
  }
@@@ -884,8 -914,8 +884,8 @@@ static int soc_new_pcm(struct snd_soc_d
        codec_dai->codec = socdev->codec;
  
        /* check client and interface hw capabilities */
 -      sprintf(new_name, "%s %s-%s-%d", dai_link->stream_name, codec_dai->name,
 -              get_dai_name(cpu_dai->type), num);
 +      sprintf(new_name, "%s %s-%d", dai_link->stream_name, codec_dai->name,
 +              num);
  
        if (codec_dai->playback.channels_min)
                playback = 1;
  }
  
  /* codec register dump */
 -static ssize_t codec_reg_show(struct device *dev,
 -      struct device_attribute *attr, char *buf)
 +static ssize_t soc_codec_reg_show(struct snd_soc_device *devdata, char *buf)
  {
 -      struct snd_soc_device *devdata = dev_get_drvdata(dev);
        struct snd_soc_codec *codec = devdata->codec;
        int i, step = 1, count = 0;
  
  
        return count;
  }
 +static ssize_t codec_reg_show(struct device *dev,
 +      struct device_attribute *attr, char *buf)
 +{
 +      struct snd_soc_device *devdata = dev_get_drvdata(dev);
 +      return soc_codec_reg_show(devdata, buf);
 +}
 +
  static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
  
 +#ifdef CONFIG_DEBUG_FS
 +static int codec_reg_open_file(struct inode *inode, struct file *file)
 +{
 +      file->private_data = inode->i_private;
 +      return 0;
 +}
 +
 +static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
 +                             size_t count, loff_t *ppos)
 +{
 +      ssize_t ret;
 +      struct snd_soc_device *devdata = file->private_data;
 +      char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 +      if (!buf)
 +              return -ENOMEM;
 +      ret = soc_codec_reg_show(devdata, buf);
 +      if (ret >= 0)
 +              ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 +      kfree(buf);
 +      return ret;
 +}
 +
 +static ssize_t codec_reg_write_file(struct file *file,
 +              const char __user *user_buf, size_t count, loff_t *ppos)
 +{
 +      char buf[32];
 +      int buf_size;
 +      char *start = buf;
 +      unsigned long reg, value;
 +      int step = 1;
 +      struct snd_soc_device *devdata = file->private_data;
 +      struct snd_soc_codec *codec = devdata->codec;
 +
 +      buf_size = min(count, (sizeof(buf)-1));
 +      if (copy_from_user(buf, user_buf, buf_size))
 +              return -EFAULT;
 +      buf[buf_size] = 0;
 +
 +      if (codec->reg_cache_step)
 +              step = codec->reg_cache_step;
 +
 +      while (*start == ' ')
 +              start++;
 +      reg = simple_strtoul(start, &start, 16);
 +      if ((reg >= codec->reg_cache_size) || (reg % step))
 +              return -EINVAL;
 +      while (*start == ' ')
 +              start++;
 +      if (strict_strtoul(start, 16, &value))
 +              return -EINVAL;
 +      codec->write(codec, reg, value);
 +      return buf_size;
 +}
 +
 +static const struct file_operations codec_reg_fops = {
 +      .open = codec_reg_open_file,
 +      .read = codec_reg_read_file,
 +      .write = codec_reg_write_file,
 +};
 +
 +static void soc_init_debugfs(struct snd_soc_device *socdev)
 +{
 +      struct dentry *root, *file;
 +      struct snd_soc_codec *codec = socdev->codec;
 +      root = debugfs_create_dir(dev_name(socdev->dev), NULL);
 +      if (IS_ERR(root) || !root)
 +              goto exit1;
 +
 +      file = debugfs_create_file("codec_reg", 0644,
 +                      root, socdev, &codec_reg_fops);
 +      if (!file)
 +              goto exit2;
 +
 +      file = debugfs_create_u32("dapm_pop_time", 0744,
 +                      root, &codec->pop_time);
 +      if (!file)
 +              goto exit2;
 +      socdev->debugfs_root = root;
 +      return;
 +exit2:
 +      debugfs_remove_recursive(root);
 +exit1:
 +      dev_err(socdev->dev, "debugfs is not available\n");
 +}
 +
 +static void soc_cleanup_debugfs(struct snd_soc_device *socdev)
 +{
 +      debugfs_remove_recursive(socdev->debugfs_root);
 +      socdev->debugfs_root = NULL;
 +}
 +
 +#else
 +
 +static inline void soc_init_debugfs(struct snd_soc_device *socdev)
 +{
 +}
 +
 +static inline void soc_cleanup_debugfs(struct snd_soc_device *socdev)
 +{
 +}
 +#endif
 +
  /**
   * snd_soc_new_ac97_codec - initailise AC97 device
   * @codec: audio codec
@@@ -1198,7 -1121,7 +1198,7 @@@ EXPORT_SYMBOL_GPL(snd_soc_test_bits)
  int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
  {
        struct snd_soc_codec *codec = socdev->codec;
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        int ret = 0, i;
  
        mutex_lock(&codec->mutex);
        strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
  
        /* create the pcms */
 -      for (i = 0; i < machine->num_links; i++) {
 -              ret = soc_new_pcm(socdev, &machine->dai_link[i], i);
 +      for (i = 0; i < card->num_links; i++) {
 +              ret = soc_new_pcm(socdev, &card->dai_link[i], i);
                if (ret < 0) {
                        printk(KERN_ERR "asoc: can't create pcm %s\n",
 -                              machine->dai_link[i].stream_name);
 +                              card->dai_link[i].stream_name);
                        mutex_unlock(&codec->mutex);
                        return ret;
                }
@@@ -1244,25 -1167,26 +1244,25 @@@ EXPORT_SYMBOL_GPL(snd_soc_new_pcms)
  int snd_soc_register_card(struct snd_soc_device *socdev)
  {
        struct snd_soc_codec *codec = socdev->codec;
 -      struct snd_soc_machine *machine = socdev->machine;
 +      struct snd_soc_card *card = socdev->card;
        int ret = 0, i, ac97 = 0, err = 0;
  
 -      for (i = 0; i < machine->num_links; i++) {
 -              if (socdev->machine->dai_link[i].init) {
 -                      err = socdev->machine->dai_link[i].init(codec);
 +      for (i = 0; i < card->num_links; i++) {
 +              if (card->dai_link[i].init) {
 +                      err = card->dai_link[i].init(codec);
                        if (err < 0) {
                                printk(KERN_ERR "asoc: failed to init %s\n",
 -                                      socdev->machine->dai_link[i].stream_name);
 +                                      card->dai_link[i].stream_name);
                                continue;
                        }
                }
 -              if (socdev->machine->dai_link[i].codec_dai->type ==
 -                      SND_SOC_DAI_AC97_BUS)
 +              if (card->dai_link[i].codec_dai->ac97_control)
                        ac97 = 1;
        }
        snprintf(codec->card->shortname, sizeof(codec->card->shortname),
 -               "%s", machine->name);
 +               "%s",  card->name);
        snprintf(codec->card->longname, sizeof(codec->card->longname),
 -               "%s (%s)", machine->name, codec->name);
 +               "%s (%s)", card->name, codec->name);
  
        ret = snd_card_register(codec->card);
        if (ret < 0) {
        if (err < 0)
                printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
  
 +      soc_init_debugfs(socdev);
        mutex_unlock(&codec->mutex);
  
  out:
@@@ -1316,11 -1239,10 +1316,11 @@@ void snd_soc_free_pcms(struct snd_soc_d
  #endif
  
        mutex_lock(&codec->mutex);
 +      soc_cleanup_debugfs(socdev);
  #ifdef CONFIG_SND_SOC_AC97_BUS
        for (i = 0; i < codec->num_dai; i++) {
                codec_dai = &codec->dai[i];
 -              if (codec_dai->type == SND_SOC_DAI_AC97_BUS && codec->ac97) {
 +              if (codec_dai->ac97_control && codec->ac97) {
                        soc_ac97_dev_unregister(codec);
                        goto free_card;
                }
@@@ -1834,8 -1756,8 +1834,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8)
  int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
        unsigned int freq, int dir)
  {
 -      if (dai->dai_ops.set_sysclk)
 -              return dai->dai_ops.set_sysclk(dai, clk_id, freq, dir);
 +      if (dai->ops.set_sysclk)
 +              return dai->ops.set_sysclk(dai, clk_id, freq, dir);
        else
                return -EINVAL;
  }
@@@ -1854,8 -1776,8 +1854,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_syscl
  int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
        int div_id, int div)
  {
 -      if (dai->dai_ops.set_clkdiv)
 -              return dai->dai_ops.set_clkdiv(dai, div_id, div);
 +      if (dai->ops.set_clkdiv)
 +              return dai->ops.set_clkdiv(dai, div_id, div);
        else
                return -EINVAL;
  }
@@@ -1873,8 -1795,8 +1873,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdi
  int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
        int pll_id, unsigned int freq_in, unsigned int freq_out)
  {
 -      if (dai->dai_ops.set_pll)
 -              return dai->dai_ops.set_pll(dai, pll_id, freq_in, freq_out);
 +      if (dai->ops.set_pll)
 +              return dai->ops.set_pll(dai, pll_id, freq_in, freq_out);
        else
                return -EINVAL;
  }
@@@ -1883,14 -1805,15 +1883,14 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll)
  /**
   * snd_soc_dai_set_fmt - configure DAI hardware audio format.
   * @dai: DAI
 - * @clk_id: DAI specific clock ID
   * @fmt: SND_SOC_DAIFMT_ format value.
   *
   * Configures the DAI hardware format and clocking.
   */
  int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
  {
 -      if (dai->dai_ops.set_fmt)
 -              return dai->dai_ops.set_fmt(dai, fmt);
 +      if (dai->ops.set_fmt)
 +              return dai->ops.set_fmt(dai, fmt);
        else
                return -EINVAL;
  }
@@@ -1908,8 -1831,8 +1908,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt)
  int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
        unsigned int mask, int slots)
  {
 -      if (dai->dai_ops.set_sysclk)
 -              return dai->dai_ops.set_tdm_slot(dai, mask, slots);
 +      if (dai->ops.set_sysclk)
 +              return dai->ops.set_tdm_slot(dai, mask, slots);
        else
                return -EINVAL;
  }
@@@ -1924,8 -1847,8 +1924,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_s
   */
  int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
  {
 -      if (dai->dai_ops.set_sysclk)
 -              return dai->dai_ops.set_tristate(dai, tristate);
 +      if (dai->ops.set_sysclk)
 +              return dai->ops.set_tristate(dai, tristate);
        else
                return -EINVAL;
  }
@@@ -1940,8 -1863,8 +1940,8 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_trist
   */
  int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
  {
 -      if (dai->dai_ops.digital_mute)
 -              return dai->dai_ops.digital_mute(dai, mute);
 +      if (dai->ops.digital_mute)
 +              return dai->ops.digital_mute(dai, mute);
        else
                return -EINVAL;
  }
@@@ -1949,6 -1872,7 +1949,6 @@@ EXPORT_SYMBOL_GPL(snd_soc_dai_digital_m
  
  static int __devinit snd_soc_init(void)
  {
 -      printk(KERN_INFO "ASoC version %s\n", SND_SOC_VERSION);
        return platform_driver_register(&soc_driver);
  }