Merge tag 'sound-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull sound updates from Takashi Iwai:
 "There have been lots of changes in ALSA core, HD-audio and ASoC, also
  most of PCI drivers touched by conversions of printks.  All these
  resulted in a high volume and wide ranged patch sets in this release.
  Many changes are fairly trivial, but also lots of nice cleanups and
  refactors.  There are a few new drivers, most notably, the Intel
  Haswell and Baytrail ASoC driver.

  Core changes:
   - A bit modernization; embed the device struct into snd_card struct,
     so that it may be referred from the beginning.  A new
     snd_card_new() function is introduced for that, and all drivers
     have been converted.

   - Simplification in the device management code in ALSA core; now
     managed by a simple priority list instead

   - Converted many kernel messages to use the standard dev_err() & co;
     this would be the pretty visible difference, especially for
     HD-audio.

  HD-audio:
   - Conexant codecs use the auto-parser as default now; the old static
     code still remains in case of regressions.  Some old quirks have
     been rewritten with the fixups for auto-parser.

   - C-Media codecs also use the auto-parser as default now, too.

   - A device struct is assigned to each HD-audio codec, and the
     formerly hwdep attributes are accessible over the codec sysfs, too.
     hwdep attributes still remain for compatibility.

   - Split the PCI-specific stuff for HD-audio controller into a
     separate module, ane make a helper module for the generic
     controller driver.  This is a preliminary change for supporting
     Tegra HDMI controller in near future, which slipped from 3.15
     merge.

   - Device-specific fixes: mute LED support for Lenovo Ideapad, mic LED
     fix for HP laptops, more ASUS subwoofer quirks, yet more Dell
     laptop headset quirks

   - Make the HD-audio codec response a bit more robust

   - A few improvements on Realtek ALC282 / 283 about the pop noises

   - A couple of Intel HDMI fixes

  ASoC:
   - Lots of cleanups for enumerations; refactored lots of error prone
     original codes to use more modern APIs

   - Elimination of the ASoC level wrappers for I2C and SPI moving us
     closer to converting to regmap completely and avoiding some
     randconfig hassle

   - Provide both manually and transparently locked DAPM APIs rather
     than a mix of the two fixing some concurrency issues

   - Start converting CODEC drivers to use separate bus interface
     drivers rather than having them all in one file helping avoid
     dependency issues

   - DPCM support for Intel Haswell and Bay Trail platforms, lots of
     fixes

   - Lots of work on improvements for simple-card, DaVinci and the
     Renesas rcar drivers.

   - New drivers for Analog Devices ADAU1977, TI PCM512x and parts of
     the CSR SiRF SoC, TLV320AIC31XXX, Armada 370 DB, Cirrus cs42xx8

   - Fixes for the simple-card DAI format DT mess

   - DT support for a couple more devices.

   - Use of the tdm_slot mapping in a few drivers

  Others:
   - Support of reset_resume callback for improved S4 in USB-audio
     driver; the device with boot quirks have been little tested, which
     we need to watch out in this development cycle

   - Add PM support for ICE1712 driver (finally!); it's still pretty
     partial support, only for M-Audio devices"

* tag 'sound-3.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (610 commits)
  ALSA: ice1712: Add suspend support for M-Audio ICE1712-based cards
  ALSA: ice1712: add suspend support for ICE1712 chip
  ALSA: hda - Enable beep for ASUS 1015E
  ALSA: asihpi: fix some indenting in snd_card_asihpi_pcm_new()
  ALSA: hda - add headset mic detect quirks for three Dell laptops
  ASoC: tegra: move AC97 clock handling to the machine driver
  ASoC: simple-card: Handle many DAI links
  ASoC: simple-card: Add DT documentation for multi-DAI links
  ASoC: simple-card: dynamically allocate the DAI link and properties
  ASoC: imx-ssi: Add .xlate_tdm_slot_mask() support.
  ASoC: fsl-esai: Add .xlate_tdm_slot_mask() support.
  ASoC: fsl-utils: Add fsl_asoc_xlate_tdm_slot_mask() support.
  ASoC: core: remove the 'of_' prefix of of_xlate_tdm_slot_mask.
  ASoC: rcar: subnode tidyup for renesas,rsnd.txt
  ASoC: Remove name_prefix unset during DAI link init hack
  ALSA: hda - Inform the unexpectedly ignored pins by auto-parser
  ASoC: rcar: bugfix: it cares about the non-src case
  ARM: bockw: fixup SND_SOC_DAIFMT_CBx_CFx flags
  ASoC: pcm: Drop incorrect double/extra frees
  ASoC: mfld_machine: Fix compile error
  ...

2 files changed, 532 insertions, 0 deletions

diff --git a/include/trace/events/hswadsp.h b/include/trace/events/hswadsp.h
new file mode 100644
index 000000000000..0f78bbb02002
--- /dev/null
+++ b/include/trace/events/hswadsp.h
@@ -0,0 +1,384 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM hswadsp
+
+#if !defined(_TRACE_HSWADSP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_HSWADSP_H
+
+#include <linux/types.h>
+#include <linux/ktime.h>
+#include <linux/tracepoint.h>
+
+struct sst_hsw;
+struct sst_hsw_stream;
+struct sst_hsw_ipc_stream_free_req;
+struct sst_hsw_ipc_volume_req;
+struct sst_hsw_ipc_stream_alloc_req;
+struct sst_hsw_audio_data_format_ipc;
+struct sst_hsw_ipc_stream_info_reply;
+struct sst_hsw_ipc_device_config_req;
+
+DECLARE_EVENT_CLASS(sst_irq,
+
+        TP_PROTO(uint32_t status, uint32_t mask),
+
+        TP_ARGS(status, mask),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   status          )
+                __field(        unsigned int,   mask            )
+        ),
+
+        TP_fast_assign(
+                __entry->status = status;
+                __entry->mask = mask;
+        ),
+
+        TP_printk("status 0x%8.8x mask 0x%8.8x",
+                (unsigned int)__entry->status, (unsigned int)__entry->mask)
+);
+
+DEFINE_EVENT(sst_irq, sst_irq_busy,
+
+        TP_PROTO(unsigned int status, unsigned int mask),
+
+        TP_ARGS(status, mask)
+
+);
+
+DEFINE_EVENT(sst_irq, sst_irq_done,
+
+        TP_PROTO(unsigned int status, unsigned int mask),
+
+        TP_ARGS(status, mask)
+
+);
+
+DECLARE_EVENT_CLASS(ipc,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val),
+
+        TP_STRUCT__entry(
+                __string(       name,   name            )
+                __field(        unsigned int,   val     )
+        ),
+
+        TP_fast_assign(
+                __assign_str(name, name);
+                __entry->val = val;
+        ),
+
+        TP_printk("%s 0x%8.8x", __get_str(name), (unsigned int)__entry->val)
+
+);
+
+DEFINE_EVENT(ipc, ipc_request,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val)
+
+);
+
+DEFINE_EVENT(ipc, ipc_reply,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val)
+
+);
+
+DEFINE_EVENT(ipc, ipc_pending_reply,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val)
+
+);
+
+DEFINE_EVENT(ipc, ipc_notification,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val)
+
+);
+
+DEFINE_EVENT(ipc, ipc_error,
+
+        TP_PROTO(const char *name, int val),
+
+        TP_ARGS(name, val)
+
+);
+
+DECLARE_EVENT_CLASS(stream_position,
+
+        TP_PROTO(unsigned int id, unsigned int pos),
+
+        TP_ARGS(id, pos),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   id              )
+                __field(        unsigned int,   pos             )
+        ),
+
+        TP_fast_assign(
+                __entry->id = id;
+                __entry->pos = pos;
+        ),
+
+        TP_printk("id %d position 0x%x",
+                (unsigned int)__entry->id, (unsigned int)__entry->pos)
+);
+
+DEFINE_EVENT(stream_position, stream_read_position,
+
+        TP_PROTO(unsigned int id, unsigned int pos),
+
+        TP_ARGS(id, pos)
+
+);
+
+DEFINE_EVENT(stream_position, stream_write_position,
+
+        TP_PROTO(unsigned int id, unsigned int pos),
+
+        TP_ARGS(id, pos)
+
+);
+
+TRACE_EVENT(hsw_stream_buffer,
+
+        TP_PROTO(struct sst_hsw_stream *stream),
+
+        TP_ARGS(stream),
+
+        TP_STRUCT__entry(
+                __field(        int,    id      )
+                __field(        int,    pt_addr )
+                __field(        int,    num_pages       )
+                __field(        int,    ring_size       )
+                __field(        int,    ring_offset     )
+                __field(        int,    first_pfn       )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->pt_addr = stream->request.ringinfo.ring_pt_address;
+                __entry->num_pages = stream->request.ringinfo.num_pages;
+                __entry->ring_size = stream->request.ringinfo.ring_size;
+                __entry->ring_offset = stream->request.ringinfo.ring_offset;
+                __entry->first_pfn = stream->request.ringinfo.ring_first_pfn;
+        ),
+
+        TP_printk("stream %d ring addr 0x%x pages %d size 0x%x offset 0x%x PFN 0x%x",
+                (int) __entry->id,  (int)__entry->pt_addr,
+                (int)__entry->num_pages, (int)__entry->ring_size,
+                (int)__entry->ring_offset, (int)__entry->first_pfn)
+);
+
+TRACE_EVENT(hsw_stream_alloc_reply,
+
+        TP_PROTO(struct sst_hsw_stream *stream),
+
+        TP_ARGS(stream),
+
+        TP_STRUCT__entry(
+                __field(        int,    id      )
+                __field(        int,    stream_id       )
+                __field(        int,    mixer_id        )
+                __field(        int,    peak0   )
+                __field(        int,    peak1   )
+                __field(        int,    vol0    )
+                __field(        int,    vol1    )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->stream_id = stream->reply.stream_hw_id;
+                __entry->mixer_id = stream->reply.mixer_hw_id;
+                __entry->peak0 = stream->reply.peak_meter_register_address[0];
+                __entry->peak1 = stream->reply.peak_meter_register_address[1];
+                __entry->vol0 = stream->reply.volume_register_address[0];
+                __entry->vol1 = stream->reply.volume_register_address[1];
+        ),
+
+        TP_printk("stream %d hw id %d mixer %d peak 0x%x:0x%x vol 0x%x,0x%x",
+                (int) __entry->id, (int) __entry->stream_id, (int)__entry->mixer_id,
+                (int)__entry->peak0, (int)__entry->peak1,
+                (int)__entry->vol0, (int)__entry->vol1)
+);
+
+TRACE_EVENT(hsw_mixer_info_reply,
+
+        TP_PROTO(struct sst_hsw_ipc_stream_info_reply *reply),
+
+        TP_ARGS(reply),
+
+        TP_STRUCT__entry(
+                __field(        int,    mixer_id        )
+                __field(        int,    peak0   )
+                __field(        int,    peak1   )
+                __field(        int,    vol0    )
+                __field(        int,    vol1    )
+        ),
+
+        TP_fast_assign(
+                __entry->mixer_id = reply->mixer_hw_id;
+                __entry->peak0 = reply->peak_meter_register_address[0];
+                __entry->peak1 = reply->peak_meter_register_address[1];
+                __entry->vol0 = reply->volume_register_address[0];
+                __entry->vol1 = reply->volume_register_address[1];
+        ),
+
+        TP_printk("mixer id %d peak 0x%x:0x%x vol 0x%x,0x%x",
+                (int)__entry->mixer_id,
+                (int)__entry->peak0, (int)__entry->peak1,
+                (int)__entry->vol0, (int)__entry->vol1)
+);
+
+TRACE_EVENT(hsw_stream_data_format,
+
+        TP_PROTO(struct sst_hsw_stream *stream,
+                struct sst_hsw_audio_data_format_ipc *req),
+
+        TP_ARGS(stream, req),
+
+        TP_STRUCT__entry(
+                __field(        uint32_t,       id      )
+                __field(        uint32_t,       frequency       )
+                __field(        uint32_t,       bitdepth        )
+                __field(        uint32_t,       map     )
+                __field(        uint32_t,       config  )
+                __field(        uint32_t,       style   )
+                __field(        uint8_t,        ch_num  )
+                __field(        uint8_t,        valid_bit       )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->frequency = req->frequency;
+                __entry->bitdepth = req->bitdepth;
+                __entry->map = req->map;
+                __entry->config = req->config;
+                __entry->style = req->style;
+                __entry->ch_num = req->ch_num;
+                __entry->valid_bit = req->valid_bit;
+        ),
+
+        TP_printk("stream %d freq %d depth %d map 0x%x config 0x%x style 0x%x ch %d bits %d",
+                (int) __entry->id, (uint32_t)__entry->frequency,
+                (uint32_t)__entry->bitdepth, (uint32_t)__entry->map,
+                (uint32_t)__entry->config, (uint32_t)__entry->style,
+                (uint8_t)__entry->ch_num, (uint8_t)__entry->valid_bit)
+);
+
+TRACE_EVENT(hsw_stream_alloc_request,
+
+        TP_PROTO(struct sst_hsw_stream *stream,
+                struct sst_hsw_ipc_stream_alloc_req *req),
+
+        TP_ARGS(stream, req),
+
+        TP_STRUCT__entry(
+                __field(        uint32_t,       id      )
+                __field(        uint8_t,        path_id )
+                __field(        uint8_t,        stream_type     )
+                __field(        uint8_t,        format_id       )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->path_id = req->path_id;
+                __entry->stream_type = req->stream_type;
+                __entry->format_id = req->format_id;
+        ),
+
+        TP_printk("stream %d path %d type %d format %d",
+                (int) __entry->id, (uint8_t)__entry->path_id,
+                (uint8_t)__entry->stream_type, (uint8_t)__entry->format_id)
+);
+
+TRACE_EVENT(hsw_stream_free_req,
+
+        TP_PROTO(struct sst_hsw_stream *stream,
+                struct sst_hsw_ipc_stream_free_req *req),
+
+        TP_ARGS(stream, req),
+
+        TP_STRUCT__entry(
+                __field(        int,    id      )
+                __field(        int,    stream_id       )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->stream_id = req->stream_id;
+        ),
+
+        TP_printk("stream %d hw id %d",
+                (int) __entry->id, (int) __entry->stream_id)
+);
+
+TRACE_EVENT(hsw_volume_req,
+
+        TP_PROTO(struct sst_hsw_stream *stream,
+                struct sst_hsw_ipc_volume_req *req),
+
+        TP_ARGS(stream, req),
+
+        TP_STRUCT__entry(
+                __field(        int,    id      )
+                __field(        uint32_t,       channel )
+                __field(        uint32_t,       target_volume   )
+                __field(        uint64_t,       curve_duration  )
+                __field(        uint32_t,       curve_type      )
+        ),
+
+        TP_fast_assign(
+                __entry->id = stream->host_id;
+                __entry->channel = req->channel;
+                __entry->target_volume = req->target_volume;
+                __entry->curve_duration = req->curve_duration;
+                __entry->curve_type = req->curve_type;
+        ),
+
+        TP_printk("stream %d chan 0x%x vol %d duration %llu type %d",
+                (int) __entry->id, (uint32_t) __entry->channel,
+                (uint32_t)__entry->target_volume,
+                (uint64_t)__entry->curve_duration,
+                (uint32_t)__entry->curve_type)
+);
+
+TRACE_EVENT(hsw_device_config_req,
+
+        TP_PROTO(struct sst_hsw_ipc_device_config_req *req),
+
+        TP_ARGS(req),
+
+        TP_STRUCT__entry(
+                __field(        uint32_t,       ssp     )
+                __field(        uint32_t,       clock_freq      )
+                __field(        uint32_t,       mode    )
+                __field(        uint16_t,       clock_divider   )
+        ),
+
+        TP_fast_assign(
+                __entry->ssp = req->ssp_interface;
+                __entry->clock_freq = req->clock_frequency;
+                __entry->mode = req->mode;
+                __entry->clock_divider = req->clock_divider;
+        ),
+
+        TP_printk("SSP %d Freq %d mode %d div %d",
+                (uint32_t)__entry->ssp,
+                (uint32_t)__entry->clock_freq, (uint32_t)__entry->mode,
+                (uint32_t)__entry->clock_divider)
+);
+
+#endif /* _TRACE_HSWADSP_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/intel-sst.h b/include/trace/events/intel-sst.h
new file mode 100644
index 000000000000..76c72d3f1902
--- /dev/null
+++ b/include/trace/events/intel-sst.h
@@ -0,0 +1,148 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM intel-sst
+
+#if !defined(_TRACE_INTEL_SST_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_INTEL_SST_H
+
+#include <linux/types.h>
+#include <linux/ktime.h>
+#include <linux/tracepoint.h>
+
+DECLARE_EVENT_CLASS(sst_ipc_msg,
+
+        TP_PROTO(unsigned int val),
+
+        TP_ARGS(val),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   val             )
+        ),
+
+        TP_fast_assign(
+                __entry->val = val;
+        ),
+
+        TP_printk("0x%8.8x", (unsigned int)__entry->val)
+);
+
+DEFINE_EVENT(sst_ipc_msg, sst_ipc_msg_tx,
+
+        TP_PROTO(unsigned int val),
+
+        TP_ARGS(val)
+
+);
+
+DEFINE_EVENT(sst_ipc_msg, sst_ipc_msg_rx,
+
+        TP_PROTO(unsigned int val),
+
+        TP_ARGS(val)
+
+);
+
+DECLARE_EVENT_CLASS(sst_ipc_mailbox,
+
+        TP_PROTO(unsigned int offset, unsigned int val),
+
+        TP_ARGS(offset, val),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   offset          )
+                __field(        unsigned int,   val             )
+        ),
+
+        TP_fast_assign(
+                __entry->offset = offset;
+                __entry->val = val;
+        ),
+
+        TP_printk(" 0x%4.4x = 0x%8.8x",
+                (unsigned int)__entry->offset, (unsigned int)__entry->val)
+);
+
+DEFINE_EVENT(sst_ipc_mailbox, sst_ipc_inbox_rdata,
+
+        TP_PROTO(unsigned int offset, unsigned int val),
+
+        TP_ARGS(offset, val)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox, sst_ipc_inbox_wdata,
+
+        TP_PROTO(unsigned int offset, unsigned int val),
+
+        TP_ARGS(offset, val)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox, sst_ipc_outbox_rdata,
+
+        TP_PROTO(unsigned int offset, unsigned int val),
+
+        TP_ARGS(offset, val)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox, sst_ipc_outbox_wdata,
+
+        TP_PROTO(unsigned int offset, unsigned int val),
+
+        TP_ARGS(offset, val)
+
+);
+
+DECLARE_EVENT_CLASS(sst_ipc_mailbox_info,
+
+        TP_PROTO(unsigned int size),
+
+        TP_ARGS(size),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   size            )
+        ),
+
+        TP_fast_assign(
+                __entry->size = size;
+        ),
+
+        TP_printk("Mailbox bytes 0x%8.8x", (unsigned int)__entry->size)
+);
+
+DEFINE_EVENT(sst_ipc_mailbox_info, sst_ipc_inbox_read,
+
+        TP_PROTO(unsigned int size),
+
+        TP_ARGS(size)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox_info, sst_ipc_inbox_write,
+
+        TP_PROTO(unsigned int size),
+
+        TP_ARGS(size)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox_info, sst_ipc_outbox_read,
+
+        TP_PROTO(unsigned int size),
+
+        TP_ARGS(size)
+
+);
+
+DEFINE_EVENT(sst_ipc_mailbox_info, sst_ipc_outbox_write,
+
+        TP_PROTO(unsigned int size),
+
+        TP_ARGS(size)
+
+);
+
+#endif /* _TRACE_SST_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>