Merge tag 'sound-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 19 May 2016 20:41:32 +0000 (13:41 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 19 May 2016 20:41:32 +0000 (13:41 -0700)
Pull sound updates from Takashi Iwai:
 "This time was again a relatively calm development cycle; most of
  updates are about drivers, and no radical changes are seen in any core
  code.  Here are some highlights:

  ALSA core:
   - Continued hardening of ALSA hrtimer
   - A few leak fixes in timer interface
   - Fix poll error handling in PCM and compress
   - Add error propagation in compress API
   - Removal of dead rtctimer driver

  HD-audio:
   - Native ELD notify support for i915 HDMI
   - Realtek ALC234 & co support
   - Code refactoring to standardize chmap support
   - Continued development for SKL HDMI core support

  Firewire:
   - Apply delayed card registration to all drivers
   - Improved / stabilized the handling of PCM stream start / stop
   - Add tracepoints to dump a part of isochronous packet data
   - Fixed incoming/outgoing packet parameter usages
   - Add support for M-Audio profire series

  USB-audio:
   - Fixes for UAC2 clock source
   - SS+ support
   - Workaround for oft-seen repeated sample rate read errors

  ASoC:
   - Further slow progress on the topology code
   - Substantial updates and improvements for the da7219, es8328,
     fsl-ssi, Intel and rcar drivers.
   - Compress error handling in WM ADSP driver"

* tag 'sound-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (177 commits)
  ALSA: firewire-lib: change a member of event structure to suppress sparse wanings to bool type
  sound: oss: Use setup_timer and mod_timer.
  ASoC: hdac_hdmi: Remove the unused 'timeout' variable
  ASoC: fsl_ssi: Fix channel slipping on capture (or playback) restart in full duplex.
  ASoC: fsl_ssi: Fix channel slipping in Playback at startup
  ASoC: fsl_ssi: Fix samples being dropped at Playback startup
  ASoC: fsl_ssi: Save a dev reference for dev_err() purpose.
  ASoC: fsl_ssi: The IPG/5 limitation concerns the bitclk, not the sysclk.
  ASoC: fsl_ssi: Real hardware channels max number is 32
  ASoC: pcm5102a: Add support for PCM5102A codec
  ASoC: hdac_hdmi: add link management
  ASoC: Intel: Skylake: add link management
  ALSA: hdac: add link pm and ref counting
  ALSA: au88x0: Fix zero clear of stream->resources
  ASoC: rt298: Add DMI match for Broxton-P reference platform
  ASoC: rt298: fix null deref on acpi driver data
  ASoC: dapm: deprecate MICBIAS widget type
  ALSA: firewire-lib: drop skip argument from helper functions to queue a packet
  ALSA: firewire-lib: add context information to tracepoints
  ALSA: firewire-lib: permit to flush queued packets only in process context for better PCM period granularity
  ...

144 files changed:
Documentation/devicetree/bindings/sound/davinci-mcbsp.txt [new file with mode: 0644]
Documentation/devicetree/bindings/sound/fsl-sai.txt
Documentation/devicetree/bindings/sound/pcm5102a.txt [new file with mode: 0644]
Documentation/sound/alsa/HD-Audio.txt
Documentation/sound/alsa/compress_offload.txt
Documentation/sound/alsa/soc/dapm.txt
Documentation/sound/alsa/soc/overview.txt
Documentation/sound/alsa/timestamping.txt
MAINTAINERS
include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
include/sound/dmaengine_pcm.h
include/sound/hda_chmap.h
include/sound/hda_i915.h
include/sound/hdaudio_ext.h
include/sound/hdmi-codec.h [new file with mode: 0644]
include/sound/pcm_iec958.h
include/sound/soc-dapm.h
include/sound/soc.h
include/uapi/sound/asound.h
sound/core/Kconfig
sound/core/Makefile
sound/core/compress_offload.c
sound/core/hrtimer.c
sound/core/pcm_dmaengine.c
sound/core/pcm_iec958.c
sound/core/pcm_lib.c
sound/core/pcm_native.c
sound/core/rtctimer.c [deleted file]
sound/core/seq/seq.c
sound/core/timer.c
sound/firewire/Kconfig
sound/firewire/Makefile
sound/firewire/amdtp-stream-trace.h [new file with mode: 0644]
sound/firewire/amdtp-stream.c
sound/firewire/amdtp-stream.h
sound/firewire/bebob/bebob.c
sound/firewire/bebob/bebob.h
sound/firewire/bebob/bebob_stream.c
sound/firewire/dice/dice.c
sound/firewire/digi00x/amdtp-dot.c
sound/firewire/digi00x/digi00x-transaction.c
sound/firewire/digi00x/digi00x.c
sound/firewire/digi00x/digi00x.h
sound/firewire/fireworks/fireworks.c
sound/firewire/fireworks/fireworks.h
sound/firewire/fireworks/fireworks_stream.c
sound/firewire/lib.c
sound/firewire/lib.h
sound/firewire/oxfw/oxfw-stream.c
sound/firewire/oxfw/oxfw.c
sound/firewire/oxfw/oxfw.h
sound/firewire/tascam/tascam-stream.c
sound/firewire/tascam/tascam.c
sound/firewire/tascam/tascam.h
sound/hda/ext/hdac_ext_bus.c
sound/hda/ext/hdac_ext_controller.c
sound/hda/hdac_controller.c
sound/hda/hdac_i915.c
sound/hda/hdmi_chmap.c
sound/hda/local.h
sound/isa/wavefront/wavefront_synth.c
sound/oss/waveartist.c
sound/pci/au88x0/au88x0_core.c
sound/pci/au88x0/au88x0_pcm.c
sound/pci/ctxfi/cttimer.c
sound/pci/ens1370.c
sound/pci/hda/Kconfig
sound/pci/hda/hda_generic.c
sound/pci/hda/patch_hdmi.c
sound/pci/hda/patch_realtek.c
sound/pci/intel8x0.c
sound/pci/lx6464es/lx_core.c
sound/soc/atmel/atmel_ssc_dai.c
sound/soc/au1x/dbdma2.c
sound/soc/bcm/bcm2835-i2s.c
sound/soc/codecs/Kconfig
sound/soc/codecs/Makefile
sound/soc/codecs/ak4642.c
sound/soc/codecs/arizona.c
sound/soc/codecs/cs42l56.c
sound/soc/codecs/cs47l24.c
sound/soc/codecs/da7213.c
sound/soc/codecs/da7213.h
sound/soc/codecs/da7218.c
sound/soc/codecs/da7218.h
sound/soc/codecs/da7219.c
sound/soc/codecs/da7219.h
sound/soc/codecs/es8328.c
sound/soc/codecs/es8328.h
sound/soc/codecs/hdac_hdmi.c
sound/soc/codecs/hdmi-codec.c [new file with mode: 0644]
sound/soc/codecs/pcm5102a.c [new file with mode: 0644]
sound/soc/codecs/rt298.c
sound/soc/codecs/rt5645.c
sound/soc/codecs/wm5102.c
sound/soc/codecs/wm5110.c
sound/soc/codecs/wm_adsp.c
sound/soc/codecs/wm_adsp.h
sound/soc/davinci/Kconfig
sound/soc/davinci/davinci-i2s.c
sound/soc/davinci/davinci-mcasp.c
sound/soc/davinci/davinci-mcasp.h
sound/soc/dwc/designware_i2s.c
sound/soc/fsl/fsl_sai.c
sound/soc/fsl/fsl_ssi.c
sound/soc/fsl/imx-pcm-fiq.c
sound/soc/intel/Kconfig
sound/soc/intel/atom/sst-atom-controls.c
sound/soc/intel/boards/Makefile
sound/soc/intel/boards/broadwell.c
sound/soc/intel/boards/bxt_rt298.c [new file with mode: 0644]
sound/soc/intel/boards/bytcr_rt5640.c
sound/soc/intel/boards/bytcr_rt5651.c
sound/soc/intel/boards/cht_bsw_max98090_ti.c
sound/soc/intel/boards/cht_bsw_rt5645.c
sound/soc/intel/boards/cht_bsw_rt5672.c
sound/soc/intel/boards/haswell.c
sound/soc/intel/boards/skl_nau88l25_max98357a.c
sound/soc/intel/boards/skl_nau88l25_ssm4567.c
sound/soc/intel/boards/skl_rt286.c
sound/soc/intel/common/sst-acpi.h
sound/soc/intel/haswell/sst-haswell-pcm.c
sound/soc/intel/skylake/Makefile
sound/soc/intel/skylake/bxt-sst.c [new file with mode: 0644]
sound/soc/intel/skylake/skl-messages.c
sound/soc/intel/skylake/skl-nhlt.c
sound/soc/intel/skylake/skl-pcm.c
sound/soc/intel/skylake/skl-sst-dsp.c
sound/soc/intel/skylake/skl-sst-dsp.h
sound/soc/intel/skylake/skl-sst.c
sound/soc/intel/skylake/skl-topology.c
sound/soc/intel/skylake/skl-topology.h
sound/soc/intel/skylake/skl-tplg-interface.h
sound/soc/intel/skylake/skl.c
sound/soc/intel/skylake/skl.h
sound/soc/rockchip/rockchip_i2s.c
sound/soc/soc-core.c
sound/soc/soc-generic-dmaengine-pcm.c
sound/usb/card.c
sound/usb/clock.c
sound/usb/helper.c
sound/usb/midi.c
sound/usb/mixer.c
sound/usb/usbaudio.h

diff --git a/Documentation/devicetree/bindings/sound/davinci-mcbsp.txt b/Documentation/devicetree/bindings/sound/davinci-mcbsp.txt
new file mode 100644 (file)
index 0000000..55b53e1
--- /dev/null
@@ -0,0 +1,51 @@
+Texas Instruments DaVinci McBSP module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This binding describes the "Multi-channel Buffered Serial Port" (McBSP)
+audio interface found in some TI DaVinci processors like the OMAP-L138 or AM180x.
+
+
+Required properties:
+~~~~~~~~~~~~~~~~~~~~
+- compatible :
+        "ti,da850-mcbsp" : for DA850, AM180x and OPAM-L138 platforms
+
+- reg : physical base address and length of the controller memory mapped
+        region(s).
+- reg-names : Should contain:
+        * "mpu" for the main registers (required).
+        * "dat" for the data FIFO (optional).
+
+- dmas: three element list of DMA controller phandles, DMA request line and
+       TC channel ordered triplets.
+- dma-names: identifier string for each DMA request line in the dmas property.
+       These strings correspond 1:1 with the ordered pairs in dmas. The dma
+       identifiers must be "rx" and "tx".
+
+Optional properties:
+~~~~~~~~~~~~~~~~~~~~
+- interrupts : Interrupt numbers for McBSP
+- interrupt-names : Known interrupt names are "rx" and "tx"
+
+- pinctrl-0: Should specify pin control group used for this controller.
+- pinctrl-names: Should contain only one value - "default", for more details
+        please refer to pinctrl-bindings.txt
+
+Example (AM1808):
+~~~~~~~~~~~~~~~~~
+
+mcbsp0: mcbsp@1d10000 {
+       compatible = "ti,da850-mcbsp";
+       pinctrl-names = "default";
+       pinctrl-0 = <&mcbsp0_pins>;
+
+       reg =   <0x00110000 0x1000>,
+               <0x00310000 0x1000>;
+       reg-names = "mpu", "dat";
+       interrupts = <97 98>;
+       interrupts-names = "rx", "tx";
+       dmas = <&edma0 3 1
+               &edma0 2 1>;
+       dma-names = "tx", "rx";
+       status = "okay";
+};
index 044e5d76e2dd32f251be377266b8fa0e3436e584..740b467adf7d1d46f318d5a2a6bf74f35cfa80bc 100644 (file)
@@ -7,8 +7,8 @@ codec/DSP interfaces.
 
 Required properties:
 
-  - compatible         : Compatible list, contains "fsl,vf610-sai" or
-                         "fsl,imx6sx-sai".
+  - compatible         : Compatible list, contains "fsl,vf610-sai",
+                         "fsl,imx6sx-sai" or "fsl,imx6ul-sai"
 
   - reg                        : Offset and length of the register set for the device.
 
@@ -48,6 +48,11 @@ Required properties:
                          receive data by following their own bit clocks and
                          frame sync clocks separately.
 
+Optional properties (for mx6ul):
+
+  - fsl,sai-mclk-direction-output: This is a boolean property. If present,
+                        indicates that SAI will output the SAI MCLK clock.
+
 Note:
 - If both fsl,sai-asynchronous and fsl,sai-synchronous-rx are absent, the
   default synchronous mode (sync Rx with Tx) will be used, which means both
diff --git a/Documentation/devicetree/bindings/sound/pcm5102a.txt b/Documentation/devicetree/bindings/sound/pcm5102a.txt
new file mode 100644 (file)
index 0000000..c63ab0b
--- /dev/null
@@ -0,0 +1,13 @@
+PCM5102a audio CODECs
+
+These devices does not use I2C or SPI.
+
+Required properties:
+
+  - compatible : set as "ti,pcm5102a"
+
+Examples:
+
+       pcm5102a: pcm5102a {
+               compatible = "ti,pcm5102a";
+       };
index e7193aac669c3a7afc356276c167de3f887fc027..d4510ebf2e8c5bf35cc54885c7ea96d54e2e67c3 100644 (file)
@@ -655,17 +655,6 @@ development branches in general while the development for the current
 and next kernels are found in for-linus and for-next branches,
 respectively.
 
-If you are using the latest Linus tree, it'd be better to pull the
-above GIT tree onto it.  If you are using the older kernels, an easy
-way to try the latest ALSA code is to build from the snapshot
-tarball.  There are daily tarballs and the latest snapshot tarball.
-All can be built just like normal alsa-driver release packages, that
-is, installed via the usual spells: configure, make and make
-install(-modules).  See INSTALL in the package.  The snapshot tarballs
-are found at:
-
-- ftp://ftp.suse.com/pub/people/tiwai/snapshot/
-
 
 Sending a Bug Report
 ~~~~~~~~~~~~~~~~~~~~
@@ -699,7 +688,12 @@ problems.
 alsa-info
 ~~~~~~~~~
 The script `alsa-info.sh` is a very useful tool to gather the audio
-device information.  You can fetch the latest version from:
+device information.  It's included in alsa-utils package.  The latest
+version can be found on git repository:
+
+- git://git.alsa-project.org/alsa-utils.git
+
+The script can be fetched directly from the following URL, too:
 
 - http://www.alsa-project.org/alsa-info.sh
 
@@ -836,15 +830,11 @@ can get a proc-file dump at the current state, get a list of control
 (mixer) elements, set/get the control element value, simulate the PCM
 operation, the jack plugging simulation, etc.
 
-The package is found in:
-
-- ftp://ftp.suse.com/pub/people/tiwai/misc/
-
-A git repository is available:
+The program is found in the git repository below:
 
 - git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/hda-emu.git
 
-See README file in the tarball for more details about hda-emu
+See README file in the repository for more details about hda-emu
 program.
 
 
index 630c492c3dc2374d621b5c70d190b9100100402a..8ba556a131c37857e8056a91e0c929bf4564a00d 100644 (file)
@@ -149,7 +149,7 @@ Gapless Playback
 ================
 When playing thru an album, the decoders have the ability to skip the encoder
 delay and padding and directly move from one track content to another. The end
-user can perceive this as gapless playback as we dont have silence while
+user can perceive this as gapless playback as we don't have silence while
 switching from one track to another
 
 Also, there might be low-intensity noises due to encoding. Perfect gapless is
@@ -184,7 +184,7 @@ Sequence flow for gapless would be:
 - Fill data of the first track
 - Trigger start
 - User-space finished sending all,
-- Indicaite next track data by sending set_next_track
+- Indicate next track data by sending set_next_track
 - Set metadata of the next track
 - then call partial_drain to flush most of buffer in DSP
 - Fill data of the next track
index 6faab4880006d4c2721846623a07eb6de6661299..c45bd79f291eaddd0f2dba42d56c9a5f0d8b466b 100644 (file)
@@ -132,7 +132,7 @@ SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0),
 SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1, wm8731_output_mixer_controls,
        ARRAY_SIZE(wm8731_output_mixer_controls)),
 
-If you dont want the mixer elements prefixed with the name of the mixer widget,
+If you don't want the mixer elements prefixed with the name of the mixer widget,
 you can use SND_SOC_DAPM_MIXER_NAMED_CTL instead. the parameters are the same
 as for SND_SOC_DAPM_MIXER.
 
index ff88f52eec9849e254796b1c56d77a19236ea6a4..f3f28b7ae2420f575773a0703f80f1fa6289c75a 100644 (file)
@@ -63,7 +63,7 @@ multiple re-usable component drivers :-
     and any audio DSP drivers for that platform.
 
   * Machine class driver: The machine driver class acts as the glue that
-    decribes and binds the other component drivers together to form an ALSA
+    describes and binds the other component drivers together to form an ALSA
     "sound card device". It handles any machine specific controls and
     machine level audio events (e.g. turning on an amp at start of playback).
 
index 0b191a23f534d1bc5a0d54d6f7dfa6ae0ee090fd..1b6473f393a8220909fcbb0eb9a1e829a7e6854d 100644 (file)
@@ -129,7 +129,7 @@ will be required to issue multiple queries and perform an
 interpolation of the results
 
 In some hardware-specific configuration, the system timestamp is
-latched by a low-level audio subsytem, and the information provided
+latched by a low-level audio subsystem, and the information provided
 back to the driver. Due to potential delays in the communication with
 the hardware, there is a risk of misalignment with the avail and delay
 information. To make sure applications are not confused, a
index f825014a082a26e7b92b5550a21d0bc5971f0b77..0d4f9a1c7ce4d994f024b0ea445a82c2b26afaf4 100644 (file)
@@ -4732,6 +4732,7 @@ FREESCALE SOC SOUND DRIVERS
 M:     Timur Tabi <timur@tabi.org>
 M:     Nicolin Chen <nicoleotsuka@gmail.com>
 M:     Xiubo Li <Xiubo.Lee@gmail.com>
+R:     Fabio Estevam <fabio.estevam@nxp.com>
 L:     alsa-devel@alsa-project.org (moderated for non-subscribers)
 L:     linuxppc-dev@lists.ozlabs.org
 S:     Maintained
index 5b08e3c5325f0a7d7bbc011ad157f96b6d7effc5..c8e0164c54236f9e32edf33b7e6c961a26540e2f 100644 (file)
 #define IMX6UL_GPR1_ENET2_CLK_OUTPUT           (0x1 << 18)
 #define IMX6UL_GPR1_ENET_CLK_DIR               (0x3 << 17)
 #define IMX6UL_GPR1_ENET_CLK_OUTPUT            (0x3 << 17)
+#define IMX6UL_GPR1_SAI1_MCLK_DIR              (0x1 << 19)
+#define IMX6UL_GPR1_SAI2_MCLK_DIR              (0x1 << 20)
+#define IMX6UL_GPR1_SAI3_MCLK_DIR              (0x1 << 21)
+#define IMX6UL_GPR1_SAI_MCLK_MASK              (0x7 << 19)
+#define MCLK_DIR(x) (x == 1 ? IMX6UL_GPR1_SAI1_MCLK_DIR : x == 2 ? \
+                    IMX6UL_GPR1_SAI2_MCLK_DIR : IMX6UL_GPR1_SAI3_MCLK_DIR)
 
 #endif /* __LINUX_IMX6Q_IOMUXC_GPR_H */
index f86ef5ea9b0147c4f51d6f885d5566ef4c6a023b..67be2445941a613bcc74918d8964bfe3aef907ff 100644 (file)
@@ -51,6 +51,16 @@ struct dma_chan *snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn,
        void *filter_data);
 struct dma_chan *snd_dmaengine_pcm_get_chan(struct snd_pcm_substream *substream);
 
+/*
+ * The DAI supports packed transfers, eg 2 16-bit samples in a 32-bit word.
+ * If this flag is set the dmaengine driver won't put any restriction on
+ * the supported sample formats and set the DMA transfer size to undefined.
+ * The DAI driver is responsible to disable any unsupported formats in it's
+ * configuration and catch corner cases that are not already handled in
+ * the ALSA core.
+ */
+#define SND_DMAENGINE_PCM_DAI_FLAG_PACK BIT(0)
+
 /**
  * struct snd_dmaengine_dai_dma_data - DAI DMA configuration data
  * @addr: Address of the DAI data source or destination register.
@@ -63,6 +73,7 @@ struct dma_chan *snd_dmaengine_pcm_get_chan(struct snd_pcm_substream *substream)
  * requesting the DMA channel.
  * @chan_name: Custom channel name to use when requesting DMA channel.
  * @fifo_size: FIFO size of the DAI controller in bytes
+ * @flags: PCM_DAI flags, only SND_DMAENGINE_PCM_DAI_FLAG_PACK for now
  */
 struct snd_dmaengine_dai_dma_data {
        dma_addr_t addr;
@@ -72,6 +83,7 @@ struct snd_dmaengine_dai_dma_data {
        void *filter_data;
        const char *chan_name;
        unsigned int fifo_size;
+       unsigned int flags;
 };
 
 void snd_dmaengine_pcm_set_config_from_dai_data(
index e20d219a030412527a57f5f2882d461412607ff3..babd445c75051fbaa9c18b337d897c75d676e237 100644 (file)
@@ -36,6 +36,8 @@ struct hdac_chmap_ops {
        int (*chmap_validate)(struct hdac_chmap *hchmap, int ca,
                        int channels, unsigned char *chmap);
 
+       int (*get_spk_alloc)(struct hdac_device *hdac, int pcm_idx);
+
        void (*get_chmap)(struct hdac_device *hdac, int pcm_idx,
                                        unsigned char *chmap);
        void (*set_chmap)(struct hdac_device *hdac, int pcm_idx,
index f5842bcd9c94ca633a2673d7a4bdceac76423364..796cabf6be5ee9da39a4a5347979b169c21bd633 100644 (file)
@@ -10,8 +10,8 @@
 int snd_hdac_set_codec_wakeup(struct hdac_bus *bus, bool enable);
 int snd_hdac_display_power(struct hdac_bus *bus, bool enable);
 void snd_hdac_i915_set_bclk(struct hdac_bus *bus);
-int snd_hdac_sync_audio_rate(struct hdac_bus *bus, hda_nid_t nid, int rate);
-int snd_hdac_acomp_get_eld(struct hdac_bus *bus, hda_nid_t nid,
+int snd_hdac_sync_audio_rate(struct hdac_device *codec, hda_nid_t nid, int rate);
+int snd_hdac_acomp_get_eld(struct hdac_device *codec, hda_nid_t nid,
                           bool *audio_enabled, char *buffer, int max_bytes);
 int snd_hdac_i915_init(struct hdac_bus *bus);
 int snd_hdac_i915_exit(struct hdac_bus *bus);
@@ -28,12 +28,12 @@ static inline int snd_hdac_display_power(struct hdac_bus *bus, bool enable)
 static inline void snd_hdac_i915_set_bclk(struct hdac_bus *bus)
 {
 }
-static inline int snd_hdac_sync_audio_rate(struct hdac_bus *bus, hda_nid_t nid,
-                                          int rate)
+static inline int snd_hdac_sync_audio_rate(struct hdac_device *codec,
+                                          hda_nid_t nid, int rate)
 {
        return 0;
 }
-static inline int snd_hdac_acomp_get_eld(struct hdac_bus *bus, hda_nid_t nid,
+static inline int snd_hdac_acomp_get_eld(struct hdac_device *codec, hda_nid_t nid,
                                         bool *audio_enabled, char *buffer,
                                         int max_bytes)
 {
index 07fa59237feb032e3e6dcb6660cca6d17b5679e4..b9593b201599f94f49b35a36c82a6f927d97677b 100644 (file)
@@ -14,6 +14,8 @@
  * @gtscap: gts capabilities pointer
  * @drsmcap: dma resume capabilities pointer
  * @hlink_list: link list of HDA links
+ * @lock: lock for link mgmt
+ * @cmd_dma_state: state of cmd DMAs: CORB and RIRB
  */
 struct hdac_ext_bus {
        struct hdac_bus bus;
@@ -27,6 +29,9 @@ struct hdac_ext_bus {
        void __iomem *drsmcap;
 
        struct list_head hlink_list;
+
+       struct mutex lock;
+       bool cmd_dma_state;
 };
 
 int snd_hdac_ext_bus_init(struct hdac_ext_bus *sbus, struct device *dev,
@@ -142,6 +147,9 @@ struct hdac_ext_link {
        void __iomem *ml_addr; /* link output stream reg pointer */
        u32 lcaps;   /* link capablities */
        u16 lsdiid;  /* link sdi identifier */
+
+       int ref_count;
+
        struct list_head list;
 };
 
@@ -154,6 +162,11 @@ void snd_hdac_ext_link_set_stream_id(struct hdac_ext_link *link,
 void snd_hdac_ext_link_clear_stream_id(struct hdac_ext_link *link,
                                 int stream);
 
+int snd_hdac_ext_bus_link_get(struct hdac_ext_bus *ebus,
+                               struct hdac_ext_link *link);
+int snd_hdac_ext_bus_link_put(struct hdac_ext_bus *ebus,
+                               struct hdac_ext_link *link);
+
 /* update register macro */
 #define snd_hdac_updatel(addr, reg, mask, val)         \
        writel(((readl(addr + reg) & ~(mask)) | (val)), \
diff --git a/include/sound/hdmi-codec.h b/include/sound/hdmi-codec.h
new file mode 100644 (file)
index 0000000..fc3a481
--- /dev/null
@@ -0,0 +1,100 @@
+/*
+ * hdmi-codec.h - HDMI Codec driver API
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Jyri Sarha <jsarha@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#ifndef __HDMI_CODEC_H__
+#define __HDMI_CODEC_H__
+
+#include <linux/hdmi.h>
+#include <drm/drm_edid.h>
+#include <sound/asoundef.h>
+#include <uapi/sound/asound.h>
+
+/*
+ * Protocol between ASoC cpu-dai and HDMI-encoder
+ */
+struct hdmi_codec_daifmt {
+       enum {
+               HDMI_I2S,
+               HDMI_RIGHT_J,
+               HDMI_LEFT_J,
+               HDMI_DSP_A,
+               HDMI_DSP_B,
+               HDMI_AC97,
+               HDMI_SPDIF,
+       } fmt;
+       int bit_clk_inv:1;
+       int frame_clk_inv:1;
+       int bit_clk_master:1;
+       int frame_clk_master:1;
+};
+
+/*
+ * HDMI audio parameters
+ */
+struct hdmi_codec_params {
+       struct hdmi_audio_infoframe cea;
+       struct snd_aes_iec958 iec;
+       int sample_rate;
+       int sample_width;
+       int channels;
+};
+
+struct hdmi_codec_ops {
+       /*
+        * Called when ASoC starts an audio stream setup.
+        * Optional
+        */
+       int (*audio_startup)(struct device *dev);
+
+       /*
+        * Configures HDMI-encoder for audio stream.
+        * Mandatory
+        */
+       int (*hw_params)(struct device *dev,
+                        struct hdmi_codec_daifmt *fmt,
+                        struct hdmi_codec_params *hparms);
+
+       /*
+        * Shuts down the audio stream.
+        * Mandatory
+        */
+       void (*audio_shutdown)(struct device *dev);
+
+       /*
+        * Mute/unmute HDMI audio stream.
+        * Optional
+        */
+       int (*digital_mute)(struct device *dev, bool enable);
+
+       /*
+        * Provides EDID-Like-Data from connected HDMI device.
+        * Optional
+        */
+       int (*get_eld)(struct device *dev, uint8_t *buf, size_t len);
+};
+
+/* HDMI codec initalization data */
+struct hdmi_codec_pdata {
+       const struct hdmi_codec_ops *ops;
+       uint i2s:1;
+       uint spdif:1;
+       int max_i2s_channels;
+};
+
+#define HDMI_CODEC_DRV_NAME "hdmi-audio-codec"
+
+#endif /* __HDMI_CODEC_H__ */
index 0eed397aca8e87904540ddbf8156f9abf6de6ec2..36f023acb201efef62fabd2debcb56cb8b7e1691 100644 (file)
@@ -6,4 +6,6 @@
 int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
        size_t len);
 
+int snd_pcm_create_iec958_consumer_hw_params(struct snd_pcm_hw_params *params,
+                                            u8 *cs, size_t len);
 #endif
index 97069466c38dd90ffb518fc8b367073c787697be..3101d53468aad5e1e86f7d65a90fdc37ffbafd8f 100644 (file)
@@ -100,6 +100,7 @@ struct device;
 {       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
+/* DEPRECATED: use SND_SOC_DAPM_SUPPLY */
 #define SND_SOC_DAPM_MICBIAS(wname, wreg, wshift, winvert) \
 {      .id = snd_soc_dapm_micbias, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
@@ -473,7 +474,7 @@ enum snd_soc_dapm_type {
        snd_soc_dapm_out_drv,                   /* output driver */
        snd_soc_dapm_adc,                       /* analog to digital converter */
        snd_soc_dapm_dac,                       /* digital to analog converter */
-       snd_soc_dapm_micbias,           /* microphone bias (power) */
+       snd_soc_dapm_micbias,           /* microphone bias (power) - DEPRECATED: use snd_soc_dapm_supply */
        snd_soc_dapm_mic,                       /* microphone */
        snd_soc_dapm_hp,                        /* headphones */
        snd_soc_dapm_spk,                       /* speaker */
index 02b4a215fd751e6fcddf1856f667fe8c3e56a2eb..fd7b58a58d6f9c26b484210a237df709e3fb2f4d 100644 (file)
@@ -1002,7 +1002,7 @@ struct snd_soc_dai_link {
         */
        const char *platform_name;
        struct device_node *platform_of_node;
-       int be_id;      /* optional ID for machine driver BE identification */
+       int id; /* optional ID for machine driver link identification */
 
        const struct snd_soc_pcm_stream *params;
        unsigned int num_params;
@@ -1683,6 +1683,9 @@ void snd_soc_remove_dai_link(struct snd_soc_card *card,
 int snd_soc_register_dai(struct snd_soc_component *component,
        struct snd_soc_dai_driver *dai_drv);
 
+struct snd_soc_dai *snd_soc_find_dai(
+       const struct snd_soc_dai_link_component *dlc);
+
 #include <sound/soc-dai.h>
 
 #ifdef CONFIG_DEBUG_FS
index 67bf49d8c94407ca6fe5547e7ce07ef992bab3fc..609cadb8739dbd143b6136d26cb7af2d7a0fc08a 100644 (file)
@@ -672,7 +672,7 @@ enum {
 
 /* global timers (device member) */
 #define SNDRV_TIMER_GLOBAL_SYSTEM      0
-#define SNDRV_TIMER_GLOBAL_RTC         1
+#define SNDRV_TIMER_GLOBAL_RTC         1       /* unused */
 #define SNDRV_TIMER_GLOBAL_HPET                2
 #define SNDRV_TIMER_GLOBAL_HRTIMER     3
 
index 6d12ca9bcb807d3a79a20f342eb15093ee8db9c9..9749f9e8b45c525d1560ddf467bf6a9cdcdffa72 100644 (file)
@@ -141,35 +141,6 @@ config SND_SEQ_HRTIMER_DEFAULT
          Say Y here to use the HR-timer backend as the default sequencer
          timer.
 
-config SND_RTCTIMER
-       tristate "RTC Timer support"
-       depends on RTC
-       select SND_TIMER
-       help
-         Say Y here to enable RTC timer support for ALSA.  ALSA uses
-         the RTC timer as a precise timing source and maps the RTC
-         timer to ALSA's timer interface.  The ALSA sequencer code also
-         can use this timing source.
-
-         To compile this driver as a module, choose M here: the module
-         will be called snd-rtctimer.
-
-         Note that this option is exclusive with the new RTC drivers
-         (CONFIG_RTC_CLASS) since this requires the old API.
-
-config SND_SEQ_RTCTIMER_DEFAULT
-       bool "Use RTC as default sequencer timer"
-       depends on SND_RTCTIMER && SND_SEQUENCER
-       depends on !SND_SEQ_HRTIMER_DEFAULT
-       default y
-       help
-         Say Y here to use the RTC timer as the default sequencer
-         timer.  This is strongly recommended because it ensures
-         precise MIDI timing even when the system timer runs at less
-         than 1000 Hz.
-
-         If in doubt, say Y.
-
 config SND_DYNAMIC_MINORS
        bool "Dynamic device file minor numbers"
        help
index 48ab4b8f82790809838c3a87535587636ea69ed7..e85d9dd12c2d7c379ce7234ab70d319c772736f7 100644 (file)
@@ -37,7 +37,6 @@ obj-$(CONFIG_SND)             += snd.o
 obj-$(CONFIG_SND_HWDEP)                += snd-hwdep.o
 obj-$(CONFIG_SND_TIMER)                += snd-timer.o
 obj-$(CONFIG_SND_HRTIMER)      += snd-hrtimer.o
-obj-$(CONFIG_SND_RTCTIMER)     += snd-rtctimer.o
 obj-$(CONFIG_SND_PCM)          += snd-pcm.o
 obj-$(CONFIG_SND_DMAENGINE_PCM)        += snd-pcm-dmaengine.o
 obj-$(CONFIG_SND_RAWMIDI)      += snd-rawmidi.o
index a9933c07a6bf542e38b54ec8ed70204fbc429d55..9b3334be9df23c8f48a8768ee8b723318252873f 100644 (file)
@@ -288,9 +288,12 @@ static ssize_t snd_compr_write(struct file *f, const char __user *buf,
        stream = &data->stream;
        mutex_lock(&stream->device->lock);
        /* write is allowed when stream is running or has been steup */
-       if (stream->runtime->state != SNDRV_PCM_STATE_SETUP &&
-           stream->runtime->state != SNDRV_PCM_STATE_PREPARED &&
-                       stream->runtime->state != SNDRV_PCM_STATE_RUNNING) {
+       switch (stream->runtime->state) {
+       case SNDRV_PCM_STATE_SETUP:
+       case SNDRV_PCM_STATE_PREPARED:
+       case SNDRV_PCM_STATE_RUNNING:
+               break;
+       default:
                mutex_unlock(&stream->device->lock);
                return -EBADFD;
        }
@@ -391,14 +394,13 @@ static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
        int retval = 0;
 
        if (snd_BUG_ON(!data))
-               return -EFAULT;
+               return POLLERR;
+
        stream = &data->stream;
-       if (snd_BUG_ON(!stream))
-               return -EFAULT;
 
        mutex_lock(&stream->device->lock);
        if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
-               retval = -EBADFD;
+               retval = snd_compr_get_poll(stream) | POLLERR;
                goto out;
        }
        poll_wait(f, &stream->runtime->sleep, wait);
@@ -421,10 +423,7 @@ static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
                        retval = snd_compr_get_poll(stream);
                break;
        default:
-               if (stream->direction == SND_COMPRESS_PLAYBACK)
-                       retval = POLLOUT | POLLWRNORM | POLLERR;
-               else
-                       retval = POLLIN | POLLRDNORM | POLLERR;
+               retval = snd_compr_get_poll(stream) | POLLERR;
                break;
        }
 out:
@@ -802,9 +801,9 @@ static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 
        if (snd_BUG_ON(!data))
                return -EFAULT;
+
        stream = &data->stream;
-       if (snd_BUG_ON(!stream))
-               return -EFAULT;
+
        mutex_lock(&stream->device->lock);
        switch (_IOC_NR(cmd)) {
        case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
index 656d9a9032dc2165d1f30f4ef193250a07bec555..e2f27022b363c482ba2614a2579f87f2b19192e3 100644 (file)
@@ -38,37 +38,53 @@ static unsigned int resolution;
 struct snd_hrtimer {
        struct snd_timer *timer;
        struct hrtimer hrt;
-       atomic_t running;
+       bool in_callback;
 };
 
 static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
 {
        struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);
        struct snd_timer *t = stime->timer;
-       unsigned long oruns;
-
-       if (!atomic_read(&stime->running))
-               return HRTIMER_NORESTART;
-
-       oruns = hrtimer_forward_now(hrt, ns_to_ktime(t->sticks * resolution));
-       snd_timer_interrupt(stime->timer, t->sticks * oruns);
+       ktime_t delta;
+       unsigned long ticks;
+       enum hrtimer_restart ret = HRTIMER_NORESTART;
+
+       spin_lock(&t->lock);
+       if (!t->running)
+               goto out; /* fast path */
+       stime->in_callback = true;
+       ticks = t->sticks;
+       spin_unlock(&t->lock);
+
+       /* calculate the drift */
+       delta = ktime_sub(hrt->base->get_time(), hrtimer_get_expires(hrt));
+       if (delta.tv64 > 0)
+               ticks += ktime_divns(delta, ticks * resolution);
+
+       snd_timer_interrupt(stime->timer, ticks);
+
+       spin_lock(&t->lock);
+       if (t->running) {
+               hrtimer_add_expires_ns(hrt, t->sticks * resolution);
+               ret = HRTIMER_RESTART;
+       }
 
-       if (!atomic_read(&stime->running))
-               return HRTIMER_NORESTART;
-       return HRTIMER_RESTART;
+       stime->in_callback = false;
+ out:
+       spin_unlock(&t->lock);
+       return ret;
 }
 
 static int snd_hrtimer_open(struct snd_timer *t)
 {
        struct snd_hrtimer *stime;
 
-       stime = kmalloc(sizeof(*stime), GFP_KERNEL);
+       stime = kzalloc(sizeof(*stime), GFP_KERNEL);
        if (!stime)
                return -ENOMEM;
        hrtimer_init(&stime->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
        stime->timer = t;
        stime->hrt.function = snd_hrtimer_callback;
-       atomic_set(&stime->running, 0);
        t->private_data = stime;
        return 0;
 }
@@ -78,6 +94,11 @@ static int snd_hrtimer_close(struct snd_timer *t)
        struct snd_hrtimer *stime = t->private_data;
 
        if (stime) {
+               spin_lock_irq(&t->lock);
+               t->running = 0; /* just to be sure */
+               stime->in_callback = 1; /* skip start/stop */
+               spin_unlock_irq(&t->lock);
+
                hrtimer_cancel(&stime->hrt);
                kfree(stime);
                t->private_data = NULL;
@@ -89,18 +110,19 @@ static int snd_hrtimer_start(struct snd_timer *t)
 {
        struct snd_hrtimer *stime = t->private_data;
 
-       atomic_set(&stime->running, 0);
-       hrtimer_try_to_cancel(&stime->hrt);
+       if (stime->in_callback)
+               return 0;
        hrtimer_start(&stime->hrt, ns_to_ktime(t->sticks * resolution),
                      HRTIMER_MODE_REL);
-       atomic_set(&stime->running, 1);
        return 0;
 }
 
 static int snd_hrtimer_stop(struct snd_timer *t)
 {
        struct snd_hrtimer *stime = t->private_data;
-       atomic_set(&stime->running, 0);
+
+       if (stime->in_callback)
+               return 0;
        hrtimer_try_to_cancel(&stime->hrt);
        return 0;
 }
index 697c166acf05e60cce4a23add6a0b45978259dbe..8eb58c709b141140660ec623d94e01a01abb4a93 100644 (file)
@@ -106,8 +106,9 @@ EXPORT_SYMBOL_GPL(snd_hwparams_to_dma_slave_config);
  * direction of the substream. If the substream is a playback stream the dst
  * fields will be initialized, if it is a capture stream the src fields will be
  * initialized. The {dst,src}_addr_width field will only be initialized if the
- * addr_width field of the DAI DMA data struct is not equal to
- * DMA_SLAVE_BUSWIDTH_UNDEFINED.
+ * SND_DMAENGINE_PCM_DAI_FLAG_PACK flag is set or if the addr_width field of
+ * the DAI DMA data struct is not equal to DMA_SLAVE_BUSWIDTH_UNDEFINED. If
+ * both conditions are met the latter takes priority.
  */
 void snd_dmaengine_pcm_set_config_from_dai_data(
        const struct snd_pcm_substream *substream,
@@ -117,11 +118,17 @@ void snd_dmaengine_pcm_set_config_from_dai_data(
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                slave_config->dst_addr = dma_data->addr;
                slave_config->dst_maxburst = dma_data->maxburst;
+               if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
+                       slave_config->dst_addr_width =
+                               DMA_SLAVE_BUSWIDTH_UNDEFINED;
                if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
                        slave_config->dst_addr_width = dma_data->addr_width;
        } else {
                slave_config->src_addr = dma_data->addr;
                slave_config->src_maxburst = dma_data->maxburst;
+               if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
+                       slave_config->src_addr_width =
+                               DMA_SLAVE_BUSWIDTH_UNDEFINED;
                if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
                        slave_config->src_addr_width = dma_data->addr_width;
        }
index 36b2d7aca1bdc3af6eefa9b9793343e32f12ebec..5e6aed64f45150e839a4ab3bf9a4a9554791d281 100644 (file)
@@ -9,30 +9,18 @@
 #include <linux/types.h>
 #include <sound/asoundef.h>
 #include <sound/pcm.h>
+#include <sound/pcm_params.h>
 #include <sound/pcm_iec958.h>
 
-/**
- * snd_pcm_create_iec958_consumer - create consumer format IEC958 channel status
- * @runtime: pcm runtime structure with ->rate filled in
- * @cs: channel status buffer, at least four bytes
- * @len: length of channel status buffer
- *
- * Create the consumer format channel status data in @cs of maximum size
- * @len corresponding to the parameters of the PCM runtime @runtime.
- *
- * Drivers may wish to tweak the contents of the buffer after creation.
- *
- * Returns: length of buffer, or negative error code if something failed.
- */
-int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
-       size_t len)
+static int create_iec958_consumer(uint rate, uint sample_width,
+                                 u8 *cs, size_t len)
 {
        unsigned int fs, ws;
 
        if (len < 4)
                return -EINVAL;
 
-       switch (runtime->rate) {
+       switch (rate) {
        case 32000:
                fs = IEC958_AES3_CON_FS_32000;
                break;
@@ -59,7 +47,7 @@ int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
        }
 
        if (len > 4) {
-               switch (snd_pcm_format_width(runtime->format)) {
+               switch (sample_width) {
                case 16:
                        ws = IEC958_AES4_CON_WORDLEN_20_16;
                        break;
@@ -71,6 +59,7 @@ int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
                             IEC958_AES4_CON_MAX_WORDLEN_24;
                        break;
                case 24:
+               case 32: /* Assume 24-bit width for 32-bit samples. */
                        ws = IEC958_AES4_CON_WORDLEN_24_20 |
                             IEC958_AES4_CON_MAX_WORDLEN_24;
                        break;
@@ -92,4 +81,46 @@ int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
 
        return len;
 }
+
+/**
+ * snd_pcm_create_iec958_consumer - create consumer format IEC958 channel status
+ * @runtime: pcm runtime structure with ->rate filled in
+ * @cs: channel status buffer, at least four bytes
+ * @len: length of channel status buffer
+ *
+ * Create the consumer format channel status data in @cs of maximum size
+ * @len corresponding to the parameters of the PCM runtime @runtime.
+ *
+ * Drivers may wish to tweak the contents of the buffer after creation.
+ *
+ * Returns: length of buffer, or negative error code if something failed.
+ */
+int snd_pcm_create_iec958_consumer(struct snd_pcm_runtime *runtime, u8 *cs,
+       size_t len)
+{
+       return create_iec958_consumer(runtime->rate,
+                                     snd_pcm_format_width(runtime->format),
+                                     cs, len);
+}
 EXPORT_SYMBOL(snd_pcm_create_iec958_consumer);
+
+/**
+ * snd_pcm_create_iec958_consumer_hw_params - create IEC958 channel status
+ * @hw_params: the hw_params instance for extracting rate and sample format
+ * @cs: channel status buffer, at least four bytes
+ * @len: length of channel status buffer
+ *
+ * Create the consumer format channel status data in @cs of maximum size
+ * @len corresponding to the parameters of the PCM runtime @runtime.
+ *
+ * Drivers may wish to tweak the contents of the buffer after creation.
+ *
+ * Returns: length of buffer, or negative error code if something failed.
+ */
+int snd_pcm_create_iec958_consumer_hw_params(struct snd_pcm_hw_params *params,
+                                            u8 *cs, size_t len)
+{
+       return create_iec958_consumer(params_rate(params), params_width(params),
+                                     cs, len);
+}
+EXPORT_SYMBOL(snd_pcm_create_iec958_consumer_hw_params);
index 3a9b66c6e09c38933b63a4af6ee20e34efa09118..bb1261591a1f300e17f8cb27e36071e5b3fb28a8 100644 (file)
@@ -1886,8 +1886,8 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
                snd_timer_interrupt(substream->timer, 1);
 #endif
  _end:
-       snd_pcm_stream_unlock_irqrestore(substream, flags);
        kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
+       snd_pcm_stream_unlock_irqrestore(substream, flags);
 }
 
 EXPORT_SYMBOL(snd_pcm_period_elapsed);
@@ -2595,6 +2595,8 @@ int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
        };
        int err;
 
+       if (WARN_ON(pcm->streams[stream].chmap_kctl))
+               return -EBUSY;
        info = kzalloc(sizeof(*info), GFP_KERNEL);
        if (!info)
                return -ENOMEM;
index 9106d8e2300eab3e566f9a3807c469ee02aa7bcd..c61fd50f771f9ecd55c8e472d152321b37255e71 100644 (file)
@@ -3161,7 +3161,7 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
 
        substream = pcm_file->substream;
        if (PCM_RUNTIME_CHECK(substream))
-               return -ENXIO;
+               return POLLOUT | POLLWRNORM | POLLERR;
        runtime = substream->runtime;
 
        poll_wait(file, &runtime->sleep, wait);
@@ -3200,7 +3200,7 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
 
        substream = pcm_file->substream;
        if (PCM_RUNTIME_CHECK(substream))
-               return -ENXIO;
+               return POLLIN | POLLRDNORM | POLLERR;
        runtime = substream->runtime;
 
        poll_wait(file, &runtime->sleep, wait);
diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c
deleted file mode 100644 (file)
index f3420d1..0000000
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- *  RTC based high-frequency timer
- *
- *  Copyright (C) 2000 Takashi Iwai
- *     based on rtctimer.c by Steve Ratcliffe
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
-
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/log2.h>
-#include <sound/core.h>
-#include <sound/timer.h>
-
-#if IS_ENABLED(CONFIG_RTC)
-
-#include <linux/mc146818rtc.h>
-
-#define RTC_FREQ       1024            /* default frequency */
-#define NANO_SEC       1000000000L     /* 10^9 in sec */
-
-/*
- * prototypes
- */
-static int rtctimer_open(struct snd_timer *t);
-static int rtctimer_close(struct snd_timer *t);
-static int rtctimer_start(struct snd_timer *t);
-static int rtctimer_stop(struct snd_timer *t);
-
-
-/*
- * The hardware dependent description for this timer.
- */
-static struct snd_timer_hardware rtc_hw = {
-       .flags =        SNDRV_TIMER_HW_AUTO |
-                       SNDRV_TIMER_HW_FIRST |
-                       SNDRV_TIMER_HW_TASKLET,
-       .ticks =        100000000L,             /* FIXME: XXX */
-       .open =         rtctimer_open,
-       .close =        rtctimer_close,
-       .start =        rtctimer_start,
-       .stop =         rtctimer_stop,
-};
-
-static int rtctimer_freq = RTC_FREQ;           /* frequency */
-static struct snd_timer *rtctimer;
-static struct tasklet_struct rtc_tasklet;
-static rtc_task_t rtc_task;
-
-
-static int
-rtctimer_open(struct snd_timer *t)
-{
-       int err;
-
-       err = rtc_register(&rtc_task);
-       if (err < 0)
-               return err;
-       t->private_data = &rtc_task;
-       return 0;
-}
-
-static int
-rtctimer_close(struct snd_timer *t)
-{
-       rtc_task_t *rtc = t->private_data;
-       if (rtc) {
-               rtc_unregister(rtc);
-               tasklet_kill(&rtc_tasklet);
-               t->private_data = NULL;
-       }
-       return 0;
-}
-
-static int
-rtctimer_start(struct snd_timer *timer)
-{
-       rtc_task_t *rtc = timer->private_data;
-       if (snd_BUG_ON(!rtc))
-               return -EINVAL;
-       rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq);
-       rtc_control(rtc, RTC_PIE_ON, 0);
-       return 0;
-}
-
-static int
-rtctimer_stop(struct snd_timer *timer)
-{
-       rtc_task_t *rtc = timer->private_data;
-       if (snd_BUG_ON(!rtc))
-               return -EINVAL;
-       rtc_control(rtc, RTC_PIE_OFF, 0);
-       return 0;
-}
-
-static void rtctimer_tasklet(unsigned long data)
-{
-       snd_timer_interrupt((struct snd_timer *)data, 1);
-}
-
-/*
- * interrupt
- */
-static void rtctimer_interrupt(void *private_data)
-{
-       tasklet_schedule(private_data);
-}
-
-
-/*
- *  ENTRY functions
- */
-static int __init rtctimer_init(void)
-{
-       int err;
-       struct snd_timer *timer;
-
-       if (rtctimer_freq < 2 || rtctimer_freq > 8192 ||
-           !is_power_of_2(rtctimer_freq)) {
-               pr_err("ALSA: rtctimer: invalid frequency %d\n", rtctimer_freq);
-               return -EINVAL;
-       }
-
-       /* Create a new timer and set up the fields */
-       err = snd_timer_global_new("rtc", SNDRV_TIMER_GLOBAL_RTC, &timer);
-       if (err < 0)
-               return err;
-
-       timer->module = THIS_MODULE;
-       strcpy(timer->name, "RTC timer");
-       timer->hw = rtc_hw;
-       timer->hw.resolution = NANO_SEC / rtctimer_freq;
-
-       tasklet_init(&rtc_tasklet, rtctimer_tasklet, (unsigned long)timer);
-
-       /* set up RTC callback */
-       rtc_task.func = rtctimer_interrupt;
-       rtc_task.private_data = &rtc_tasklet;
-
-       err = snd_timer_global_register(timer);
-       if (err < 0) {
-               snd_timer_global_free(timer);
-               return err;
-       }
-       rtctimer = timer; /* remember this */
-
-       return 0;
-}
-
-static void __exit rtctimer_exit(void)
-{
-       if (rtctimer) {
-               snd_timer_global_free(rtctimer);
-               rtctimer = NULL;
-       }
-}
-
-
-/*
- * exported stuff
- */
-module_init(rtctimer_init)
-module_exit(rtctimer_exit)
-
-module_param(rtctimer_freq, int, 0444);
-MODULE_PARM_DESC(rtctimer_freq, "timer frequency in Hz");
-
-MODULE_LICENSE("GPL");
-
-MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));
-
-#endif /* IS_ENABLED(CONFIG_RTC) */
index 7e0aabb808a66007d3719be8ca7885a611164ed3..639544b4fb044c3560196f451d5990c778f7a8e2 100644 (file)
@@ -47,8 +47,6 @@ int seq_default_timer_card = -1;
 int seq_default_timer_device =
 #ifdef CONFIG_SND_SEQ_HRTIMER_DEFAULT
        SNDRV_TIMER_GLOBAL_HRTIMER
-#elif defined(CONFIG_SND_SEQ_RTCTIMER_DEFAULT)
-       SNDRV_TIMER_GLOBAL_RTC
 #else
        SNDRV_TIMER_GLOBAL_SYSTEM
 #endif
index 6469bedda2f3c033a30007e910caf4c500aeaca7..e722022d325d7771d0d516c08ad830d814eeebdc 100644 (file)
@@ -37,8 +37,6 @@
 
 #if IS_ENABLED(CONFIG_SND_HRTIMER)
 #define DEFAULT_TIMER_LIMIT 4
-#elif IS_ENABLED(CONFIG_SND_RTCTIMER)
-#define DEFAULT_TIMER_LIMIT 2
 #else
 #define DEFAULT_TIMER_LIMIT 1
 #endif
@@ -1225,6 +1223,7 @@ static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
                tu->tstamp = *tstamp;
        if ((tu->filter & (1 << event)) == 0 || !tu->tread)
                return;
+       memset(&r1, 0, sizeof(r1));
        r1.event = event;
        r1.tstamp = *tstamp;
        r1.val = resolution;
@@ -1267,6 +1266,7 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
        }
        if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&
            tu->last_resolution != resolution) {
+               memset(&r1, 0, sizeof(r1));
                r1.event = SNDRV_TIMER_EVENT_RESOLUTION;
                r1.tstamp = tstamp;
                r1.val = resolution;
@@ -1739,6 +1739,7 @@ static int snd_timer_user_params(struct file *file,
        if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
                if (tu->tread) {
                        struct snd_timer_tread tread;
+                       memset(&tread, 0, sizeof(tread));
                        tread.event = SNDRV_TIMER_EVENT_EARLY;
                        tread.tstamp.tv_sec = 0;
                        tread.tstamp.tv_nsec = 0;
index 2a779c2f63abc7978842890b815c700b5ab50236..ab894ed1ff6717a8acde6581fef9842dbb8d5c35 100644 (file)
@@ -134,6 +134,7 @@ config SND_FIREWIRE_TASCAM
         Say Y here to include support for TASCAM.
          * FW-1884
          * FW-1082
+         * FW-1804
 
         To compile this driver as a module, choose M here: the module
         will be called snd-firewire-tascam.
index 003c09029786c592750b13b2c28c86c88b587b6f..0ee1fb115d8833bb076b74079de1b1222d8d98e3 100644 (file)
@@ -1,3 +1,6 @@
+# To find a header included by define_trace.h.
+CFLAGS_amdtp-stream.o  := -I$(src)
+
 snd-firewire-lib-objs := lib.o iso-resources.o packets-buffer.o \
                         fcp.o cmp.o amdtp-stream.o amdtp-am824.o
 snd-isight-objs := isight.o
diff --git a/sound/firewire/amdtp-stream-trace.h b/sound/firewire/amdtp-stream-trace.h
new file mode 100644 (file)
index 0000000..9c04faf
--- /dev/null
@@ -0,0 +1,110 @@
+/*
+ * amdtp-stream-trace.h - tracepoint definitions to dump a part of packet data
+ *
+ * Copyright (c) 2016 Takashi Sakamoto
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM           snd_firewire_lib
+
+#if !defined(_AMDTP_STREAM_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _AMDTP_STREAM_TRACE_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(in_packet,
+       TP_PROTO(const struct amdtp_stream *s, u32 cycles, u32 cip_header[2], unsigned int payload_quadlets, unsigned int index),
+       TP_ARGS(s, cycles, cip_header, payload_quadlets, index),
+       TP_STRUCT__entry(
+               __field(unsigned int, second)
+               __field(unsigned int, cycle)
+               __field(int, channel)
+               __field(int, src)
+               __field(int, dest)
+               __field(u32, cip_header0)
+               __field(u32, cip_header1)
+               __field(unsigned int, payload_quadlets)
+               __field(unsigned int, packet_index)
+               __field(unsigned int, irq)
+               __field(unsigned int, index)
+       ),
+       TP_fast_assign(
+               __entry->second = cycles / CYCLES_PER_SECOND;
+               __entry->cycle = cycles % CYCLES_PER_SECOND;
+               __entry->channel = s->context->channel;
+               __entry->src = fw_parent_device(s->unit)->node_id;
+               __entry->dest = fw_parent_device(s->unit)->card->node_id;
+               __entry->cip_header0 = cip_header[0];
+               __entry->cip_header1 = cip_header[1];
+               __entry->payload_quadlets = payload_quadlets;
+               __entry->packet_index = s->packet_index;
+               __entry->irq = !!in_interrupt();
+               __entry->index = index;
+       ),
+       TP_printk(
+               "%02u %04u %04x %04x %02d %08x %08x %03u %02u %01u %02u",
+               __entry->second,
+               __entry->cycle,
+               __entry->src,
+               __entry->dest,
+               __entry->channel,
+               __entry->cip_header0,
+               __entry->cip_header1,
+               __entry->payload_quadlets,
+               __entry->packet_index,
+               __entry->irq,
+               __entry->index)
+);
+
+TRACE_EVENT(out_packet,
+       TP_PROTO(const struct amdtp_stream *s, u32 cycles, __be32 *cip_header, unsigned int payload_length, unsigned int index),
+       TP_ARGS(s, cycles, cip_header, payload_length, index),
+       TP_STRUCT__entry(
+               __field(unsigned int, second)
+               __field(unsigned int, cycle)
+               __field(int, channel)
+               __field(int, src)
+               __field(int, dest)
+               __field(u32, cip_header0)
+               __field(u32, cip_header1)
+               __field(unsigned int, payload_quadlets)
+               __field(unsigned int, packet_index)
+               __field(unsigned int, irq)
+               __field(unsigned int, index)
+       ),
+       TP_fast_assign(
+               __entry->second = cycles / CYCLES_PER_SECOND;
+               __entry->cycle = cycles % CYCLES_PER_SECOND;
+               __entry->channel = s->context->channel;
+               __entry->src = fw_parent_device(s->unit)->card->node_id;
+               __entry->dest = fw_parent_device(s->unit)->node_id;
+               __entry->cip_header0 = be32_to_cpu(cip_header[0]);
+               __entry->cip_header1 = be32_to_cpu(cip_header[1]);
+               __entry->payload_quadlets = payload_length / 4;
+               __entry->packet_index = s->packet_index;
+               __entry->irq = !!in_interrupt();
+               __entry->index = index;
+       ),
+       TP_printk(
+               "%02u %04u %04x %04x %02d %08x %08x %03u %02u %01u %02u",
+               __entry->second,
+               __entry->cycle,
+               __entry->src,
+               __entry->dest,
+               __entry->channel,
+               __entry->cip_header0,
+               __entry->cip_header1,
+               __entry->payload_quadlets,
+               __entry->packet_index,
+               __entry->irq,
+               __entry->index)
+);
+
+#endif
+
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH     .
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_FILE     amdtp-stream-trace
+#include <trace/define_trace.h>
index ed2902609a4c6cd0fd854e6ee29f6eaa866499c0..00060c4a9deb4ec239f34dc857ceebf75615d65c 100644 (file)
 #define CYCLES_PER_SECOND      8000
 #define TICKS_PER_SECOND       (TICKS_PER_CYCLE * CYCLES_PER_SECOND)
 
+/* Always support Linux tracing subsystem. */
+#define CREATE_TRACE_POINTS
+#include "amdtp-stream-trace.h"
+
 #define TRANSFER_DELAY_TICKS   0x2e00 /* 479.17 microseconds */
 
 /* isochronous header parameters */
@@ -87,7 +91,6 @@ int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
 
        init_waitqueue_head(&s->callback_wait);
        s->callbacked = false;
-       s->sync_slave = NULL;
 
        s->fmt = fmt;
        s->process_data_blocks = process_data_blocks;
@@ -102,6 +105,10 @@ EXPORT_SYMBOL(amdtp_stream_init);
  */
 void amdtp_stream_destroy(struct amdtp_stream *s)
 {
+       /* Not initialized. */
+       if (s->protocol == NULL)
+               return;
+
        WARN_ON(amdtp_stream_running(s));
        kfree(s->protocol);
        mutex_destroy(&s->mutex);
@@ -244,7 +251,6 @@ void amdtp_stream_pcm_prepare(struct amdtp_stream *s)
        tasklet_kill(&s->period_tasklet);
        s->pcm_buffer_pointer = 0;
        s->pcm_period_pointer = 0;
-       s->pointer_flush = true;
 }
 EXPORT_SYMBOL(amdtp_stream_pcm_prepare);
 
@@ -349,7 +355,6 @@ static void update_pcm_pointers(struct amdtp_stream *s,
        s->pcm_period_pointer += frames;
        if (s->pcm_period_pointer >= pcm->runtime->period_size) {
                s->pcm_period_pointer -= pcm->runtime->period_size;
-               s->pointer_flush = false;
                tasklet_hi_schedule(&s->period_tasklet);
        }
 }
@@ -363,9 +368,8 @@ static void pcm_period_tasklet(unsigned long data)
                snd_pcm_period_elapsed(pcm);
 }
 
-static int queue_packet(struct amdtp_stream *s,
-                       unsigned int header_length,
-                       unsigned int payload_length, bool skip)
+static int queue_packet(struct amdtp_stream *s, unsigned int header_length,
+                       unsigned int payload_length)
 {
        struct fw_iso_packet p = {0};
        int err = 0;
@@ -376,8 +380,10 @@ static int queue_packet(struct amdtp_stream *s,
        p.interrupt = IS_ALIGNED(s->packet_index + 1, INTERRUPT_INTERVAL);
        p.tag = TAG_CIP;
        p.header_length = header_length;
-       p.payload_length = (!skip) ? payload_length : 0;
-       p.skip = skip;
+       if (payload_length > 0)
+               p.payload_length = payload_length;
+       else
+               p.skip = true;
        err = fw_iso_context_queue(s->context, &p, &s->buffer.iso_buffer,
                                   s->buffer.packets[s->packet_index].offset);
        if (err < 0) {
@@ -392,27 +398,30 @@ end:
 }
 
 static inline int queue_out_packet(struct amdtp_stream *s,
-                                  unsigned int payload_length, bool skip)
+                                  unsigned int payload_length)
 {
-       return queue_packet(s, OUT_PACKET_HEADER_SIZE,
-                           payload_length, skip);
+       return queue_packet(s, OUT_PACKET_HEADER_SIZE, payload_length);
 }
 
 static inline int queue_in_packet(struct amdtp_stream *s)
 {
        return queue_packet(s, IN_PACKET_HEADER_SIZE,
-                           amdtp_stream_get_max_payload(s), false);
+                           amdtp_stream_get_max_payload(s));
 }
 
-static int handle_out_packet(struct amdtp_stream *s, unsigned int data_blocks,
-                            unsigned int syt)
+static int handle_out_packet(struct amdtp_stream *s, unsigned int cycle,
+                            unsigned int index)
 {
        __be32 *buffer;
+       unsigned int syt;
+       unsigned int data_blocks;
        unsigned int payload_length;
        unsigned int pcm_frames;
        struct snd_pcm_substream *pcm;
 
        buffer = s->buffer.packets[s->packet_index].buffer;
+       syt = calculate_syt(s, cycle);
+       data_blocks = calculate_data_blocks(s, syt);
        pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
 
        buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
@@ -424,9 +433,11 @@ static int handle_out_packet(struct amdtp_stream *s, unsigned int data_blocks,
                                (syt & CIP_SYT_MASK));
 
        s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
-
        payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
-       if (queue_out_packet(s, payload_length, false) < 0)
+
+       trace_out_packet(s, cycle, buffer, payload_length, index);
+
+       if (queue_out_packet(s, payload_length) < 0)
                return -EIO;
 
        pcm = ACCESS_ONCE(s->pcm);
@@ -438,19 +449,24 @@ static int handle_out_packet(struct amdtp_stream *s, unsigned int data_blocks,
 }
 
 static int handle_in_packet(struct amdtp_stream *s,
-                           unsigned int payload_quadlets, __be32 *buffer,
-                           unsigned int *data_blocks, unsigned int syt)
+                           unsigned int payload_quadlets, unsigned int cycle,
+                           unsigned int index)
 {
+       __be32 *buffer;
        u32 cip_header[2];
-       unsigned int fmt, fdf;
+       unsigned int fmt, fdf, syt;
        unsigned int data_block_quadlets, data_block_counter, dbc_interval;
+       unsigned int data_blocks;
        struct snd_pcm_substream *pcm;
        unsigned int pcm_frames;
        bool lost;
 
+       buffer = s->buffer.packets[s->packet_index].buffer;
        cip_header[0] = be32_to_cpu(buffer[0]);
        cip_header[1] = be32_to_cpu(buffer[1]);
 
+       trace_in_packet(s, cycle, cip_header, payload_quadlets, index);
+
        /*
         * This module supports 'Two-quadlet CIP header with SYT field'.
         * For convenience, also check FMT field is AM824 or not.
@@ -460,7 +476,7 @@ static int handle_in_packet(struct amdtp_stream *s,
                dev_info_ratelimited(&s->unit->device,
                                "Invalid CIP header for AMDTP: %08X:%08X\n",
                                cip_header[0], cip_header[1]);
-               *data_blocks = 0;
+               data_blocks = 0;
                pcm_frames = 0;
                goto end;
        }
@@ -471,7 +487,7 @@ static int handle_in_packet(struct amdtp_stream *s,
                dev_info_ratelimited(&s->unit->device,
                                     "Detect unexpected protocol: %08x %08x\n",
                                     cip_header[0], cip_header[1]);
-               *data_blocks = 0;
+               data_blocks = 0;
                pcm_frames = 0;
                goto end;
        }
@@ -480,7 +496,7 @@ static int handle_in_packet(struct amdtp_stream *s,
        fdf = (cip_header[1] & CIP_FDF_MASK) >> CIP_FDF_SHIFT;
        if (payload_quadlets < 3 ||
            (fmt == CIP_FMT_AM && fdf == AMDTP_FDF_NO_DATA)) {
-               *data_blocks = 0;
+               data_blocks = 0;
        } else {
                data_block_quadlets =
                        (cip_header[0] & CIP_DBS_MASK) >> CIP_DBS_SHIFT;
@@ -494,12 +510,12 @@ static int handle_in_packet(struct amdtp_stream *s,
                if (s->flags & CIP_WRONG_DBS)
                        data_block_quadlets = s->data_block_quadlets;
 
-               *data_blocks = (payload_quadlets - 2) / data_block_quadlets;
+               data_blocks = (payload_quadlets - 2) / data_block_quadlets;
        }
 
        /* Check data block counter continuity */
        data_block_counter = cip_header[0] & CIP_DBC_MASK;
-       if (*data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
+       if (data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
            s->data_block_counter != UINT_MAX)
                data_block_counter = s->data_block_counter;
 
@@ -510,10 +526,10 @@ static int handle_in_packet(struct amdtp_stream *s,
        } else if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
                lost = data_block_counter != s->data_block_counter;
        } else {
-               if ((*data_blocks > 0) && (s->tx_dbc_interval > 0))
+               if (data_blocks > 0 && s->tx_dbc_interval > 0)
                        dbc_interval = s->tx_dbc_interval;
                else
-                       dbc_interval = *data_blocks;
+                       dbc_interval = data_blocks;
 
                lost = data_block_counter !=
                       ((s->data_block_counter + dbc_interval) & 0xff);
@@ -526,13 +542,14 @@ static int handle_in_packet(struct amdtp_stream *s,
                return -EIO;
        }
 
-       pcm_frames = s->process_data_blocks(s, buffer + 2, *data_blocks, &syt);
+       syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
+       pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
 
        if (s->flags & CIP_DBC_IS_END_EVENT)
                s->data_block_counter = data_block_counter;
        else
                s->data_block_counter =
-                               (data_block_counter + *data_blocks) & 0xff;
+                               (data_block_counter + data_blocks) & 0xff;
 end:
        if (queue_in_packet(s) < 0)
                return -EIO;
@@ -544,29 +561,50 @@ end:
        return 0;
 }
 
-static void out_stream_callback(struct fw_iso_context *context, u32 cycle,
+/*
+ * In CYCLE_TIMER register of IEEE 1394, 7 bits are used to represent second. On
+ * the other hand, in DMA descriptors of 1394 OHCI, 3 bits are used to represent
+ * it. Thus, via Linux firewire subsystem, we can get the 3 bits for second.
+ */
+static inline u32 compute_cycle_count(u32 tstamp)
+{
+       return (((tstamp >> 13) & 0x07) * 8000) + (tstamp & 0x1fff);
+}
+
+static inline u32 increment_cycle_count(u32 cycle, unsigned int addend)
+{
+       cycle += addend;
+       if (cycle >= 8 * CYCLES_PER_SECOND)
+               cycle -= 8 * CYCLES_PER_SECOND;
+       return cycle;
+}
+
+static inline u32 decrement_cycle_count(u32 cycle, unsigned int subtrahend)
+{
+       if (cycle < subtrahend)
+               cycle += 8 * CYCLES_PER_SECOND;
+       return cycle - subtrahend;
+}
+
+static void out_stream_callback(struct fw_iso_context *context, u32 tstamp,
                                size_t header_length, void *header,
                                void *private_data)
 {
        struct amdtp_stream *s = private_data;
-       unsigned int i, syt, packets = header_length / 4;
-       unsigned int data_blocks;
+       unsigned int i, packets = header_length / 4;
+       u32 cycle;
 
        if (s->packet_index < 0)
                return;
 
-       /*
-        * Compute the cycle of the last queued packet.
-        * (We need only the four lowest bits for the SYT, so we can ignore
-        * that bits 0-11 must wrap around at 3072.)
-        */
-       cycle += QUEUE_LENGTH - packets;
+       cycle = compute_cycle_count(tstamp);
 
-       for (i = 0; i < packets; ++i) {
-               syt = calculate_syt(s, ++cycle);
-               data_blocks = calculate_data_blocks(s, syt);
+       /* Align to actual cycle count for the last packet. */
+       cycle = increment_cycle_count(cycle, QUEUE_LENGTH - packets);
 
-               if (handle_out_packet(s, data_blocks, syt) < 0) {
+       for (i = 0; i < packets; ++i) {
+               cycle = increment_cycle_count(cycle, 1);
+               if (handle_out_packet(s, cycle, i) < 0) {
                        s->packet_index = -1;
                        amdtp_stream_pcm_abort(s);
                        return;
@@ -576,15 +614,15 @@ static void out_stream_callback(struct fw_iso_context *context, u32 cycle,
        fw_iso_context_queue_flush(s->context);
 }
 
-static void in_stream_callback(struct fw_iso_context *context, u32 cycle,
+static void in_stream_callback(struct fw_iso_context *context, u32 tstamp,
                               size_t header_length, void *header,
                               void *private_data)
 {
        struct amdtp_stream *s = private_data;
-       unsigned int p, syt, packets;
+       unsigned int i, packets;
        unsigned int payload_quadlets, max_payload_quadlets;
-       unsigned int data_blocks;
-       __be32 *buffer, *headers = header;
+       __be32 *headers = header;
+       u32 cycle;
 
        if (s->packet_index < 0)
                return;
@@ -592,70 +630,44 @@ static void in_stream_callback(struct fw_iso_context *context, u32 cycle,
        /* The number of packets in buffer */
        packets = header_length / IN_PACKET_HEADER_SIZE;
 
+       cycle = compute_cycle_count(tstamp);
+
+       /* Align to actual cycle count for the last packet. */
+       cycle = decrement_cycle_count(cycle, packets);
+
        /* For buffer-over-run prevention. */
        max_payload_quadlets = amdtp_stream_get_max_payload(s) / 4;
 
-       for (p = 0; p < packets; p++) {
-               buffer = s->buffer.packets[s->packet_index].buffer;
+       for (i = 0; i < packets; i++) {
+               cycle = increment_cycle_count(cycle, 1);
 
                /* The number of quadlets in this packet */
                payload_quadlets =
-                       (be32_to_cpu(headers[p]) >> ISO_DATA_LENGTH_SHIFT) / 4;
+                       (be32_to_cpu(headers[i]) >> ISO_DATA_LENGTH_SHIFT) / 4;
                if (payload_quadlets > max_payload_quadlets) {
                        dev_err(&s->unit->device,
                                "Detect jumbo payload: %02x %02x\n",
                                payload_quadlets, max_payload_quadlets);
-                       s->packet_index = -1;
                        break;
                }
 
-               syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
-               if (handle_in_packet(s, payload_quadlets, buffer,
-                                               &data_blocks, syt) < 0) {
-                       s->packet_index = -1;
+               if (handle_in_packet(s, payload_quadlets, cycle, i) < 0)
                        break;
-               }
-
-               /* Process sync slave stream */
-               if (s->sync_slave && s->sync_slave->callbacked) {
-                       if (handle_out_packet(s->sync_slave,
-                                             data_blocks, syt) < 0) {
-                               s->packet_index = -1;
-                               break;
-                       }
-               }
        }
 
-       /* Queueing error or detecting discontinuity */
-       if (s->packet_index < 0) {
+       /* Queueing error or detecting invalid payload. */
+       if (i < packets) {
+               s->packet_index = -1;
                amdtp_stream_pcm_abort(s);
-
-               /* Abort sync slave. */
-               if (s->sync_slave) {
-                       s->sync_slave->packet_index = -1;
-                       amdtp_stream_pcm_abort(s->sync_slave);
-               }
                return;
        }
 
-       /* when sync to device, flush the packets for slave stream */
-       if (s->sync_slave && s->sync_slave->callbacked)
-               fw_iso_context_queue_flush(s->sync_slave->context);
-
        fw_iso_context_queue_flush(s->context);
 }
 
-/* processing is done by master callback */
-static void slave_stream_callback(struct fw_iso_context *context, u32 cycle,
-                                 size_t header_length, void *header,
-                                 void *private_data)
-{
-       return;
-}
-
 /* this is executed one time */
 static void amdtp_stream_first_callback(struct fw_iso_context *context,
-                                       u32 cycle, size_t header_length,
+                                       u32 tstamp, size_t header_length,
                                        void *header, void *private_data)
 {
        struct amdtp_stream *s = private_data;
@@ -669,12 +681,10 @@ static void amdtp_stream_first_callback(struct fw_iso_context *context,
 
        if (s->direction == AMDTP_IN_STREAM)
                context->callback.sc = in_stream_callback;
-       else if (s->flags & CIP_SYNC_TO_DEVICE)
-               context->callback.sc = slave_stream_callback;
        else
                context->callback.sc = out_stream_callback;
 
-       context->callback.sc(context, cycle, header_length, header, s);
+       context->callback.sc(context, tstamp, header_length, header, s);
 }
 
 /**
@@ -713,8 +723,7 @@ int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
                goto err_unlock;
        }
 
-       if (s->direction == AMDTP_IN_STREAM &&
-           s->flags & CIP_SKIP_INIT_DBC_CHECK)
+       if (s->direction == AMDTP_IN_STREAM)
                s->data_block_counter = UINT_MAX;
        else
                s->data_block_counter = 0;
@@ -755,7 +764,7 @@ int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
                if (s->direction == AMDTP_IN_STREAM)
                        err = queue_in_packet(s);
                else
-                       err = queue_out_packet(s, 0, true);
+                       err = queue_out_packet(s, 0);
                if (err < 0)
                        goto err_context;
        } while (s->packet_index > 0);
@@ -794,11 +803,24 @@ EXPORT_SYMBOL(amdtp_stream_start);
  */
 unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream *s)
 {
-       /* this optimization is allowed to be racy */
-       if (s->pointer_flush && amdtp_stream_running(s))
+       /*
+        * This function is called in software IRQ context of period_tasklet or
+        * process context.
+        *
+        * When the software IRQ context was scheduled by software IRQ context
+        * of IR/IT contexts, queued packets were already handled. Therefore,
+        * no need to flush the queue in buffer anymore.
+        *
+        * When the process context reach here, some packets will be already
+        * queued in the buffer. These packets should be handled immediately
+        * to keep better granularity of PCM pointer.
+        *
+        * Later, the process context will sometimes schedules software IRQ
+        * context of the period_tasklet. Then, no need to flush the queue by
+        * the same reason as described for IR/IT contexts.
+        */
+       if (!in_interrupt() && amdtp_stream_running(s))
                fw_iso_context_flush_completions(s->context);
-       else
-               s->pointer_flush = true;
 
        return ACCESS_ONCE(s->pcm_buffer_pointer);
 }
index 8775704a3665ef9989e242a8bc152c24d6afb825..c1bc7fad056e82c62ee81e8f6a615f0a5d5fa85b 100644 (file)
@@ -17,8 +17,6 @@
  * @CIP_BLOCKING: In blocking mode, each packet contains either zero or
  *     SYT_INTERVAL samples, with these two types alternating so that
  *     the overall sample rate comes out right.
- * @CIP_SYNC_TO_DEVICE: In sync to device mode, time stamp in out packets is
- *     generated by in packets. Defaultly this driver generates timestamp.
  * @CIP_EMPTY_WITH_TAG0: Only for in-stream. Empty in-packets have TAG0.
  * @CIP_DBC_IS_END_EVENT: Only for in-stream. The value of dbc in an in-packet
  *     corresponds to the end of event in the packet. Out of IEC 61883.
@@ -26,8 +24,6 @@
  *     The value of data_block_quadlets is used instead of reported value.
  * @CIP_SKIP_DBC_ZERO_CHECK: Only for in-stream.  Packets with zero in dbc is
  *     skipped for detecting discontinuity.
- * @CIP_SKIP_INIT_DBC_CHECK: Only for in-stream. The value of dbc in first
- *     packet is not continuous from an initial value.
  * @CIP_EMPTY_HAS_WRONG_DBC: Only for in-stream. The value of dbc in empty
  *     packet is wrong but the others are correct.
  * @CIP_JUMBO_PAYLOAD: Only for in-stream. The number of data blocks in an
 enum cip_flags {
        CIP_NONBLOCKING         = 0x00,
        CIP_BLOCKING            = 0x01,
-       CIP_SYNC_TO_DEVICE      = 0x02,
-       CIP_EMPTY_WITH_TAG0     = 0x04,
-       CIP_DBC_IS_END_EVENT    = 0x08,
-       CIP_WRONG_DBS           = 0x10,
-       CIP_SKIP_DBC_ZERO_CHECK = 0x20,
-       CIP_SKIP_INIT_DBC_CHECK = 0x40,
-       CIP_EMPTY_HAS_WRONG_DBC = 0x80,
-       CIP_JUMBO_PAYLOAD       = 0x100,
+       CIP_EMPTY_WITH_TAG0     = 0x02,
+       CIP_DBC_IS_END_EVENT    = 0x04,
+       CIP_WRONG_DBS           = 0x08,
+       CIP_SKIP_DBC_ZERO_CHECK = 0x10,
+       CIP_EMPTY_HAS_WRONG_DBC = 0x20,
+       CIP_JUMBO_PAYLOAD       = 0x40,
 };
 
 /**
@@ -132,12 +126,10 @@ struct amdtp_stream {
        struct tasklet_struct period_tasklet;
        unsigned int pcm_buffer_pointer;
        unsigned int pcm_period_pointer;
-       bool pointer_flush;
 
        /* To wait for first packet. */
        bool callbacked;
        wait_queue_head_t callback_wait;
-       struct amdtp_stream *sync_slave;
 
        /* For backends to process data blocks. */
        void *protocol;
@@ -223,23 +215,6 @@ static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
        return sfc & 1;
 }
 
-static inline void amdtp_stream_set_sync(enum cip_flags sync_mode,
-                                        struct amdtp_stream *master,
-                                        struct amdtp_stream *slave)
-{
-       if (sync_mode == CIP_SYNC_TO_DEVICE) {
-               master->flags |= CIP_SYNC_TO_DEVICE;
-               slave->flags |= CIP_SYNC_TO_DEVICE;
-               master->sync_slave = slave;
-       } else {
-               master->flags &= ~CIP_SYNC_TO_DEVICE;
-               slave->flags &= ~CIP_SYNC_TO_DEVICE;
-               master->sync_slave = NULL;
-       }
-
-       slave->sync_slave = NULL;
-}
-
 /**
  * amdtp_stream_wait_callback - sleep till callbacked or timeout
  * @s: the AMDTP stream
index 3e4e0756e3febfeb90547f5f9085f13f6d948451..f7e2cbd2a3132b0cc52ff2ea3433477ce9a2cc04 100644 (file)
@@ -67,7 +67,7 @@ static DECLARE_BITMAP(devices_used, SNDRV_CARDS);
 #define MODEL_MAUDIO_PROJECTMIX                0x00010091
 
 static int
-name_device(struct snd_bebob *bebob, unsigned int vendor_id)
+name_device(struct snd_bebob *bebob)
 {
        struct fw_device *fw_dev = fw_parent_device(bebob->unit);
        char vendor[24] = {0};
@@ -126,6 +126,17 @@ end:
        return err;
 }
 
+static void bebob_free(struct snd_bebob *bebob)
+{
+       snd_bebob_stream_destroy_duplex(bebob);
+       fw_unit_put(bebob->unit);
+
+       kfree(bebob->maudio_special_quirk);
+
+       mutex_destroy(&bebob->mutex);
+       kfree(bebob);
+}
+
 /*
  * This module releases the FireWire unit data after all ALSA character devices
  * are released by applications. This is for releasing stream data or finishing
@@ -137,18 +148,11 @@ bebob_card_free(struct snd_card *card)
 {
        struct snd_bebob *bebob = card->private_data;
 
-       snd_bebob_stream_destroy_duplex(bebob);
-       fw_unit_put(bebob->unit);
-
-       kfree(bebob->maudio_special_quirk);
-
-       if (bebob->card_index >= 0) {
-               mutex_lock(&devices_mutex);
-               clear_bit(bebob->card_index, devices_used);
-               mutex_unlock(&devices_mutex);
-       }
+       mutex_lock(&devices_mutex);
+       clear_bit(bebob->card_index, devices_used);
+       mutex_unlock(&devices_mutex);
 
-       mutex_destroy(&bebob->mutex);
+       bebob_free(card->private_data);
 }
 
 static const struct snd_bebob_spec *
@@ -176,16 +180,17 @@ check_audiophile_booted(struct fw_unit *unit)
        return strncmp(name, "FW Audiophile Bootloader", 15) != 0;
 }
 
-static int
-bebob_probe(struct fw_unit *unit,
-           const struct ieee1394_device_id *entry)
+static void
+do_registration(struct work_struct *work)
 {
-       struct snd_card *card;
-       struct snd_bebob *bebob;
-       const struct snd_bebob_spec *spec;
+       struct snd_bebob *bebob =
+                       container_of(work, struct snd_bebob, dwork.work);
        unsigned int card_index;
        int err;
 
+       if (bebob->registered)
+               return;
+
        mutex_lock(&devices_mutex);
 
        for (card_index = 0; card_index < SNDRV_CARDS; card_index++) {
@@ -193,64 +198,39 @@ bebob_probe(struct fw_unit *unit,
                        break;
        }
        if (card_index >= SNDRV_CARDS) {
-               err = -ENOENT;
-               goto end;
+               mutex_unlock(&devices_mutex);
+               return;
        }
 
-       if ((entry->vendor_id == VEN_FOCUSRITE) &&
-           (entry->model_id == MODEL_FOCUSRITE_SAFFIRE_BOTH))
-               spec = get_saffire_spec(unit);
-       else if ((entry->vendor_id == VEN_MAUDIO1) &&
-                (entry->model_id == MODEL_MAUDIO_AUDIOPHILE_BOTH) &&
-                !check_audiophile_booted(unit))
-               spec = NULL;
-       else
-               spec = (const struct snd_bebob_spec *)entry->driver_data;
-
-       if (spec == NULL) {
-               if ((entry->vendor_id == VEN_MAUDIO1) ||
-                   (entry->vendor_id == VEN_MAUDIO2))
-                       err = snd_bebob_maudio_load_firmware(unit);
-               else
-                       err = -ENOSYS;
-               goto end;
+       err = snd_card_new(&bebob->unit->device, index[card_index],
+                          id[card_index], THIS_MODULE, 0, &bebob->card);
+       if (err < 0) {
+               mutex_unlock(&devices_mutex);
+               return;
        }
 
-       err = snd_card_new(&unit->device, index[card_index], id[card_index],
-                          THIS_MODULE, sizeof(struct snd_bebob), &card);
+       err = name_device(bebob);
        if (err < 0)
-               goto end;
-       bebob = card->private_data;
-       bebob->card_index = card_index;
-       set_bit(card_index, devices_used);
-       card->private_free = bebob_card_free;
-
-       bebob->card = card;
-       bebob->unit = fw_unit_get(unit);
-       bebob->spec = spec;
-       mutex_init(&bebob->mutex);
-       spin_lock_init(&bebob->lock);
-       init_waitqueue_head(&bebob->hwdep_wait);
+               goto error;
 
-       err = name_device(bebob, entry->vendor_id);
+       if (bebob->spec == &maudio_special_spec) {
+               if (bebob->entry->model_id == MODEL_MAUDIO_FW1814)
+                       err = snd_bebob_maudio_special_discover(bebob, true);
+               else
+                       err = snd_bebob_maudio_special_discover(bebob, false);
+       } else {
+               err = snd_bebob_stream_discover(bebob);
+       }
        if (err < 0)
                goto error;
 
-       if ((entry->vendor_id == VEN_MAUDIO1) &&
-           (entry->model_id == MODEL_MAUDIO_FW1814))
-               err = snd_bebob_maudio_special_discover(bebob, true);
-       else if ((entry->vendor_id == VEN_MAUDIO1) &&
-                (entry->model_id == MODEL_MAUDIO_PROJECTMIX))
-               err = snd_bebob_maudio_special_discover(bebob, false);
-       else
-               err = snd_bebob_stream_discover(bebob);
+       err = snd_bebob_stream_init_duplex(bebob);
        if (err < 0)
                goto error;
 
        snd_bebob_proc_init(bebob);
 
-       if ((bebob->midi_input_ports > 0) ||
-           (bebob->midi_output_ports > 0)) {
+       if (bebob->midi_input_ports > 0 || bebob->midi_output_ports > 0) {
                err = snd_bebob_create_midi_devices(bebob);
                if (err < 0)
                        goto error;
@@ -264,16 +244,75 @@ bebob_probe(struct fw_unit *unit,
        if (err < 0)
                goto error;
 
-       err = snd_bebob_stream_init_duplex(bebob);
+       err = snd_card_register(bebob->card);
        if (err < 0)
                goto error;
 
-       if (!bebob->maudio_special_quirk) {
-               err = snd_card_register(card);
-               if (err < 0) {
-                       snd_bebob_stream_destroy_duplex(bebob);
-                       goto error;
-               }
+       set_bit(card_index, devices_used);
+       mutex_unlock(&devices_mutex);
+
+       /*
+        * After registered, bebob instance can be released corresponding to
+        * releasing the sound card instance.
+        */
+       bebob->card->private_free = bebob_card_free;
+       bebob->card->private_data = bebob;
+       bebob->registered = true;
+
+       return;
+error:
+       mutex_unlock(&devices_mutex);
+       snd_bebob_stream_destroy_duplex(bebob);
+       snd_card_free(bebob->card);
+       dev_info(&bebob->unit->device,
+                "Sound card registration failed: %d\n", err);
+}
+
+static int
+bebob_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry)
+{
+       struct snd_bebob *bebob;
+       const struct snd_bebob_spec *spec;
+
+       if (entry->vendor_id == VEN_FOCUSRITE &&
+           entry->model_id == MODEL_FOCUSRITE_SAFFIRE_BOTH)
+               spec = get_saffire_spec(unit);
+       else if (entry->vendor_id == VEN_MAUDIO1 &&
+                entry->model_id == MODEL_MAUDIO_AUDIOPHILE_BOTH &&
+                !check_audiophile_booted(unit))
+               spec = NULL;
+       else
+               spec = (const struct snd_bebob_spec *)entry->driver_data;
+
+       if (spec == NULL) {
+               if (entry->vendor_id == VEN_MAUDIO1 ||
+                   entry->vendor_id == VEN_MAUDIO2)
+                       return snd_bebob_maudio_load_firmware(unit);
+               else
+                       return -ENODEV;
+       }
+
+       /* Allocate this independent of sound card instance. */
+       bebob = kzalloc(sizeof(struct snd_bebob), GFP_KERNEL);
+       if (bebob == NULL)
+               return -ENOMEM;
+
+       bebob->unit = fw_unit_get(unit);
+       bebob->entry = entry;
+       bebob->spec = spec;
+       dev_set_drvdata(&unit->device, bebob);
+
+       mutex_init(&bebob->mutex);
+       spin_lock_init(&bebob->lock);
+       init_waitqueue_head(&bebob->hwdep_wait);
+
+       /* Allocate and register this sound card later. */
+       INIT_DEFERRABLE_WORK(&bebob->dwork, do_registration);
+
+       if (entry->vendor_id != VEN_MAUDIO1 ||
+           (entry->model_id != MODEL_MAUDIO_FW1814 &&
+            entry->model_id != MODEL_MAUDIO_PROJECTMIX)) {
+               snd_fw_schedule_registration(unit, &bebob->dwork);
        } else {
                /*
                 * This is a workaround. This bus reset seems to have an effect
@@ -285,19 +324,11 @@ bebob_probe(struct fw_unit *unit,
                 * signals from dbus and starts I/Os. To avoid I/Os till the
                 * future bus reset, registration is done in next update().
                 */
-               bebob->deferred_registration = true;
                fw_schedule_bus_reset(fw_parent_device(bebob->unit)->card,
                                      false, true);
        }
 
-       dev_set_drvdata(&unit->device, bebob);
-end:
-       mutex_unlock(&devices_mutex);
-       return err;
-error:
-       mutex_unlock(&devices_mutex);
-       snd_card_free(card);
-       return err;
+       return 0;
 }
 
 /*
@@ -324,15 +355,11 @@ bebob_update(struct fw_unit *unit)
        if (bebob == NULL)
                return;
 
-       fcp_bus_reset(bebob->unit);
-
-       if (bebob->deferred_registration) {
-               if (snd_card_register(bebob->card) < 0) {
-                       snd_bebob_stream_destroy_duplex(bebob);
-                       snd_card_free(bebob->card);
-               }
-               bebob->deferred_registration = false;
-       }
+       /* Postpone a workqueue for deferred registration. */
+       if (!bebob->registered)
+               snd_fw_schedule_registration(unit, &bebob->dwork);
+       else
+               fcp_bus_reset(bebob->unit);
 }
 
 static void bebob_remove(struct fw_unit *unit)
@@ -342,8 +369,20 @@ static void bebob_remove(struct fw_unit *unit)
        if (bebob == NULL)
                return;
 
-       /* No need to wait for releasing card object in this context. */
-       snd_card_free_when_closed(bebob->card);
+       /*
+        * Confirm to stop the work for registration before the sound card is
+        * going to be released. The work is not scheduled again because bus
+        * reset handler is not called anymore.
+        */
+       cancel_delayed_work_sync(&bebob->dwork);
+
+       if (bebob->registered) {
+               /* No need to wait for releasing card object in this context. */
+               snd_card_free_when_closed(bebob->card);
+       } else {
+               /* Don't forget this case. */
+               bebob_free(bebob);
+       }
 }
 
 static const struct snd_bebob_rate_spec normal_rate_spec = {
index b50bb33d9d46616b1186143b03495b309967f770..e7f1bb925b12f9e19d76a1c4e563a522473a8436 100644 (file)
@@ -83,6 +83,10 @@ struct snd_bebob {
        struct mutex mutex;
        spinlock_t lock;
 
+       bool registered;
+       struct delayed_work dwork;
+
+       const struct ieee1394_device_id *entry;
        const struct snd_bebob_spec *spec;
 
        unsigned int midi_input_ports;
@@ -90,7 +94,6 @@ struct snd_bebob {
 
        bool connected;
 
-       struct amdtp_stream *master;
        struct amdtp_stream tx_stream;
        struct amdtp_stream rx_stream;
        struct cmp_connection out_conn;
@@ -111,7 +114,6 @@ struct snd_bebob {
 
        /* for M-Audio special devices */
        void *maudio_special_quirk;
-       bool deferred_registration;
 
        /* For BeBoB version quirk. */
        unsigned int version;
index 77cbb02bff342271555398bbd582ab5a4a578bed..4d3034a68bdfbd587163566484eea57804260eb7 100644 (file)
@@ -483,30 +483,6 @@ destroy_both_connections(struct snd_bebob *bebob)
        cmp_connection_destroy(&bebob->out_conn);
 }
 
-static int
-get_sync_mode(struct snd_bebob *bebob, enum cip_flags *sync_mode)
-{
-       enum snd_bebob_clock_type src;
-       int err;
-
-       err = snd_bebob_stream_get_clock_src(bebob, &src);
-       if (err < 0)
-               return err;
-
-       switch (src) {
-       case SND_BEBOB_CLOCK_TYPE_INTERNAL:
-       case SND_BEBOB_CLOCK_TYPE_EXTERNAL:
-               *sync_mode = CIP_SYNC_TO_DEVICE;
-               break;
-       default:
-       case SND_BEBOB_CLOCK_TYPE_SYT:
-               *sync_mode = 0;
-               break;
-       }
-
-       return 0;
-}
-
 static int
 start_stream(struct snd_bebob *bebob, struct amdtp_stream *stream,
             unsigned int rate)
@@ -550,8 +526,6 @@ int snd_bebob_stream_init_duplex(struct snd_bebob *bebob)
                goto end;
        }
 
-       bebob->tx_stream.flags |= CIP_SKIP_INIT_DBC_CHECK;
-
        /*
         * BeBoB v3 transfers packets with these qurks:
         *  - In the beginning of streaming, the value of dbc is incremented
@@ -584,8 +558,6 @@ end:
 int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
 {
        const struct snd_bebob_rate_spec *rate_spec = bebob->spec->rate;
-       struct amdtp_stream *master, *slave;
-       enum cip_flags sync_mode;
        unsigned int curr_rate;
        int err = 0;
 
@@ -593,22 +565,11 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
        if (bebob->substreams_counter == 0)
                goto end;
 
-       err = get_sync_mode(bebob, &sync_mode);
-       if (err < 0)
-               goto end;
-       if (sync_mode == CIP_SYNC_TO_DEVICE) {
-               master = &bebob->tx_stream;
-               slave  = &bebob->rx_stream;
-       } else {
-               master = &bebob->rx_stream;
-               slave  = &bebob->tx_stream;
-       }
-
        /*
         * Considering JACK/FFADO streaming:
         * TODO: This can be removed hwdep functionality becomes popular.
         */
-       err = check_connection_used_by_others(bebob, master);
+       err = check_connection_used_by_others(bebob, &bebob->rx_stream);
        if (err < 0)
                goto end;
 
@@ -618,11 +579,12 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
         * At bus reset, connections should not be broken here. So streams need
         * to be re-started. This is a reason to use SKIP_INIT_DBC_CHECK flag.
         */
-       if (amdtp_streaming_error(master))
-               amdtp_stream_stop(master);
-       if (amdtp_streaming_error(slave))
-               amdtp_stream_stop(slave);
-       if (!amdtp_stream_running(master) && !amdtp_stream_running(slave))
+       if (amdtp_streaming_error(&bebob->rx_stream))
+               amdtp_stream_stop(&bebob->rx_stream);
+       if (amdtp_streaming_error(&bebob->tx_stream))
+               amdtp_stream_stop(&bebob->tx_stream);
+       if (!amdtp_stream_running(&bebob->rx_stream) &&
+           !amdtp_stream_running(&bebob->tx_stream))
                break_both_connections(bebob);
 
        /* stop streams if rate is different */
@@ -635,16 +597,13 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
        if (rate == 0)
                rate = curr_rate;
        if (rate != curr_rate) {
-               amdtp_stream_stop(master);
-               amdtp_stream_stop(slave);
+               amdtp_stream_stop(&bebob->rx_stream);
+               amdtp_stream_stop(&bebob->tx_stream);
                break_both_connections(bebob);
        }
 
        /* master should be always running */
-       if (!amdtp_stream_running(master)) {
-               amdtp_stream_set_sync(sync_mode, master, slave);
-               bebob->master = master;
-
+       if (!amdtp_stream_running(&bebob->rx_stream)) {
                /*
                 * NOTE:
                 * If establishing connections at first, Yamaha GO46
@@ -666,7 +625,7 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
                if (err < 0)
                        goto end;
 
-               err = start_stream(bebob, master, rate);
+               err = start_stream(bebob, &bebob->rx_stream, rate);
                if (err < 0) {
                        dev_err(&bebob->unit->device,
                                "fail to run AMDTP master stream:%d\n", err);
@@ -685,15 +644,16 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
                                dev_err(&bebob->unit->device,
                                        "fail to ensure sampling rate: %d\n",
                                        err);
-                               amdtp_stream_stop(master);
+                               amdtp_stream_stop(&bebob->rx_stream);
                                break_both_connections(bebob);
                                goto end;
                        }
                }
 
                /* wait first callback */
-               if (!amdtp_stream_wait_callback(master, CALLBACK_TIMEOUT)) {
-                       amdtp_stream_stop(master);
+               if (!amdtp_stream_wait_callback(&bebob->rx_stream,
+                                               CALLBACK_TIMEOUT)) {
+                       amdtp_stream_stop(&bebob->rx_stream);
                        break_both_connections(bebob);
                        err = -ETIMEDOUT;
                        goto end;
@@ -701,20 +661,21 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob, unsigned int rate)
        }
 
        /* start slave if needed */
-       if (!amdtp_stream_running(slave)) {
-               err = start_stream(bebob, slave, rate);
+       if (!amdtp_stream_running(&bebob->tx_stream)) {
+               err = start_stream(bebob, &bebob->tx_stream, rate);
                if (err < 0) {
                        dev_err(&bebob->unit->device,
                                "fail to run AMDTP slave stream:%d\n", err);
-                       amdtp_stream_stop(master);
+                       amdtp_stream_stop(&bebob->rx_stream);
                        break_both_connections(bebob);
                        goto end;
                }
 
                /* wait first callback */
-               if (!amdtp_stream_wait_callback(slave, CALLBACK_TIMEOUT)) {
-                       amdtp_stream_stop(slave);
-                       amdtp_stream_stop(master);
+               if (!amdtp_stream_wait_callback(&bebob->tx_stream,
+                                               CALLBACK_TIMEOUT)) {
+                       amdtp_stream_stop(&bebob->tx_stream);
+                       amdtp_stream_stop(&bebob->rx_stream);
                        break_both_connections(bebob);
                        err = -ETIMEDOUT;
                }
@@ -725,22 +686,12 @@ end:
 
 void snd_bebob_stream_stop_duplex(struct snd_bebob *bebob)
 {
-       struct amdtp_stream *master, *slave;
-
-       if (bebob->master == &bebob->rx_stream) {
-               slave  = &bebob->tx_stream;
-               master = &bebob->rx_stream;
-       } else {
-               slave  = &bebob->rx_stream;
-               master = &bebob->tx_stream;
-       }
-
        if (bebob->substreams_counter == 0) {
-               amdtp_stream_pcm_abort(master);
-               amdtp_stream_stop(master);
+               amdtp_stream_pcm_abort(&bebob->rx_stream);
+               amdtp_stream_stop(&bebob->rx_stream);
 
-               amdtp_stream_pcm_abort(slave);
-               amdtp_stream_stop(slave);
+               amdtp_stream_pcm_abort(&bebob->tx_stream);
+               amdtp_stream_stop(&bebob->tx_stream);
 
                break_both_connections(bebob);
        }
index 8b64aef31a864523d428e6fa26b8c6a5f45db154..25e9f77275c4dd6ef6a39da8e9f77294f86f876c 100644 (file)
@@ -20,8 +20,6 @@ MODULE_LICENSE("GPL v2");
 #define WEISS_CATEGORY_ID      0x00
 #define LOUD_CATEGORY_ID       0x10
 
-#define PROBE_DELAY_MS         (2 * MSEC_PER_SEC)
-
 /*
  * Some models support several isochronous channels, while these streams are not
  * always available. In this case, add the model name to this list.
@@ -201,6 +199,10 @@ static void do_registration(struct work_struct *work)
 
        dice_card_strings(dice);
 
+       err = snd_dice_stream_init_duplex(dice);
+       if (err < 0)
+               goto error;
+
        snd_dice_create_proc(dice);
 
        err = snd_dice_create_pcm(dice);
@@ -229,28 +231,14 @@ static void do_registration(struct work_struct *work)
 
        return;
 error:
+       snd_dice_stream_destroy_duplex(dice);
        snd_dice_transaction_destroy(dice);
+       snd_dice_stream_destroy_duplex(dice);
        snd_card_free(dice->card);
        dev_info(&dice->unit->device,
                 "Sound card registration failed: %d\n", err);
 }
 
-static void schedule_registration(struct snd_dice *dice)
-{
-       struct fw_card *fw_card = fw_parent_device(dice->unit)->card;
-       u64 now, delay;
-
-       now = get_jiffies_64();
-       delay = fw_card->reset_jiffies + msecs_to_jiffies(PROBE_DELAY_MS);
-
-       if (time_after64(delay, now))
-               delay -= now;
-       else
-               delay = 0;
-
-       mod_delayed_work(system_wq, &dice->dwork, delay);
-}
-
 static int dice_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)
 {
        struct snd_dice *dice;
@@ -273,15 +261,9 @@ static int dice_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)
        init_completion(&dice->clock_accepted);
        init_waitqueue_head(&dice->hwdep_wait);
 
-       err = snd_dice_stream_init_duplex(dice);
-       if (err < 0) {
-               dice_free(dice);
-               return err;
-       }
-
        /* Allocate and register this sound card later. */
        INIT_DEFERRABLE_WORK(&dice->dwork, do_registration);
-       schedule_registration(dice);
+       snd_fw_schedule_registration(unit, &dice->dwork);
 
        return 0;
 }
@@ -312,7 +294,7 @@ static void dice_bus_reset(struct fw_unit *unit)
 
        /* Postpone a workqueue for deferred registration. */
        if (!dice->registered)
-               schedule_registration(dice);
+               snd_fw_schedule_registration(unit, &dice->dwork);
 
        /* The handler address register becomes initialized. */
        snd_dice_transaction_reinit(dice);
@@ -335,6 +317,13 @@ static const struct ieee1394_device_id dice_id_table[] = {
                .match_flags = IEEE1394_MATCH_VERSION,
                .version     = DICE_INTERFACE,
        },
+       /* M-Audio Profire 610/2626 has a different value in version field. */
+       {
+               .match_flags    = IEEE1394_MATCH_VENDOR_ID |
+                                 IEEE1394_MATCH_SPECIFIER_ID,
+               .vendor_id      = 0x000d6c,
+               .specifier_id   = 0x000d6c,
+       },
        { }
 };
 MODULE_DEVICE_TABLE(ieee1394, dice_id_table);
index 0ac92aba5bc1c9a4c01b1764a6f16a098e3bbae1..b3cffd01a19f711f3572920a33fa75098f39ffde 100644 (file)
@@ -421,7 +421,7 @@ int amdtp_dot_init(struct amdtp_stream *s, struct fw_unit *unit,
 
        /* Use different mode between incoming/outgoing. */
        if (dir == AMDTP_IN_STREAM) {
-               flags = CIP_NONBLOCKING | CIP_SKIP_INIT_DBC_CHECK;
+               flags = CIP_NONBLOCKING;
                process_data_blocks = process_tx_data_blocks;
        } else {
                flags = CIP_BLOCKING;
index 554324d8c602189e58efc9aebeac1707c3f5cf97..735d35640807c581ea43a6f4152348a549c0427d 100644 (file)
@@ -126,12 +126,17 @@ int snd_dg00x_transaction_register(struct snd_dg00x *dg00x)
        return err;
 error:
        fw_core_remove_address_handler(&dg00x->async_handler);
-       dg00x->async_handler.address_callback = NULL;
+       dg00x->async_handler.callback_data = NULL;
        return err;
 }
 
 void snd_dg00x_transaction_unregister(struct snd_dg00x *dg00x)
 {
+       if (dg00x->async_handler.callback_data == NULL)
+               return;
+
        snd_fw_async_midi_port_destroy(&dg00x->out_control);
        fw_core_remove_address_handler(&dg00x->async_handler);
+
+       dg00x->async_handler.callback_data = NULL;
 }
index 1f33b7a1fca4c3695cc663789d7eeeff135c2a83..cc4776c6ded313673ef1c767101f2ed7e0c4369f 100644 (file)
@@ -40,10 +40,8 @@ static int name_card(struct snd_dg00x *dg00x)
        return 0;
 }
 
-static void dg00x_card_free(struct snd_card *card)
+static void dg00x_free(struct snd_dg00x *dg00x)
 {
-       struct snd_dg00x *dg00x = card->private_data;
-
        snd_dg00x_stream_destroy_duplex(dg00x);
        snd_dg00x_transaction_unregister(dg00x);
 
@@ -52,28 +50,24 @@ static void dg00x_card_free(struct snd_card *card)
        mutex_destroy(&dg00x->mutex);
 }
 
-static int snd_dg00x_probe(struct fw_unit *unit,
-                          const struct ieee1394_device_id *entry)
+static void dg00x_card_free(struct snd_card *card)
 {
-       struct snd_card *card;
-       struct snd_dg00x *dg00x;
-       int err;
+       dg00x_free(card->private_data);
+}
 
-       /* create card */
-       err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
-                          sizeof(struct snd_dg00x), &card);
-       if (err < 0)
-               return err;
-       card->private_free = dg00x_card_free;
+static void do_registration(struct work_struct *work)
+{
+       struct snd_dg00x *dg00x =
+                       container_of(work, struct snd_dg00x, dwork.work);
+       int err;
 
-       /* initialize myself */
-       dg00x = card->private_data;
-       dg00x->card = card;
-       dg00x->unit = fw_unit_get(unit);
+       if (dg00x->registered)
+               return;
 
-       mutex_init(&dg00x->mutex);
-       spin_lock_init(&dg00x->lock);
-       init_waitqueue_head(&dg00x->hwdep_wait);
+       err = snd_card_new(&dg00x->unit->device, -1, NULL, THIS_MODULE, 0,
+                          &dg00x->card);
+       if (err < 0)
+               return;
 
        err = name_card(dg00x);
        if (err < 0)
@@ -101,35 +95,86 @@ static int snd_dg00x_probe(struct fw_unit *unit,
        if (err < 0)
                goto error;
 
-       err = snd_card_register(card);
+       err = snd_card_register(dg00x->card);
        if (err < 0)
                goto error;
 
-       dev_set_drvdata(&unit->device, dg00x);
+       dg00x->card->private_free = dg00x_card_free;
+       dg00x->card->private_data = dg00x;
+       dg00x->registered = true;
 
-       return err;
+       return;
 error:
-       snd_card_free(card);
-       return err;
+       snd_dg00x_transaction_unregister(dg00x);
+       snd_dg00x_stream_destroy_duplex(dg00x);
+       snd_card_free(dg00x->card);
+       dev_info(&dg00x->unit->device,
+                "Sound card registration failed: %d\n", err);
+}
+
+static int snd_dg00x_probe(struct fw_unit *unit,
+                          const struct ieee1394_device_id *entry)
+{
+       struct snd_dg00x *dg00x;
+
+       /* Allocate this independent of sound card instance. */
+       dg00x = kzalloc(sizeof(struct snd_dg00x), GFP_KERNEL);
+       if (dg00x == NULL)
+               return -ENOMEM;
+
+       dg00x->unit = fw_unit_get(unit);
+       dev_set_drvdata(&unit->device, dg00x);
+
+       mutex_init(&dg00x->mutex);
+       spin_lock_init(&dg00x->lock);
+       init_waitqueue_head(&dg00x->hwdep_wait);
+
+       /* Allocate and register this sound card later. */
+       INIT_DEFERRABLE_WORK(&dg00x->dwork, do_registration);
+       snd_fw_schedule_registration(unit, &dg00x->dwork);
+
+       return 0;
 }
 
 static void snd_dg00x_update(struct fw_unit *unit)
 {
        struct snd_dg00x *dg00x = dev_get_drvdata(&unit->device);
 
+       /* Postpone a workqueue for deferred registration. */
+       if (!dg00x->registered)
+               snd_fw_schedule_registration(unit, &dg00x->dwork);
+
        snd_dg00x_transaction_reregister(dg00x);
 
-       mutex_lock(&dg00x->mutex);
-       snd_dg00x_stream_update_duplex(dg00x);
-       mutex_unlock(&dg00x->mutex);
+       /*
+        * After registration, userspace can start packet streaming, then this
+        * code block works fine.
+        */
+       if (dg00x->registered) {
+               mutex_lock(&dg00x->mutex);
+               snd_dg00x_stream_update_duplex(dg00x);
+               mutex_unlock(&dg00x->mutex);
+       }
 }
 
 static void snd_dg00x_remove(struct fw_unit *unit)
 {
        struct snd_dg00x *dg00x = dev_get_drvdata(&unit->device);
 
-       /* No need to wait for releasing card object in this context. */
-       snd_card_free_when_closed(dg00x->card);
+       /*
+        * Confirm to stop the work for registration before the sound card is
+        * going to be released. The work is not scheduled again because bus
+        * reset handler is not called anymore.
+        */
+       cancel_delayed_work_sync(&dg00x->dwork);
+
+       if (dg00x->registered) {
+               /* No need to wait for releasing card object in this context. */
+               snd_card_free_when_closed(dg00x->card);
+       } else {
+               /* Don't forget this case. */
+               dg00x_free(dg00x);
+       }
 }
 
 static const struct ieee1394_device_id snd_dg00x_id_table[] = {
index 907e739936777c359bf6c93973d7faba09ac68df..2cd465c0caae84e1f1e21849f58c12194e2b9f5f 100644 (file)
@@ -37,6 +37,9 @@ struct snd_dg00x {
        struct mutex mutex;
        spinlock_t lock;
 
+       bool registered;
+       struct delayed_work dwork;
+
        struct amdtp_stream tx_stream;
        struct fw_iso_resources tx_resources;
 
index 8f27b67503c880bcf5d1c1e4a9e84ba2ad4bd006..71a0613d3da040c49ef633f4877f98d8db219a99 100644 (file)
@@ -168,11 +168,34 @@ get_hardware_info(struct snd_efw *efw)
               sizeof(struct snd_efw_phys_grp) * hwinfo->phys_in_grp_count);
        memcpy(&efw->phys_out_grps, hwinfo->phys_out_grps,
               sizeof(struct snd_efw_phys_grp) * hwinfo->phys_out_grp_count);
+
+       /* AudioFire8 (since 2009) and AudioFirePre8 */
+       if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_9)
+               efw->is_af9 = true;
+       /* These models uses the same firmware. */
+       if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_2 ||
+           hwinfo->type == MODEL_ECHO_AUDIOFIRE_4 ||
+           hwinfo->type == MODEL_ECHO_AUDIOFIRE_9 ||
+           hwinfo->type == MODEL_GIBSON_RIP ||
+           hwinfo->type == MODEL_GIBSON_GOLDTOP)
+               efw->is_fireworks3 = true;
 end:
        kfree(hwinfo);
        return err;
 }
 
+static void efw_free(struct snd_efw *efw)
+{
+       snd_efw_stream_destroy_duplex(efw);
+       snd_efw_transaction_remove_instance(efw);
+       fw_unit_put(efw->unit);
+
+       kfree(efw->resp_buf);
+
+       mutex_destroy(&efw->mutex);
+       kfree(efw);
+}
+
 /*
  * This module releases the FireWire unit data after all ALSA character devices
  * are released by applications. This is for releasing stream data or finishing
@@ -184,28 +207,24 @@ efw_card_free(struct snd_card *card)
 {
        struct snd_efw *efw = card->private_data;
 
-       snd_efw_stream_destroy_duplex(efw);
-       snd_efw_transaction_remove_instance(efw);
-       fw_unit_put(efw->unit);
-
-       kfree(efw->resp_buf);
-
        if (efw->card_index >= 0) {
                mutex_lock(&devices_mutex);
                clear_bit(efw->card_index, devices_used);
                mutex_unlock(&devices_mutex);
        }
 
-       mutex_destroy(&efw->mutex);
+       efw_free(card->private_data);
 }
 
-static int
-efw_probe(struct fw_unit *unit,
-         const struct ieee1394_device_id *entry)
+static void
+do_registration(struct work_struct *work)
 {
-       struct snd_card *card;
-       struct snd_efw *efw;
-       int card_index, err;
+       struct snd_efw *efw = container_of(work, struct snd_efw, dwork.work);
+       unsigned int card_index;
+       int err;
+
+       if (efw->registered)
+               return;
 
        mutex_lock(&devices_mutex);
 
@@ -215,24 +234,16 @@ efw_probe(struct fw_unit *unit,
                        break;
        }
        if (card_index >= SNDRV_CARDS) {
-               err = -ENOENT;
-               goto end;
+               mutex_unlock(&devices_mutex);
+               return;
        }
 
-       err = snd_card_new(&unit->device, index[card_index], id[card_index],
-                          THIS_MODULE, sizeof(struct snd_efw), &card);
-       if (err < 0)
-               goto end;
-       efw = card->private_data;
-       efw->card_index = card_index;
-       set_bit(card_index, devices_used);
-       card->private_free = efw_card_free;
-
-       efw->card = card;
-       efw->unit = fw_unit_get(unit);
-       mutex_init(&efw->mutex);
-       spin_lock_init(&efw->lock);
-       init_waitqueue_head(&efw->hwdep_wait);
+       err = snd_card_new(&efw->unit->device, index[card_index],
+                          id[card_index], THIS_MODULE, 0, &efw->card);
+       if (err < 0) {
+               mutex_unlock(&devices_mutex);
+               return;
+       }
 
        /* prepare response buffer */
        snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size,
@@ -248,16 +259,10 @@ efw_probe(struct fw_unit *unit,
        err = get_hardware_info(efw);
        if (err < 0)
                goto error;
-       /* AudioFire8 (since 2009) and AudioFirePre8 */
-       if (entry->model_id == MODEL_ECHO_AUDIOFIRE_9)
-               efw->is_af9 = true;
-       /* These models uses the same firmware. */
-       if (entry->model_id == MODEL_ECHO_AUDIOFIRE_2 ||
-           entry->model_id == MODEL_ECHO_AUDIOFIRE_4 ||
-           entry->model_id == MODEL_ECHO_AUDIOFIRE_9 ||
-           entry->model_id == MODEL_GIBSON_RIP ||
-           entry->model_id == MODEL_GIBSON_GOLDTOP)
-               efw->is_fireworks3 = true;
+
+       err = snd_efw_stream_init_duplex(efw);
+       if (err < 0)
+               goto error;
 
        snd_efw_proc_init(efw);
 
@@ -275,44 +280,93 @@ efw_probe(struct fw_unit *unit,
        if (err < 0)
                goto error;
 
-       err = snd_efw_stream_init_duplex(efw);
+       err = snd_card_register(efw->card);
        if (err < 0)
                goto error;
 
-       err = snd_card_register(card);
-       if (err < 0) {
-               snd_efw_stream_destroy_duplex(efw);
-               goto error;
-       }
-
-       dev_set_drvdata(&unit->device, efw);
-end:
+       set_bit(card_index, devices_used);
        mutex_unlock(&devices_mutex);
-       return err;
+
+       /*
+        * After registered, efw instance can be released corresponding to
+        * releasing the sound card instance.
+        */
+       efw->card->private_free = efw_card_free;
+       efw->card->private_data = efw;
+       efw->registered = true;
+
+       return;
 error:
-       snd_efw_transaction_remove_instance(efw);
        mutex_unlock(&devices_mutex);
-       snd_card_free(card);
-       return err;
+       snd_efw_transaction_remove_instance(efw);
+       snd_efw_stream_destroy_duplex(efw);
+       snd_card_free(efw->card);
+       dev_info(&efw->unit->device,
+                "Sound card registration failed: %d\n", err);
+}
+
+static int
+efw_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry)
+{
+       struct snd_efw *efw;
+
+       efw = kzalloc(sizeof(struct snd_efw), GFP_KERNEL);
+       if (efw == NULL)
+               return -ENOMEM;
+
+       efw->unit = fw_unit_get(unit);
+       dev_set_drvdata(&unit->device, efw);
+
+       mutex_init(&efw->mutex);
+       spin_lock_init(&efw->lock);
+       init_waitqueue_head(&efw->hwdep_wait);
+
+       /* Allocate and register this sound card later. */
+       INIT_DEFERRABLE_WORK(&efw->dwork, do_registration);
+       snd_fw_schedule_registration(unit, &efw->dwork);
+
+       return 0;
 }
 
 static void efw_update(struct fw_unit *unit)
 {
        struct snd_efw *efw = dev_get_drvdata(&unit->device);
 
+       /* Postpone a workqueue for deferred registration. */
+       if (!efw->registered)
+               snd_fw_schedule_registration(unit, &efw->dwork);
+
        snd_efw_transaction_bus_reset(efw->unit);
 
-       mutex_lock(&efw->mutex);
-       snd_efw_stream_update_duplex(efw);
-       mutex_unlock(&efw->mutex);
+       /*
+        * After registration, userspace can start packet streaming, then this
+        * code block works fine.
+        */
+       if (efw->registered) {
+               mutex_lock(&efw->mutex);
+               snd_efw_stream_update_duplex(efw);
+               mutex_unlock(&efw->mutex);
+       }
 }
 
 static void efw_remove(struct fw_unit *unit)
 {
        struct snd_efw *efw = dev_get_drvdata(&unit->device);
 
-       /* No need to wait for releasing card object in this context. */
-       snd_card_free_when_closed(efw->card);
+       /*
+        * Confirm to stop the work for registration before the sound card is
+        * going to be released. The work is not scheduled again because bus
+        * reset handler is not called anymore.
+        */
+       cancel_delayed_work_sync(&efw->dwork);
+
+       if (efw->registered) {
+               /* No need to wait for releasing card object in this context. */
+               snd_card_free_when_closed(efw->card);
+       } else {
+               /* Don't forget this case. */
+               efw_free(efw);
+       }
 }
 
 static const struct ieee1394_device_id efw_id_table[] = {
index 96c4e0c6a9bd81d5f1136bc2673471ca5c23fd93..03ed35237e2bb89af027b18fddbc334f5e4620b7 100644 (file)
@@ -65,6 +65,9 @@ struct snd_efw {
        struct mutex mutex;
        spinlock_t lock;
 
+       bool registered;
+       struct delayed_work dwork;
+
        /* for transaction */
        u32 seqnum;
        bool resp_addr_changable;
@@ -81,7 +84,6 @@ struct snd_efw {
        unsigned int pcm_capture_channels[SND_EFW_MULTIPLIER_MODES];
        unsigned int pcm_playback_channels[SND_EFW_MULTIPLIER_MODES];
 
-       struct amdtp_stream *master;
        struct amdtp_stream tx_stream;
        struct amdtp_stream rx_stream;
        struct cmp_connection out_conn;
index 425db8d88235ad755b054f3701fc9b0c14072709..ee47924aef0df676223975a08df37ad055cc1f51 100644 (file)
@@ -120,23 +120,6 @@ destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream)
        cmp_connection_destroy(&efw->out_conn);
 }
 
-static int
-get_sync_mode(struct snd_efw *efw, enum cip_flags *sync_mode)
-{
-       enum snd_efw_clock_source clock_source;
-       int err;
-
-       err = snd_efw_command_get_clock_source(efw, &clock_source);
-       if (err < 0)
-               return err;
-
-       if (clock_source == SND_EFW_CLOCK_SOURCE_SYTMATCH)
-               return -ENOSYS;
-
-       *sync_mode = CIP_SYNC_TO_DEVICE;
-       return 0;
-}
-
 static int
 check_connection_used_by_others(struct snd_efw *efw, struct amdtp_stream *s)
 {
@@ -208,9 +191,6 @@ end:
 
 int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate)
 {
-       struct amdtp_stream *master, *slave;
-       unsigned int slave_substreams;
-       enum cip_flags sync_mode;
        unsigned int curr_rate;
        int err = 0;
 
@@ -218,32 +198,19 @@ int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate)
        if (efw->playback_substreams == 0 && efw->capture_substreams  == 0)
                goto end;
 
-       err = get_sync_mode(efw, &sync_mode);
-       if (err < 0)
-               goto end;
-       if (sync_mode == CIP_SYNC_TO_DEVICE) {
-               master = &efw->tx_stream;
-               slave  = &efw->rx_stream;
-               slave_substreams  = efw->playback_substreams;
-       } else {
-               master = &efw->rx_stream;
-               slave  = &efw->tx_stream;
-               slave_substreams = efw->capture_substreams;
-       }
-
        /*
         * Considering JACK/FFADO streaming:
         * TODO: This can be removed hwdep functionality becomes popular.
         */
-       err = check_connection_used_by_others(efw, master);
+       err = check_connection_used_by_others(efw, &efw->rx_stream);
        if (err < 0)
                goto end;
 
        /* packet queueing error */
-       if (amdtp_streaming_error(slave))
-               stop_stream(efw, slave);
-       if (amdtp_streaming_error(master))
-               stop_stream(efw, master);
+       if (amdtp_streaming_error(&efw->tx_stream))
+               stop_stream(efw, &efw->tx_stream);
+       if (amdtp_streaming_error(&efw->rx_stream))
+               stop_stream(efw, &efw->rx_stream);
 
        /* stop streams if rate is different */
        err = snd_efw_command_get_sampling_rate(efw, &curr_rate);
@@ -252,20 +219,17 @@ int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate)
        if (rate == 0)
                rate = curr_rate;
        if (rate != curr_rate) {
-               stop_stream(efw, slave);
-               stop_stream(efw, master);
+               stop_stream(efw, &efw->tx_stream);
+               stop_stream(efw, &efw->rx_stream);
        }
 
        /* master should be always running */
-       if (!amdtp_stream_running(master)) {
-               amdtp_stream_set_sync(sync_mode, master, slave);
-               efw->master = master;
-
+       if (!amdtp_stream_running(&efw->rx_stream)) {
                err = snd_efw_command_set_sampling_rate(efw, rate);
                if (err < 0)
                        goto end;
 
-               err = start_stream(efw, master, rate);
+               err = start_stream(efw, &efw->rx_stream, rate);
                if (err < 0) {
                        dev_err(&efw->unit->device,
                                "fail to start AMDTP master stream:%d\n", err);
@@ -274,12 +238,13 @@ int snd_efw_stream_start_duplex(struct snd_efw *efw, unsigned int rate)
        }
 
        /* start slave if needed */
-       if (slave_substreams > 0 && !amdtp_stream_running(slave)) {
-               err = start_stream(efw, slave, rate);
+       if (efw->capture_substreams > 0 &&
+           !amdtp_stream_running(&efw->tx_stream)) {
+               err = start_stream(efw, &efw->tx_stream, rate);
                if (err < 0) {
                        dev_err(&efw->unit->device,
                                "fail to start AMDTP slave stream:%d\n", err);
-                       stop_stream(efw, master);
+                       stop_stream(efw, &efw->rx_stream);
                }
        }
 end:
@@ -288,26 +253,11 @@ end:
 
 void snd_efw_stream_stop_duplex(struct snd_efw *efw)
 {
-       struct amdtp_stream *master, *slave;
-       unsigned int master_substreams, slave_substreams;
-
-       if (efw->master == &efw->rx_stream) {
-               slave  = &efw->tx_stream;
-               master = &efw->rx_stream;
-               slave_substreams  = efw->capture_substreams;
-               master_substreams = efw->playback_substreams;
-       } else {
-               slave  = &efw->rx_stream;
-               master = &efw->tx_stream;
-               slave_substreams  = efw->playback_substreams;
-               master_substreams = efw->capture_substreams;
-       }
-
-       if (slave_substreams == 0) {
-               stop_stream(efw, slave);
+       if (efw->capture_substreams == 0) {
+               stop_stream(efw, &efw->tx_stream);
 
-               if (master_substreams == 0)
-                       stop_stream(efw, master);
+               if (efw->playback_substreams == 0)
+                       stop_stream(efw, &efw->rx_stream);
        }
 }
 
index f80aafa44c89499ff92b0b3af0bc761ca49c0567..ca4dfcf4317579158c1cc6178a40fcf7eeda1052 100644 (file)
@@ -67,6 +67,38 @@ int snd_fw_transaction(struct fw_unit *unit, int tcode,
 }
 EXPORT_SYMBOL(snd_fw_transaction);
 
+#define PROBE_DELAY_MS         (2 * MSEC_PER_SEC)
+
+/**
+ * snd_fw_schedule_registration - schedule work for sound card registration
+ * @unit: an instance for unit on IEEE 1394 bus
+ * @dwork: delayed work with callback function
+ *
+ * This function is not designed for general purposes. When new unit is
+ * connected to IEEE 1394 bus, the bus is under bus-reset state because of
+ * topological change. In this state, units tend to fail both of asynchronous
+ * and isochronous communication. To avoid this problem, this function is used
+ * to postpone sound card registration after the state. The callers must
+ * set up instance of delayed work in advance.
+ */
+void snd_fw_schedule_registration(struct fw_unit *unit,
+                                 struct delayed_work *dwork)
+{
+       u64 now, delay;
+
+       now = get_jiffies_64();
+       delay = fw_parent_device(unit)->card->reset_jiffies
+                                       + msecs_to_jiffies(PROBE_DELAY_MS);
+
+       if (time_after64(delay, now))
+               delay -= now;
+       else
+               delay = 0;
+
+       mod_delayed_work(system_wq, dwork, delay);
+}
+EXPORT_SYMBOL(snd_fw_schedule_registration);
+
 static void async_midi_port_callback(struct fw_card *card, int rcode,
                                     void *data, size_t length,
                                     void *callback_data)
index f3f6f84c48d69747cc0fa3bd815d986c79ca0d78..f6769312ebfccbe473ac291e81b386b48b45488f 100644 (file)
@@ -22,6 +22,9 @@ static inline bool rcode_is_permanent_error(int rcode)
        return rcode == RCODE_TYPE_ERROR || rcode == RCODE_ADDRESS_ERROR;
 }
 
+void snd_fw_schedule_registration(struct fw_unit *unit,
+                                 struct delayed_work *dwork);
+
 struct snd_fw_async_midi_port;
 typedef int (*snd_fw_async_midi_port_fill)(
                                struct snd_rawmidi_substream *substream,
index 7cb5743c073bbed3f88d2452b6b6a7047f7619f3..d9361f3521338bce3befa1ddaa422a4e935680b4 100644 (file)
@@ -242,8 +242,7 @@ int snd_oxfw_stream_init_simplex(struct snd_oxfw *oxfw,
         * blocks than IEC 61883-6 defines.
         */
        if (stream == &oxfw->tx_stream) {
-               oxfw->tx_stream.flags |= CIP_SKIP_INIT_DBC_CHECK |
-                                        CIP_JUMBO_PAYLOAD;
+               oxfw->tx_stream.flags |= CIP_JUMBO_PAYLOAD;
                if (oxfw->wrong_dbs)
                        oxfw->tx_stream.flags |= CIP_WRONG_DBS;
        }
index abedc2207261cac52e6b848a7123cf746780941e..e629b88f7d933481a70cb72b6c504856c9a57d98 100644 (file)
@@ -118,15 +118,8 @@ end:
        return err;
 }
 
-/*
- * This module releases the FireWire unit data after all ALSA character devices
- * are released by applications. This is for releasing stream data or finishing
- * transactions safely. Thus at returning from .remove(), this module still keep
- * references for the unit.
- */
-static void oxfw_card_free(struct snd_card *card)
+static void oxfw_free(struct snd_oxfw *oxfw)
 {
-       struct snd_oxfw *oxfw = card->private_data;
        unsigned int i;
 
        snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
@@ -144,6 +137,17 @@ static void oxfw_card_free(struct snd_card *card)
        mutex_destroy(&oxfw->mutex);
 }
 
+/*
+ * This module releases the FireWire unit data after all ALSA character devices
+ * are released by applications. This is for releasing stream data or finishing
+ * transactions safely. Thus at returning from .remove(), this module still keep
+ * references for the unit.
+ */
+static void oxfw_card_free(struct snd_card *card)
+{
+       oxfw_free(card->private_data);
+}
+
 static int detect_quirks(struct snd_oxfw *oxfw)
 {
        struct fw_device *fw_dev = fw_parent_device(oxfw->unit);
@@ -205,41 +209,39 @@ static int detect_quirks(struct snd_oxfw *oxfw)
        return 0;
 }
 
-static int oxfw_probe(struct fw_unit *unit,
-                     const struct ieee1394_device_id *entry)
+static void do_registration(struct work_struct *work)
 {
-       struct snd_card *card;
-       struct snd_oxfw *oxfw;
+       struct snd_oxfw *oxfw = container_of(work, struct snd_oxfw, dwork.work);
        int err;
 
-       if (entry->vendor_id == VENDOR_LOUD && !detect_loud_models(unit))
-               return -ENODEV;
+       if (oxfw->registered)
+               return;
 
-       err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
-                          sizeof(*oxfw), &card);
+       err = snd_card_new(&oxfw->unit->device, -1, NULL, THIS_MODULE, 0,
+                          &oxfw->card);
        if (err < 0)
-               return err;
+               return;
 
-       card->private_free = oxfw_card_free;
-       oxfw = card->private_data;
-       oxfw->card = card;
-       mutex_init(&oxfw->mutex);
-       oxfw->unit = fw_unit_get(unit);
-       oxfw->entry = entry;
-       spin_lock_init(&oxfw->lock);
-       init_waitqueue_head(&oxfw->hwdep_wait);
+       err = name_card(oxfw);
+       if (err < 0)
+               goto error;
 
-       err = snd_oxfw_stream_discover(oxfw);
+       err = detect_quirks(oxfw);
        if (err < 0)
                goto error;
 
-       err = name_card(oxfw);
+       err = snd_oxfw_stream_discover(oxfw);
        if (err < 0)
                goto error;
 
-       err = detect_quirks(oxfw);
+       err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->rx_stream);
        if (err < 0)
                goto error;
+       if (oxfw->has_output) {
+               err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->tx_stream);
+               if (err < 0)
+                       goto error;
+       }
 
        err = snd_oxfw_create_pcm(oxfw);
        if (err < 0)
@@ -255,54 +257,97 @@ static int oxfw_probe(struct fw_unit *unit,
        if (err < 0)
                goto error;
 
-       err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->rx_stream);
+       err = snd_card_register(oxfw->card);
        if (err < 0)
                goto error;
-       if (oxfw->has_output) {
-               err = snd_oxfw_stream_init_simplex(oxfw, &oxfw->tx_stream);
-               if (err < 0)
-                       goto error;
-       }
 
-       err = snd_card_register(card);
-       if (err < 0) {
-               snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
-               if (oxfw->has_output)
-                       snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
-               goto error;
-       }
+       /*
+        * After registered, oxfw instance can be released corresponding to
+        * releasing the sound card instance.
+        */
+       oxfw->card->private_free = oxfw_card_free;
+       oxfw->card->private_data = oxfw;
+       oxfw->registered = true;
+
+       return;
+error:
+       snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
+       if (oxfw->has_output)
+               snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
+       snd_card_free(oxfw->card);
+       dev_info(&oxfw->unit->device,
+                "Sound card registration failed: %d\n", err);
+}
+
+static int oxfw_probe(struct fw_unit *unit,
+                     const struct ieee1394_device_id *entry)
+{
+       struct snd_oxfw *oxfw;
+
+       if (entry->vendor_id == VENDOR_LOUD && !detect_loud_models(unit))
+               return -ENODEV;
+
+       /* Allocate this independent of sound card instance. */
+       oxfw = kzalloc(sizeof(struct snd_oxfw), GFP_KERNEL);
+       if (oxfw == NULL)
+               return -ENOMEM;
+
+       oxfw->entry = entry;
+       oxfw->unit = fw_unit_get(unit);
        dev_set_drvdata(&unit->device, oxfw);
 
+       mutex_init(&oxfw->mutex);
+       spin_lock_init(&oxfw->lock);
+       init_waitqueue_head(&oxfw->hwdep_wait);
+
+       /* Allocate and register this sound card later. */
+       INIT_DEFERRABLE_WORK(&oxfw->dwork, do_registration);
+       snd_fw_schedule_registration(unit, &oxfw->dwork);
+
        return 0;
-error:
-       snd_card_free(card);
-       return err;
 }
 
 static void oxfw_bus_reset(struct fw_unit *unit)
 {
        struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
 
+       if (!oxfw->registered)
+               snd_fw_schedule_registration(unit, &oxfw->dwork);
+
        fcp_bus_reset(oxfw->unit);
 
-       mutex_lock(&oxfw->mutex);
+       if (oxfw->registered) {
+               mutex_lock(&oxfw->mutex);
 
-       snd_oxfw_stream_update_simplex(oxfw, &oxfw->rx_stream);
-       if (oxfw->has_output)
-               snd_oxfw_stream_update_simplex(oxfw, &oxfw->tx_stream);
+               snd_oxfw_stream_update_simplex(oxfw, &oxfw->rx_stream);
+               if (oxfw->has_output)
+                       snd_oxfw_stream_update_simplex(oxfw, &oxfw->tx_stream);
 
-       mutex_unlock(&oxfw->mutex);
+               mutex_unlock(&oxfw->mutex);
 
-       if (oxfw->entry->vendor_id == OUI_STANTON)
-               snd_oxfw_scs1x_update(oxfw);
+               if (oxfw->entry->vendor_id == OUI_STANTON)
+                       snd_oxfw_scs1x_update(oxfw);
+       }
 }
 
 static void oxfw_remove(struct fw_unit *unit)
 {
        struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
 
-       /* No need to wait for releasing card object in this context. */
-       snd_card_free_when_closed(oxfw->card);
+       /*
+        * Confirm to stop the work for registration before the sound card is
+        * going to be released. The work is not scheduled again because bus
+        * reset handler is not called anymore.
+        */
+       cancel_delayed_work_sync(&oxfw->dwork);
+
+       if (oxfw->registered) {
+               /* No need to wait for releasing card object in this context. */
+               snd_card_free_when_closed(oxfw->card);
+       } else {
+               /* Don't forget this case. */
+               oxfw_free(oxfw);
+       }
 }
 
 static const struct compat_info griffin_firewave = {
index 9beecc2147676090be4ccec9c1c4488fb63f883e..2047dcb27625161d8851658a2d4ad44e78da7263 100644 (file)
 struct snd_oxfw {
        struct snd_card *card;
        struct fw_unit *unit;
-       const struct device_info *device_info;
        struct mutex mutex;
        spinlock_t lock;
 
+       bool registered;
+       struct delayed_work dwork;
+
        bool wrong_dbs;
        bool has_output;
        u8 *tx_stream_formats[SND_OXFW_STREAM_FORMAT_ENTRIES];
index 0e6dd5c61f5388afc39cdaca33bff884ec5ad748..4ad3bd7fd4453e3a64fc4cd95001165510292559 100644 (file)
@@ -381,19 +381,17 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
        if (err < 0)
                return err;
        if (curr_rate != rate ||
-           amdtp_streaming_error(&tscm->tx_stream) ||
-           amdtp_streaming_error(&tscm->rx_stream)) {
+           amdtp_streaming_error(&tscm->rx_stream) ||
+           amdtp_streaming_error(&tscm->tx_stream)) {
                finish_session(tscm);
 
-               amdtp_stream_stop(&tscm->tx_stream);
                amdtp_stream_stop(&tscm->rx_stream);
+               amdtp_stream_stop(&tscm->tx_stream);
 
                release_resources(tscm);
        }
 
-       if (!amdtp_stream_running(&tscm->tx_stream)) {
-               amdtp_stream_set_sync(CIP_SYNC_TO_DEVICE,
-                                     &tscm->tx_stream, &tscm->rx_stream);
+       if (!amdtp_stream_running(&tscm->rx_stream)) {
                err = keep_resources(tscm, rate);
                if (err < 0)
                        goto error;
@@ -406,27 +404,27 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
                if (err < 0)
                        goto error;
 
-               err = amdtp_stream_start(&tscm->tx_stream,
-                               tscm->tx_resources.channel,
+               err = amdtp_stream_start(&tscm->rx_stream,
+                               tscm->rx_resources.channel,
                                fw_parent_device(tscm->unit)->max_speed);
                if (err < 0)
                        goto error;
 
-               if (!amdtp_stream_wait_callback(&tscm->tx_stream,
+               if (!amdtp_stream_wait_callback(&tscm->rx_stream,
                                                CALLBACK_TIMEOUT)) {
                        err = -ETIMEDOUT;
                        goto error;
                }
        }
 
-       if (!amdtp_stream_running(&tscm->rx_stream)) {
-               err = amdtp_stream_start(&tscm->rx_stream,
-                               tscm->rx_resources.channel,
+       if (!amdtp_stream_running(&tscm->tx_stream)) {
+               err = amdtp_stream_start(&tscm->tx_stream,
+                               tscm->tx_resources.channel,
                                fw_parent_device(tscm->unit)->max_speed);
                if (err < 0)
                        goto error;
 
-               if (!amdtp_stream_wait_callback(&tscm->rx_stream,
+               if (!amdtp_stream_wait_callback(&tscm->tx_stream,
                                                CALLBACK_TIMEOUT)) {
                        err = -ETIMEDOUT;
                        goto error;
@@ -435,8 +433,8 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
 
        return 0;
 error:
-       amdtp_stream_stop(&tscm->tx_stream);
        amdtp_stream_stop(&tscm->rx_stream);
+       amdtp_stream_stop(&tscm->tx_stream);
 
        finish_session(tscm);
        release_resources(tscm);
index e281c338e562d59e861303789d82c319b9a2ae9c..9dc93a7eb9da420fb871d7b28007b67b4d37f261 100644 (file)
@@ -85,10 +85,8 @@ static int identify_model(struct snd_tscm *tscm)
        return 0;
 }
 
-static void tscm_card_free(struct snd_card *card)
+static void tscm_free(struct snd_tscm *tscm)
 {
-       struct snd_tscm *tscm = card->private_data;
-
        snd_tscm_transaction_unregister(tscm);
        snd_tscm_stream_destroy_duplex(tscm);
 
@@ -97,44 +95,36 @@ static void tscm_card_free(struct snd_card *card)
        mutex_destroy(&tscm->mutex);
 }
 
-static int snd_tscm_probe(struct fw_unit *unit,
-                          const struct ieee1394_device_id *entry)
+static void tscm_card_free(struct snd_card *card)
 {
-       struct snd_card *card;
-       struct snd_tscm *tscm;
+       tscm_free(card->private_data);
+}
+
+static void do_registration(struct work_struct *work)
+{
+       struct snd_tscm *tscm = container_of(work, struct snd_tscm, dwork.work);
        int err;
 
-       /* create card */
-       err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
-                          sizeof(struct snd_tscm), &card);
+       err = snd_card_new(&tscm->unit->device, -1, NULL, THIS_MODULE, 0,
+                          &tscm->card);
        if (err < 0)
-               return err;
-       card->private_free = tscm_card_free;
-
-       /* initialize myself */
-       tscm = card->private_data;
-       tscm->card = card;
-       tscm->unit = fw_unit_get(unit);
-
-       mutex_init(&tscm->mutex);
-       spin_lock_init(&tscm->lock);
-       init_waitqueue_head(&tscm->hwdep_wait);
+               return;
 
        err = identify_model(tscm);
        if (err < 0)
                goto error;
 
-       snd_tscm_proc_init(tscm);
-
-       err = snd_tscm_stream_init_duplex(tscm);
+       err = snd_tscm_transaction_register(tscm);
        if (err < 0)
                goto error;
 
-       err = snd_tscm_create_pcm_devices(tscm);
+       err = snd_tscm_stream_init_duplex(tscm);
        if (err < 0)
                goto error;
 
-       err = snd_tscm_transaction_register(tscm);
+       snd_tscm_proc_init(tscm);
+
+       err = snd_tscm_create_pcm_devices(tscm);
        if (err < 0)
                goto error;
 
@@ -146,35 +136,91 @@ static int snd_tscm_probe(struct fw_unit *unit,
        if (err < 0)
                goto error;
 
-       err = snd_card_register(card);
+       err = snd_card_register(tscm->card);
        if (err < 0)
                goto error;
 
-       dev_set_drvdata(&unit->device, tscm);
+       /*
+        * After registered, tscm instance can be released corresponding to
+        * releasing the sound card instance.
+        */
+       tscm->card->private_free = tscm_card_free;
+       tscm->card->private_data = tscm;
+       tscm->registered = true;
 
-       return err;
+       return;
 error:
-       snd_card_free(card);
-       return err;
+       snd_tscm_transaction_unregister(tscm);
+       snd_tscm_stream_destroy_duplex(tscm);
+       snd_card_free(tscm->card);
+       dev_info(&tscm->unit->device,
+                "Sound card registration failed: %d\n", err);
+}
+
+static int snd_tscm_probe(struct fw_unit *unit,
+                          const struct ieee1394_device_id *entry)
+{
+       struct snd_tscm *tscm;
+
+       /* Allocate this independent of sound card instance. */
+       tscm = kzalloc(sizeof(struct snd_tscm), GFP_KERNEL);
+       if (tscm == NULL)
+               return -ENOMEM;
+
+       /* initialize myself */
+       tscm->unit = fw_unit_get(unit);
+       dev_set_drvdata(&unit->device, tscm);
+
+       mutex_init(&tscm->mutex);
+       spin_lock_init(&tscm->lock);
+       init_waitqueue_head(&tscm->hwdep_wait);
+
+       /* Allocate and register this sound card later. */
+       INIT_DEFERRABLE_WORK(&tscm->dwork, do_registration);
+       snd_fw_schedule_registration(unit, &tscm->dwork);
+
+       return 0;
 }
 
 static void snd_tscm_update(struct fw_unit *unit)
 {
        struct snd_tscm *tscm = dev_get_drvdata(&unit->device);
 
+       /* Postpone a workqueue for deferred registration. */
+       if (!tscm->registered)
+               snd_fw_schedule_registration(unit, &tscm->dwork);
+
        snd_tscm_transaction_reregister(tscm);
 
-       mutex_lock(&tscm->mutex);
-       snd_tscm_stream_update_duplex(tscm);
-       mutex_unlock(&tscm->mutex);
+       /*
+        * After registration, userspace can start packet streaming, then this
+        * code block works fine.
+        */
+       if (tscm->registered) {
+               mutex_lock(&tscm->mutex);
+               snd_tscm_stream_update_duplex(tscm);
+               mutex_unlock(&tscm->mutex);
+       }
 }
 
 static void snd_tscm_remove(struct fw_unit *unit)
 {
        struct snd_tscm *tscm = dev_get_drvdata(&unit->device);
 
-       /* No need to wait for releasing card object in this context. */
-       snd_card_free_when_closed(tscm->card);
+       /*
+        * Confirm to stop the work for registration before the sound card is
+        * going to be released. The work is not scheduled again because bus
+        * reset handler is not called anymore.
+        */
+       cancel_delayed_work_sync(&tscm->dwork);
+
+       if (tscm->registered) {
+               /* No need to wait for releasing card object in this context. */
+               snd_card_free_when_closed(tscm->card);
+       } else {
+               /* Don't forget this case. */
+               tscm_free(tscm);
+       }
 }
 
 static const struct ieee1394_device_id snd_tscm_id_table[] = {
index 30ab77e924f7f68f9b939a230109152722ad9057..1f61011579a7fc72f44b6cae84d2e2d039969ddf 100644 (file)
@@ -51,6 +51,8 @@ struct snd_tscm {
        struct mutex mutex;
        spinlock_t lock;
 
+       bool registered;
+       struct delayed_work dwork;
        const struct snd_tscm_spec *spec;
 
        struct fw_iso_resources tx_resources;
index 2433f7c81472848be51b9af420ec198b523871b1..31b510c5ca0bdf3cfef06bdbc47700e4f8c3ca73 100644 (file)
@@ -105,6 +105,9 @@ int snd_hdac_ext_bus_init(struct hdac_ext_bus *ebus, struct device *dev,
        INIT_LIST_HEAD(&ebus->hlink_list);
        ebus->idx = idx++;
 
+       mutex_init(&ebus->lock);
+       ebus->cmd_dma_state = true;
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_init);
@@ -144,6 +147,7 @@ int snd_hdac_ext_bus_device_init(struct hdac_ext_bus *ebus, int addr)
        if (!edev)
                return -ENOMEM;
        hdev = &edev->hdac;
+       edev->ebus = ebus;
 
        snprintf(name, sizeof(name), "ehdaudio%dD%d", ebus->idx, addr);
 
index 548cc1e4114bb81af0136cf77d517b4e751c6736..860f8cad6602d59332f1990b2e3ee216da0b72f6 100644 (file)
@@ -186,6 +186,9 @@ int snd_hdac_ext_bus_get_ml_capabilities(struct hdac_ext_bus *ebus)
                hlink->lcaps  = readl(hlink->ml_addr + AZX_REG_ML_LCAP);
                hlink->lsdiid = readw(hlink->ml_addr + AZX_REG_ML_LSDIID);
 
+               /* since link in On, update the ref */
+               hlink->ref_count = 1;
+
                list_add_tail(&hlink->list, &ebus->hlink_list);
        }
 
@@ -327,3 +330,66 @@ int snd_hdac_ext_bus_link_power_down_all(struct hdac_ext_bus *ebus)
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_down_all);
+
+int snd_hdac_ext_bus_link_get(struct hdac_ext_bus *ebus,
+                               struct hdac_ext_link *link)
+{
+       int ret = 0;
+
+       mutex_lock(&ebus->lock);
+
+       /*
+        * if we move from 0 to 1, count will be 1 so power up this link
+        * as well, also check the dma status and trigger that
+        */
+       if (++link->ref_count == 1) {
+               if (!ebus->cmd_dma_state) {
+                       snd_hdac_bus_init_cmd_io(&ebus->bus);
+                       ebus->cmd_dma_state = true;
+               }
+
+               ret = snd_hdac_ext_bus_link_power_up(link);
+       }
+
+       mutex_unlock(&ebus->lock);
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_get);
+
+int snd_hdac_ext_bus_link_put(struct hdac_ext_bus *ebus,
+                               struct hdac_ext_link *link)
+{
+       int ret = 0;
+       struct hdac_ext_link *hlink;
+       bool link_up = false;
+
+       mutex_lock(&ebus->lock);
+
+       /*
+        * if we move from 1 to 0, count will be 0
+        * so power down this link as well
+        */
+       if (--link->ref_count == 0) {
+               ret = snd_hdac_ext_bus_link_power_down(link);
+
+               /*
+                * now check if all links are off, if so turn off
+                * cmd dma as well
+                */
+               list_for_each_entry(hlink, &ebus->hlink_list, list) {
+                       if (hlink->ref_count) {
+                               link_up = true;
+                               break;
+                       }
+               }
+
+               if (!link_up) {
+                       snd_hdac_bus_stop_cmd_io(&ebus->bus);
+                       ebus->cmd_dma_state = false;
+               }
+       }
+
+       mutex_unlock(&ebus->lock);
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_put);
index 8c486235c905253ea0609183d813362a294e42f9..9fee464e5d49772f53db5d4f5a6485ecaa028b10 100644 (file)
@@ -80,6 +80,22 @@ void snd_hdac_bus_init_cmd_io(struct hdac_bus *bus)
 }
 EXPORT_SYMBOL_GPL(snd_hdac_bus_init_cmd_io);
 
+/* wait for cmd dmas till they are stopped */
+static void hdac_wait_for_cmd_dmas(struct hdac_bus *bus)
+{
+       unsigned long timeout;
+
+       timeout = jiffies + msecs_to_jiffies(100);
+       while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN)
+               && time_before(jiffies, timeout))
+               udelay(10);
+
+       timeout = jiffies + msecs_to_jiffies(100);
+       while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN)
+               && time_before(jiffies, timeout))
+               udelay(10);
+}
+
 /**
  * snd_hdac_bus_stop_cmd_io - clean up CORB/RIRB buffers
  * @bus: HD-audio core bus
@@ -90,6 +106,7 @@ void snd_hdac_bus_stop_cmd_io(struct hdac_bus *bus)
        /* disable ringbuffer DMAs */
        snd_hdac_chip_writeb(bus, RIRBCTL, 0);
        snd_hdac_chip_writeb(bus, CORBCTL, 0);
+       hdac_wait_for_cmd_dmas(bus);
        /* disable unsolicited responses */
        snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_UNSOL, 0);
        spin_unlock_irq(&bus->reg_lock);
index 607bbeaebddf784aadb062c7b3934b4fa506c1e0..c9af022676c2f1071585d6ec3a7975ef19ed55be 100644 (file)
@@ -158,22 +158,40 @@ void snd_hdac_i915_set_bclk(struct hdac_bus *bus)
 }
 EXPORT_SYMBOL_GPL(snd_hdac_i915_set_bclk);
 
-/* There is a fixed mapping between audio pin node and display port
- * on current Intel platforms:
+/* There is a fixed mapping between audio pin node and display port.
+ * on SNB, IVY, HSW, BSW, SKL, BXT, KBL:
  * Pin Widget 5 - PORT B (port = 1 in i915 driver)
  * Pin Widget 6 - PORT C (port = 2 in i915 driver)
  * Pin Widget 7 - PORT D (port = 3 in i915 driver)
+ *
+ * on VLV, ILK:
+ * Pin Widget 4 - PORT B (port = 1 in i915 driver)
+ * Pin Widget 5 - PORT C (port = 2 in i915 driver)
+ * Pin Widget 6 - PORT D (port = 3 in i915 driver)
  */
-static int pin2port(hda_nid_t pin_nid)
+static int pin2port(struct hdac_device *codec, hda_nid_t pin_nid)
 {
-       if (WARN_ON(pin_nid < 5 || pin_nid > 7))
+       int base_nid;
+
+       switch (codec->vendor_id) {
+       case 0x80860054: /* ILK */
+       case 0x80862804: /* ILK */
+       case 0x80862882: /* VLV */
+               base_nid = 3;
+               break;
+       default:
+               base_nid = 4;
+               break;
+       }
+
+       if (WARN_ON(pin_nid <= base_nid || pin_nid > base_nid + 3))
                return -1;
-       return pin_nid - 4;
+       return pin_nid - base_nid;
 }
 
 /**
  * snd_hdac_sync_audio_rate - Set N/CTS based on the sample rate
- * @bus: HDA core bus
+ * @codec: HDA codec
  * @nid: the pin widget NID
  * @rate: the sample rate to set
  *
@@ -183,14 +201,15 @@ static int pin2port(hda_nid_t pin_nid)
  * This function sets N/CTS value based on the given sample rate.
  * Returns zero for success, or a negative error code.
  */
-int snd_hdac_sync_audio_rate(struct hdac_bus *bus, hda_nid_t nid, int rate)
+int snd_hdac_sync_audio_rate(struct hdac_device *codec, hda_nid_t nid, int rate)
 {
+       struct hdac_bus *bus = codec->bus;
        struct i915_audio_component *acomp = bus->audio_component;
        int port;
 
        if (!acomp || !acomp->ops || !acomp->ops->sync_audio_rate)
                return -ENODEV;
-       port = pin2port(nid);
+       port = pin2port(codec, nid);
        if (port < 0)
                return -EINVAL;
        return acomp->ops->sync_audio_rate(acomp->dev, port, rate);
@@ -199,7 +218,7 @@ EXPORT_SYMBOL_GPL(snd_hdac_sync_audio_rate);
 
 /**
  * snd_hdac_acomp_get_eld - Get the audio state and ELD via component
- * @bus: HDA core bus
+ * @codec: HDA codec
  * @nid: the pin widget NID
  * @audio_enabled: the pointer to store the current audio state
  * @buffer: the buffer pointer to store ELD bytes
@@ -217,16 +236,17 @@ EXPORT_SYMBOL_GPL(snd_hdac_sync_audio_rate);
  * thus it may be over @max_bytes.  If it's over @max_bytes, it implies
  * that only a part of ELD bytes have been fetched.
  */
-int snd_hdac_acomp_get_eld(struct hdac_bus *bus, hda_nid_t nid,
+int snd_hdac_acomp_get_eld(struct hdac_device *codec, hda_nid_t nid,
                           bool *audio_enabled, char *buffer, int max_bytes)
 {
+       struct hdac_bus *bus = codec->bus;
        struct i915_audio_component *acomp = bus->audio_component;
        int port;
 
        if (!acomp || !acomp->ops || !acomp->ops->get_eld)
                return -ENODEV;
 
-       port = pin2port(nid);
+       port = pin2port(codec, nid);
        if (port < 0)
                return -EINVAL;
        return acomp->ops->get_eld(acomp->dev, port, audio_enabled,
@@ -338,6 +358,9 @@ int snd_hdac_i915_init(struct hdac_bus *bus)
        struct i915_audio_component *acomp;
        int ret;
 
+       if (WARN_ON(hdac_acomp))
+               return -EBUSY;
+
        if (!i915_gfx_present())
                return -ENODEV;
 
@@ -371,6 +394,7 @@ out_master_del:
 out_err:
        kfree(acomp);
        bus->audio_component = NULL;
+       hdac_acomp = NULL;
        dev_info(dev, "failed to add i915 component master (%d)\n", ret);
 
        return ret;
@@ -404,6 +428,7 @@ int snd_hdac_i915_exit(struct hdac_bus *bus)
 
        kfree(acomp);
        bus->audio_component = NULL;
+       hdac_acomp = NULL;
 
        return 0;
 }
index d7ec862638286d0272206dc77b647491ca19c7ae..c6c75e7e0981affde1d06b508f551b7be25733a0 100644 (file)
@@ -625,13 +625,30 @@ static void hdmi_cea_alloc_to_tlv_chmap(struct hdac_chmap *hchmap,
        WARN_ON(count != channels);
 }
 
+static int spk_mask_from_spk_alloc(int spk_alloc)
+{
+       int i;
+       int spk_mask = eld_speaker_allocation_bits[0];
+
+       for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
+               if (spk_alloc & (1 << i))
+                       spk_mask |= eld_speaker_allocation_bits[i];
+       }
+
+       return spk_mask;
+}
+
 static int hdmi_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                              unsigned int size, unsigned int __user *tlv)
 {
        struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
        struct hdac_chmap *chmap = info->private_data;
+       int pcm_idx = kcontrol->private_value;
        unsigned int __user *dst;
        int chs, count = 0;
+       unsigned long max_chs;
+       int type;
+       int spk_alloc, spk_mask;
 
        if (size < 8)
                return -ENOMEM;
@@ -639,40 +656,59 @@ static int hdmi_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                return -EFAULT;
        size -= 8;
        dst = tlv + 2;
-       for (chs = 2; chs <= chmap->channels_max; chs++) {
+
+       spk_alloc = chmap->ops.get_spk_alloc(chmap->hdac, pcm_idx);
+       spk_mask = spk_mask_from_spk_alloc(spk_alloc);
+
+       max_chs = hweight_long(spk_mask);
+
+       for (chs = 2; chs <= max_chs; chs++) {
                int i;
                struct hdac_cea_channel_speaker_allocation *cap;
 
                cap = channel_allocations;
                for (i = 0; i < ARRAY_SIZE(channel_allocations); i++, cap++) {
                        int chs_bytes = chs * 4;
-                       int type = chmap->ops.chmap_cea_alloc_validate_get_type(
-                                                               chmap, cap, chs);
                        unsigned int tlv_chmap[8];
 
-                       if (type < 0)
+                       if (cap->channels != chs)
+                               continue;
+
+                       if (!(cap->spk_mask == (spk_mask & cap->spk_mask)))
                                continue;
+
+                       type = chmap->ops.chmap_cea_alloc_validate_get_type(
+                                                       chmap, cap, chs);
+                       if (type < 0)
+                               return -ENODEV;
                        if (size < 8)
                                return -ENOMEM;
+
                        if (put_user(type, dst) ||
                            put_user(chs_bytes, dst + 1))
                                return -EFAULT;
+
                        dst += 2;
                        size -= 8;
                        count += 8;
+
                        if (size < chs_bytes)
                                return -ENOMEM;
+
                        size -= chs_bytes;
                        count += chs_bytes;
                        chmap->ops.cea_alloc_to_tlv_chmap(chmap, cap,
                                                tlv_chmap, chs);
+
                        if (copy_to_user(dst, tlv_chmap, chs_bytes))
                                return -EFAULT;
                        dst += chs;
                }
        }
+
        if (put_user(count, tlv + 1))
                return -EFAULT;
+
        return 0;
 }
 
index d692f417ddc0a2c159092bd76aaa2c2fef8d44a5..0d5bb159d538ef53dcddb1914a3b4068c90f4795 100644 (file)
@@ -16,6 +16,16 @@ static inline int get_wcaps_type(unsigned int wcaps)
        return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 }
 
+static inline unsigned int get_wcaps_channels(u32 wcaps)
+{
+       unsigned int chans;
+
+       chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13;
+       chans = (chans + 1) * 2;
+
+       return chans;
+}
+
 extern const struct attribute_group *hdac_dev_attr_groups[];
 int hda_widget_sysfs_init(struct hdac_device *codec);
 void hda_widget_sysfs_exit(struct hdac_device *codec);
index 69f76ff5693d4ec864a8dea68e374929bed66974..718d5e3b7806f01da8782ed9955c9d5dd22db57a 100644 (file)
@@ -785,6 +785,9 @@ wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
        DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
                                      header->number);
 
+       if (header->number >= ARRAY_SIZE(dev->patch_status))
+               return -EINVAL;
+
        dev->patch_status[header->number] |= WF_SLOT_FILLED;
 
        bptr = buf;
@@ -809,6 +812,9 @@ wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
        DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
                header->number);
 
+       if (header->number >= ARRAY_SIZE(dev->prog_status))
+               return -EINVAL;
+
        dev->prog_status[header->number] = WF_SLOT_USED;
 
        /* XXX need to zero existing SLOT_USED bit for program_status[i]
@@ -898,6 +904,9 @@ wavefront_send_sample (snd_wavefront_t *dev,
                header->number = x;
        }
 
+       if (header->number >= WF_MAX_SAMPLE)
+               return -EINVAL;
+
        if (header->size) {
 
                /* XXX it's a debatable point whether or not RDONLY semantics
index b36ea47527e87f567cd5c97ee7b9d3297676f092..0b8d0de872732e618a55f6b26e9bec9935956d60 100644 (file)
@@ -1414,11 +1414,9 @@ attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *m
        else {
 #ifdef CONFIG_ARCH_NETWINDER
                if (machine_is_netwinder()) {
-                       init_timer(&vnc_timer);
-                       vnc_timer.function = vnc_slider_tick;
-                       vnc_timer.expires  = jiffies;
-                       vnc_timer.data     = nr_waveartist_devs;
-                       add_timer(&vnc_timer);
+                       setup_timer(&vnc_timer, vnc_slider_tick,
+                                   nr_waveartist_devs);
+                       mod_timer(&vnc_timer, jiffies);
 
                        vnc_configure_mixer(devc, 0);
 
index 4667c3232b7f1d48d15d637bb73019ba40675958..4a054d72011246db38fbdba68c25f3da0c0ce372 100644 (file)
@@ -2151,8 +2151,7 @@ vortex_adb_allocroute(vortex_t *vortex, int dma, int nr_ch, int dir,
                                                           stream->resources, en,
                                                           VORTEX_RESOURCE_SRC)) < 0) {
                                        memset(stream->resources, 0,
-                                              sizeof(unsigned char) *
-                                              VORTEX_RESOURCE_LAST);
+                                              sizeof(stream->resources));
                                        return -EBUSY;
                                }
                                if (stream->type != VORTEX_PCM_A3D) {
@@ -2162,7 +2161,7 @@ vortex_adb_allocroute(vortex_t *vortex, int dma, int nr_ch, int dir,
                                                                   VORTEX_RESOURCE_MIXIN)) < 0) {
                                                memset(stream->resources,
                                                       0,
-                                                      sizeof(unsigned char) * VORTEX_RESOURCE_LAST);
+                                                      sizeof(stream->resources));
                                                return -EBUSY;
                                        }
                                }
@@ -2175,8 +2174,7 @@ vortex_adb_allocroute(vortex_t *vortex, int dma, int nr_ch, int dir,
                                                   stream->resources, en,
                                                   VORTEX_RESOURCE_A3D)) < 0) {
                                memset(stream->resources, 0,
-                                      sizeof(unsigned char) *
-                                      VORTEX_RESOURCE_LAST);
+                                      sizeof(stream->resources));
                                dev_err(vortex->card->dev,
                                        "out of A3D sources. Sorry\n");
                                return -EBUSY;
@@ -2290,8 +2288,7 @@ vortex_adb_allocroute(vortex_t *vortex, int dma, int nr_ch, int dir,
                                                   VORTEX_RESOURCE_MIXOUT))
                            < 0) {
                                memset(stream->resources, 0,
-                                      sizeof(unsigned char) *
-                                      VORTEX_RESOURCE_LAST);
+                                      sizeof(stream->resources));
                                return -EBUSY;
                        }
                        if ((src[i] =
@@ -2299,8 +2296,7 @@ vortex_adb_allocroute(vortex_t *vortex, int dma, int nr_ch, int dir,
                                                   stream->resources, en,
                                                   VORTEX_RESOURCE_SRC)) < 0) {
                                memset(stream->resources, 0,
-                                      sizeof(unsigned char) *
-                                      VORTEX_RESOURCE_LAST);
+                                      sizeof(stream->resources));
                                return -EBUSY;
                        }
                }
index a6d6d8d0867add5446fd6a0126cca7b7041d8d3b..df5741a78fd23089eff63ef26d213f7341d8b60a 100644 (file)
@@ -432,7 +432,10 @@ static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substr
 #endif
        //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
        spin_unlock(&chip->lock);
-       return (bytes_to_frames(substream->runtime, current_ptr));
+       current_ptr = bytes_to_frames(substream->runtime, current_ptr);
+       if (current_ptr >= substream->runtime->buffer_size)
+               current_ptr = 0;
+       return current_ptr;
 }
 
 /* operators */
index a5d460453d7bbf1895bf7e0085675ec7e36b9d60..8f945341720bb594d54694bd5f99be855dcd339a 100644 (file)
@@ -49,7 +49,7 @@ struct ct_timer {
        spinlock_t lock;                /* global timer lock (for xfitimer) */
        spinlock_t list_lock;           /* lock for instance list */
        struct ct_atc *atc;
-       struct ct_timer_ops *ops;
+       const struct ct_timer_ops *ops;
        struct list_head instance_head;
        struct list_head running_head;
        unsigned int wc;                /* current wallclock */
@@ -128,7 +128,7 @@ static void ct_systimer_prepare(struct ct_timer_instance *ti)
 
 #define ct_systimer_free       ct_systimer_prepare
 
-static struct ct_timer_ops ct_systimer_ops = {
+static const struct ct_timer_ops ct_systimer_ops = {
        .init = ct_systimer_init,
        .free_instance = ct_systimer_free,
        .prepare = ct_systimer_prepare,
@@ -322,7 +322,7 @@ static void ct_xfitimer_free_global(struct ct_timer *atimer)
        ct_xfitimer_irq_stop(atimer);
 }
 
-static struct ct_timer_ops ct_xfitimer_ops = {
+static const struct ct_timer_ops ct_xfitimer_ops = {
        .prepare = ct_xfitimer_prepare,
        .start = ct_xfitimer_start,
        .stop = ct_xfitimer_stop,
index 0dc44ebb00329e3266d6bad2e20b424588c9a321..626cd2167d29032e7369ed94c447445acbb9451d 100644 (file)
@@ -1548,7 +1548,7 @@ static int snd_es1373_line_get(struct snd_kcontrol *kcontrol,
        int val = 0;
        
        spin_lock_irq(&ensoniq->reg_lock);
-       if ((ensoniq->ctrl & ES_1371_GPIO_OUTM) >= 4)
+       if (ensoniq->ctrl & ES_1371_GPIO_OUT(4))
                val = 1;
        ucontrol->value.integer.value[0] = val;
        spin_unlock_irq(&ensoniq->reg_lock);
index bb02c2d48fd508d2892d39b5ec58e976831d59b2..7f3b5ed819957df6aacb5ab483e55e50d9b4d49d 100644 (file)
@@ -50,9 +50,13 @@ config SND_HDA_RECONFIG
        bool "Allow dynamic codec reconfiguration"
        help
          Say Y here to enable the HD-audio codec re-configuration feature.
-         This adds the sysfs interfaces to allow user to clear the whole
-         codec configuration, change the codec setup, add extra verbs,
-         and re-configure the codec dynamically.
+         It allows user to clear the whole codec configuration, change the
+         codec setup, add extra verbs, and re-configure the codec dynamically.
+
+         Note that this item alone doesn't provide the sysfs interface, but
+         enables the feature just for the patch loader below.
+         If you need the traditional sysfs entries for the manual interaction,
+         turn on CONFIG_SND_HDA_HWDEP as well.
 
 config SND_HDA_INPUT_BEEP
        bool "Support digital beep via input layer"
index dfaf1a93fb8a3b8aba4fee3f3090a48b08ed2734..320445f3bf736d51e3dcfc884cdf5f7aef0b3855 100644 (file)
@@ -5434,6 +5434,7 @@ static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
        spec->cur_adc_stream_tag = stream_tag;
        spec->cur_adc_format = format;
        snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
+       call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
        return 0;
 }
 
@@ -5444,6 +5445,7 @@ static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
        struct hda_gen_spec *spec = codec->spec;
        snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
        spec->cur_adc = 0;
+       call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
        return 0;
 }
 
index a010d704e0e20b066d912349088cfe0a27de0c31..d0d5ad8beac565b8e5bee7bb61f6e692081083ec 100644 (file)
@@ -114,6 +114,9 @@ struct hdmi_ops {
        int (*setup_stream)(struct hda_codec *codec, hda_nid_t cvt_nid,
                            hda_nid_t pin_nid, u32 stream_tag, int format);
 
+       void (*pin_cvt_fixup)(struct hda_codec *codec,
+                             struct hdmi_spec_per_pin *per_pin,
+                             hda_nid_t cvt_nid);
 };
 
 struct hdmi_pcm {
@@ -684,7 +687,8 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
        if (!channels)
                return;
 
-       if (is_haswell_plus(codec))
+       /* some HW (e.g. HSW+) needs reprogramming the amp at each time */
+       if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
                snd_hda_codec_write(codec, pin_nid, 0,
                                            AC_VERB_SET_AMP_GAIN_MUTE,
                                            AMP_OUT_UNMUTE);
@@ -864,9 +868,6 @@ static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
        struct hdmi_spec *spec = codec->spec;
        int err;
 
-       if (is_haswell_plus(codec))
-               haswell_verify_D0(codec, cvt_nid, pin_nid);
-
        err = spec->ops.pin_hbr_setup(codec, pin_nid, is_hbr_format(format));
 
        if (err) {
@@ -884,7 +885,7 @@ static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
  * of the pin.
  */
 static int hdmi_choose_cvt(struct hda_codec *codec,
-                       int pin_idx, int *cvt_id, int *mux_id)
+                          int pin_idx, int *cvt_id)
 {
        struct hdmi_spec *spec = codec->spec;
        struct hdmi_spec_per_pin *per_pin;
@@ -925,8 +926,6 @@ static int hdmi_choose_cvt(struct hda_codec *codec,
 
        if (cvt_id)
                *cvt_id = cvt_idx;
-       if (mux_id)
-               *mux_id = mux_idx;
 
        return 0;
 }
@@ -1019,9 +1018,6 @@ static void intel_not_share_assigned_cvt_nid(struct hda_codec *codec,
        int mux_idx;
        struct hdmi_spec *spec = codec->spec;
 
-       if (!is_haswell_plus(codec) && !is_valleyview_plus(codec))
-               return;
-
        /* On Intel platform, the mapping of converter nid to
         * mux index of the pins are always the same.
         * The pin nid may be 0, this means all pins will not
@@ -1032,6 +1028,17 @@ static void intel_not_share_assigned_cvt_nid(struct hda_codec *codec,
                intel_not_share_assigned_cvt(codec, pin_nid, mux_idx);
 }
 
+/* skeleton caller of pin_cvt_fixup ops */
+static void pin_cvt_fixup(struct hda_codec *codec,
+                         struct hdmi_spec_per_pin *per_pin,
+                         hda_nid_t cvt_nid)
+{
+       struct hdmi_spec *spec = codec->spec;
+
+       if (spec->ops.pin_cvt_fixup)
+               spec->ops.pin_cvt_fixup(codec, per_pin, cvt_nid);
+}
+
 /* called in hdmi_pcm_open when no pin is assigned to the PCM
  * in dyn_pcm_assign mode.
  */
@@ -1049,7 +1056,7 @@ static int hdmi_pcm_open_no_pin(struct hda_pcm_stream *hinfo,
        if (pcm_idx < 0)
                return -EINVAL;
 
-       err = hdmi_choose_cvt(codec, -1, &cvt_idx, NULL);
+       err = hdmi_choose_cvt(codec, -1, &cvt_idx);
        if (err)
                return err;
 
@@ -1057,7 +1064,7 @@ static int hdmi_pcm_open_no_pin(struct hda_pcm_stream *hinfo,
        per_cvt->assigned = 1;
        hinfo->nid = per_cvt->cvt_nid;
 
-       intel_not_share_assigned_cvt_nid(codec, 0, per_cvt->cvt_nid);
+       pin_cvt_fixup(codec, NULL, per_cvt->cvt_nid);
 
        set_bit(pcm_idx, &spec->pcm_in_use);
        /* todo: setup spdif ctls assign */
@@ -1089,7 +1096,7 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
 {
        struct hdmi_spec *spec = codec->spec;
        struct snd_pcm_runtime *runtime = substream->runtime;
-       int pin_idx, cvt_idx, pcm_idx, mux_idx = 0;
+       int pin_idx, cvt_idx, pcm_idx;
        struct hdmi_spec_per_pin *per_pin;
        struct hdmi_eld *eld;
        struct hdmi_spec_per_cvt *per_cvt = NULL;
@@ -1118,7 +1125,7 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
                }
        }
 
-       err = hdmi_choose_cvt(codec, pin_idx, &cvt_idx, &mux_idx);
+       err = hdmi_choose_cvt(codec, pin_idx, &cvt_idx);
        if (err < 0) {
                mutex_unlock(&spec->pcm_lock);
                return err;
@@ -1135,11 +1142,10 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
 
        snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
                            AC_VERB_SET_CONNECT_SEL,
-                           mux_idx);
+                           per_pin->mux_idx);
 
        /* configure unused pins to choose other converters */
-       if (is_haswell_plus(codec) || is_valleyview_plus(codec))
-               intel_not_share_assigned_cvt(codec, per_pin->pin_nid, mux_idx);
+       pin_cvt_fixup(codec, per_pin, 0);
 
        snd_hda_spdif_ctls_assign(codec, pcm_idx, per_cvt->cvt_nid);
 
@@ -1372,12 +1378,7 @@ static void update_eld(struct hda_codec *codec,
         *   and this can make HW reset converter selection on a pin.
         */
        if (eld->eld_valid && !old_eld_valid && per_pin->setup) {
-               if (is_haswell_plus(codec) || is_valleyview_plus(codec)) {
-                       intel_verify_pin_cvt_connect(codec, per_pin);
-                       intel_not_share_assigned_cvt(codec, per_pin->pin_nid,
-                                                    per_pin->mux_idx);
-               }
-
+               pin_cvt_fixup(codec, per_pin, 0);
                hdmi_setup_audio_infoframe(codec, per_pin, per_pin->non_pcm);
        }
 
@@ -1484,7 +1485,7 @@ static void sync_eld_via_acomp(struct hda_codec *codec,
 
        mutex_lock(&per_pin->lock);
        eld->monitor_present = false;
-       size = snd_hdac_acomp_get_eld(&codec->bus->core, per_pin->pin_nid,
+       size = snd_hdac_acomp_get_eld(&codec->core, per_pin->pin_nid,
                                      &eld->monitor_present, eld->eld_buffer,
                                      ELD_MAX_SIZE);
        if (size > 0) {
@@ -1711,7 +1712,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                 * skip pin setup and return 0 to make audio playback
                 * be ongoing
                 */
-               intel_not_share_assigned_cvt_nid(codec, 0, cvt_nid);
+               pin_cvt_fixup(codec, NULL, cvt_nid);
                snd_hda_codec_setup_stream(codec, cvt_nid,
                                        stream_tag, 0, format);
                mutex_unlock(&spec->pcm_lock);
@@ -1724,23 +1725,21 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
        }
        per_pin = get_pin(spec, pin_idx);
        pin_nid = per_pin->pin_nid;
-       if (is_haswell_plus(codec) || is_valleyview_plus(codec)) {
-               /* Verify pin:cvt selections to avoid silent audio after S3.
-                * After S3, the audio driver restores pin:cvt selections
-                * but this can happen before gfx is ready and such selection
-                * is overlooked by HW. Thus multiple pins can share a same
-                * default convertor and mute control will affect each other,
-                * which can cause a resumed audio playback become silent
-                * after S3.
-                */
-               intel_verify_pin_cvt_connect(codec, per_pin);
-               intel_not_share_assigned_cvt(codec, pin_nid, per_pin->mux_idx);
-       }
+
+       /* Verify pin:cvt selections to avoid silent audio after S3.
+        * After S3, the audio driver restores pin:cvt selections
+        * but this can happen before gfx is ready and such selection
+        * is overlooked by HW. Thus multiple pins can share a same
+        * default convertor and mute control will affect each other,
+        * which can cause a resumed audio playback become silent
+        * after S3.
+        */
+       pin_cvt_fixup(codec, per_pin, 0);
 
        /* Call sync_audio_rate to set the N/CTS/M manually if necessary */
        /* Todo: add DP1.2 MST audio support later */
        if (codec_has_acomp(codec))
-               snd_hdac_sync_audio_rate(&codec->bus->core, pin_nid, runtime->rate);
+               snd_hdac_sync_audio_rate(&codec->core, pin_nid, runtime->rate);
 
        non_pcm = check_non_pcm_per_cvt(codec, cvt_nid);
        mutex_lock(&per_pin->lock);
@@ -1837,6 +1836,18 @@ static const struct hda_pcm_ops generic_ops = {
        .cleanup = generic_hdmi_playback_pcm_cleanup,
 };
 
+static int hdmi_get_spk_alloc(struct hdac_device *hdac, int pcm_idx)
+{
+       struct hda_codec *codec = container_of(hdac, struct hda_codec, core);
+       struct hdmi_spec *spec = codec->spec;
+       struct hdmi_spec_per_pin *per_pin = pcm_idx_to_pin(spec, pcm_idx);
+
+       if (!per_pin)
+               return 0;
+
+       return per_pin->sink_eld.info.spk_alloc;
+}
+
 static void hdmi_get_chmap(struct hdac_device *hdac, int pcm_idx,
                                        unsigned char *chmap)
 {
@@ -2075,6 +2086,20 @@ static void hdmi_array_free(struct hdmi_spec *spec)
        snd_array_free(&spec->cvts);
 }
 
+static void generic_spec_free(struct hda_codec *codec)
+{
+       struct hdmi_spec *spec = codec->spec;
+
+       if (spec) {
+               if (spec->i915_bound)
+                       snd_hdac_i915_exit(&codec->bus->core);
+               hdmi_array_free(spec);
+               kfree(spec);
+               codec->spec = NULL;
+       }
+       codec->dp_mst = false;
+}
+
 static void generic_hdmi_free(struct hda_codec *codec)
 {
        struct hdmi_spec *spec = codec->spec;
@@ -2099,10 +2124,7 @@ static void generic_hdmi_free(struct hda_codec *codec)
                        spec->pcm_rec[pcm_idx].jack = NULL;
        }
 
-       if (spec->i915_bound)
-               snd_hdac_i915_exit(&codec->bus->core);
-       hdmi_array_free(spec);
-       kfree(spec);
+       generic_spec_free(codec);
 }
 
 #ifdef CONFIG_PM
@@ -2140,6 +2162,55 @@ static const struct hdmi_ops generic_standard_hdmi_ops = {
        .setup_stream                           = hdmi_setup_stream,
 };
 
+/* allocate codec->spec and assign/initialize generic parser ops */
+static int alloc_generic_hdmi(struct hda_codec *codec)
+{
+       struct hdmi_spec *spec;
+
+       spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
+               return -ENOMEM;
+
+       spec->ops = generic_standard_hdmi_ops;
+       mutex_init(&spec->pcm_lock);
+       snd_hdac_register_chmap_ops(&codec->core, &spec->chmap);
+
+       spec->chmap.ops.get_chmap = hdmi_get_chmap;
+       spec->chmap.ops.set_chmap = hdmi_set_chmap;
+       spec->chmap.ops.is_pcm_attached = is_hdmi_pcm_attached;
+       spec->chmap.ops.get_spk_alloc = hdmi_get_spk_alloc,
+
+       codec->spec = spec;
+       hdmi_array_init(spec, 4);
+
+       codec->patch_ops = generic_hdmi_patch_ops;
+
+       return 0;
+}
+
+/* generic HDMI parser */
+static int patch_generic_hdmi(struct hda_codec *codec)
+{
+       int err;
+
+       err = alloc_generic_hdmi(codec);
+       if (err < 0)
+               return err;
+
+       err = hdmi_parse_codec(codec);
+       if (err < 0) {
+               generic_spec_free(codec);
+               return err;
+       }
+
+       generic_hdmi_init_per_pins(codec);
+       return 0;
+}
+
+/*
+ * Intel codec parsers and helpers
+ */
+
 static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
                                             hda_nid_t nid)
 {
@@ -2217,12 +2288,23 @@ static void haswell_set_power_state(struct hda_codec *codec, hda_nid_t fg,
 static void intel_pin_eld_notify(void *audio_ptr, int port)
 {
        struct hda_codec *codec = audio_ptr;
-       int pin_nid = port + 0x04;
+       int pin_nid;
 
        /* we assume only from port-B to port-D */
        if (port < 1 || port > 3)
                return;
 
+       switch (codec->core.vendor_id) {
+       case 0x80860054: /* ILK */
+       case 0x80862804: /* ILK */
+       case 0x80862882: /* VLV */
+               pin_nid = port + 0x03;
+               break;
+       default:
+               pin_nid = port + 0x04;
+               break;
+       }
+
        /* skip notification during system suspend (but not in runtime PM);
         * the state will be updated at resume
         */
@@ -2236,93 +2318,159 @@ static void intel_pin_eld_notify(void *audio_ptr, int port)
        check_presence_and_report(codec, pin_nid);
 }
 
-static int patch_generic_hdmi(struct hda_codec *codec)
+/* register i915 component pin_eld_notify callback */
+static void register_i915_notifier(struct hda_codec *codec)
 {
-       struct hdmi_spec *spec;
+       struct hdmi_spec *spec = codec->spec;
 
-       spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-       if (spec == NULL)
-               return -ENOMEM;
+       spec->use_acomp_notifier = true;
+       spec->i915_audio_ops.audio_ptr = codec;
+       /* intel_audio_codec_enable() or intel_audio_codec_disable()
+        * will call pin_eld_notify with using audio_ptr pointer
+        * We need make sure audio_ptr is really setup
+        */
+       wmb();
+       spec->i915_audio_ops.pin_eld_notify = intel_pin_eld_notify;
+       snd_hdac_i915_register_notifier(&spec->i915_audio_ops);
+}
 
-       spec->ops = generic_standard_hdmi_ops;
-       mutex_init(&spec->pcm_lock);
-       snd_hdac_register_chmap_ops(&codec->core, &spec->chmap);
+/* setup_stream ops override for HSW+ */
+static int i915_hsw_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
+                                hda_nid_t pin_nid, u32 stream_tag, int format)
+{
+       haswell_verify_D0(codec, cvt_nid, pin_nid);
+       return hdmi_setup_stream(codec, cvt_nid, pin_nid, stream_tag, format);
+}
 
-       spec->chmap.ops.get_chmap = hdmi_get_chmap;
-       spec->chmap.ops.set_chmap = hdmi_set_chmap;
-       spec->chmap.ops.is_pcm_attached = is_hdmi_pcm_attached;
+/* pin_cvt_fixup ops override for HSW+ and VLV+ */
+static void i915_pin_cvt_fixup(struct hda_codec *codec,
+                              struct hdmi_spec_per_pin *per_pin,
+                              hda_nid_t cvt_nid)
+{
+       if (per_pin) {
+               intel_verify_pin_cvt_connect(codec, per_pin);
+               intel_not_share_assigned_cvt(codec, per_pin->pin_nid,
+                                            per_pin->mux_idx);
+       } else {
+               intel_not_share_assigned_cvt_nid(codec, 0, cvt_nid);
+       }
+}
 
-       codec->spec = spec;
-       hdmi_array_init(spec, 4);
+/* Intel Haswell and onwards; audio component with eld notifier */
+static int patch_i915_hsw_hdmi(struct hda_codec *codec)
+{
+       struct hdmi_spec *spec;
+       int err;
 
-#ifdef CONFIG_SND_HDA_I915
-       /* Try to bind with i915 for Intel HSW+ codecs (if not done yet) */
-       if ((codec->core.vendor_id >> 16) == 0x8086 &&
-           is_haswell_plus(codec)) {
-#if 0
-               /* on-demand binding leads to an unbalanced refcount when
-                * both i915 and hda drivers are probed concurrently;
-                * disabled temporarily for now
-                */
-               if (!codec->bus->core.audio_component)
-                       if (!snd_hdac_i915_init(&codec->bus->core))
-                               spec->i915_bound = true;
-#endif
-               /* use i915 audio component notifier for hotplug */
-               if (codec->bus->core.audio_component)
-                       spec->use_acomp_notifier = true;
+       /* HSW+ requires i915 binding */
+       if (!codec->bus->core.audio_component) {
+               codec_info(codec, "No i915 binding for Intel HDMI/DP codec\n");
+               return -ENODEV;
        }
-#endif
 
-       if (is_haswell_plus(codec)) {
-               intel_haswell_enable_all_pins(codec, true);
-               intel_haswell_fixup_enable_dp12(codec);
-       }
+       err = alloc_generic_hdmi(codec);
+       if (err < 0)
+               return err;
+       spec = codec->spec;
 
-       /* For Valleyview/Cherryview, only the display codec is in the display
-        * power well and can use link_power ops to request/release the power.
-        * For Haswell/Broadwell, the controller is also in the power well and
+       intel_haswell_enable_all_pins(codec, true);
+       intel_haswell_fixup_enable_dp12(codec);
+
+       /* For Haswell/Broadwell, the controller is also in the power well and
         * can cover the codec power request, and so need not set this flag.
-        * For previous platforms, there is no such power well feature.
         */
-       if (is_valleyview_plus(codec) || is_skylake(codec) ||
-                       is_broxton(codec))
+       if (!is_haswell(codec) && !is_broadwell(codec))
                codec->core.link_power_control = 1;
 
-       if (hdmi_parse_codec(codec) < 0) {
-               if (spec->i915_bound)
-                       snd_hdac_i915_exit(&codec->bus->core);
-               codec->spec = NULL;
-               kfree(spec);
-               return -EINVAL;
+       codec->patch_ops.set_power_state = haswell_set_power_state;
+       codec->dp_mst = true;
+       codec->depop_delay = 0;
+       codec->auto_runtime_pm = 1;
+
+       spec->ops.setup_stream = i915_hsw_setup_stream;
+       spec->ops.pin_cvt_fixup = i915_pin_cvt_fixup;
+
+       err = hdmi_parse_codec(codec);
+       if (err < 0) {
+               generic_spec_free(codec);
+               return err;
        }
-       codec->patch_ops = generic_hdmi_patch_ops;
-       if (is_haswell_plus(codec)) {
-               codec->patch_ops.set_power_state = haswell_set_power_state;
-               codec->dp_mst = true;
+
+       generic_hdmi_init_per_pins(codec);
+       register_i915_notifier(codec);
+       return 0;
+}
+
+/* Intel Baytrail and Braswell; with eld notifier */
+static int patch_i915_byt_hdmi(struct hda_codec *codec)
+{
+       struct hdmi_spec *spec;
+       int err;
+
+       /* requires i915 binding */
+       if (!codec->bus->core.audio_component) {
+               codec_info(codec, "No i915 binding for Intel HDMI/DP codec\n");
+               return -ENODEV;
        }
 
-       /* Enable runtime pm for HDMI audio codec of HSW/BDW/SKL/BYT/BSW */
-       if (is_haswell_plus(codec) || is_valleyview_plus(codec))
-               codec->auto_runtime_pm = 1;
+       err = alloc_generic_hdmi(codec);
+       if (err < 0)
+               return err;
+       spec = codec->spec;
 
-       generic_hdmi_init_per_pins(codec);
+       /* For Valleyview/Cherryview, only the display codec is in the display
+        * power well and can use link_power ops to request/release the power.
+        */
+       codec->core.link_power_control = 1;
 
+       codec->depop_delay = 0;
+       codec->auto_runtime_pm = 1;
 
-       if (codec_has_acomp(codec)) {
-               codec->depop_delay = 0;
-               spec->i915_audio_ops.audio_ptr = codec;
-               /* intel_audio_codec_enable() or intel_audio_codec_disable()
-                * will call pin_eld_notify with using audio_ptr pointer
-                * We need make sure audio_ptr is really setup
-                */
-               wmb();
-               spec->i915_audio_ops.pin_eld_notify = intel_pin_eld_notify;
-               snd_hdac_i915_register_notifier(&spec->i915_audio_ops);
+       spec->ops.pin_cvt_fixup = i915_pin_cvt_fixup;
+
+       err = hdmi_parse_codec(codec);
+       if (err < 0) {
+               generic_spec_free(codec);
+               return err;
        }
 
-       WARN_ON(spec->dyn_pcm_assign && !codec_has_acomp(codec));
+       generic_hdmi_init_per_pins(codec);
+       register_i915_notifier(codec);
+       return 0;
+}
+
+/* Intel IronLake, SandyBridge and IvyBridge; with eld notifier */
+static int patch_i915_cpt_hdmi(struct hda_codec *codec)
+{
+       struct hdmi_spec *spec;
+       int err;
+
+       /* no i915 component should have been bound before this */
+       if (WARN_ON(codec->bus->core.audio_component))
+               return -EBUSY;
+
+       err = alloc_generic_hdmi(codec);
+       if (err < 0)
+               return err;
+       spec = codec->spec;
+
+       /* Try to bind with i915 now */
+       err = snd_hdac_i915_init(&codec->bus->core);
+       if (err < 0)
+               goto error;
+       spec->i915_bound = true;
+
+       err = hdmi_parse_codec(codec);
+       if (err < 0)
+               goto error;
+
+       generic_hdmi_init_per_pins(codec);
+       register_i915_notifier(codec);
        return 0;
+
+ error:
+       generic_spec_free(codec);
+       return err;
 }
 
 /*
@@ -3492,21 +3640,21 @@ HDA_CODEC_ENTRY(0x11069f80, "VX900 HDMI/DP",    patch_via_hdmi),
 HDA_CODEC_ENTRY(0x11069f81, "VX900 HDMI/DP",   patch_via_hdmi),
 HDA_CODEC_ENTRY(0x11069f84, "VX11 HDMI/DP",    patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x11069f85, "VX11 HDMI/DP",    patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80860054, "IbexPeak HDMI",   patch_generic_hdmi),
+HDA_CODEC_ENTRY(0x80860054, "IbexPeak HDMI",   patch_i915_cpt_hdmi),
 HDA_CODEC_ENTRY(0x80862801, "Bearlake HDMI",   patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862802, "Cantiga HDMI",    patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862803, "Eaglelake HDMI",  patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862804, "IbexPeak HDMI",   patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862805, "CougarPoint HDMI",        patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862806, "PantherPoint HDMI", patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862807, "Haswell HDMI",    patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862808, "Broadwell HDMI",  patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862809, "Skylake HDMI",    patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x8086280a, "Broxton HDMI",    patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x8086280b, "Kabylake HDMI",   patch_generic_hdmi),
+HDA_CODEC_ENTRY(0x80862804, "IbexPeak HDMI",   patch_i915_cpt_hdmi),
+HDA_CODEC_ENTRY(0x80862805, "CougarPoint HDMI",        patch_i915_cpt_hdmi),
+HDA_CODEC_ENTRY(0x80862806, "PantherPoint HDMI", patch_i915_cpt_hdmi),
+HDA_CODEC_ENTRY(0x80862807, "Haswell HDMI",    patch_i915_hsw_hdmi),
+HDA_CODEC_ENTRY(0x80862808, "Broadwell HDMI",  patch_i915_hsw_hdmi),
+HDA_CODEC_ENTRY(0x80862809, "Skylake HDMI",    patch_i915_hsw_hdmi),
+HDA_CODEC_ENTRY(0x8086280a, "Broxton HDMI",    patch_i915_hsw_hdmi),
+HDA_CODEC_ENTRY(0x8086280b, "Kabylake HDMI",   patch_i915_hsw_hdmi),
 HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI", patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI",        patch_generic_hdmi),
-HDA_CODEC_ENTRY(0x80862883, "Braswell HDMI",   patch_generic_hdmi),
+HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI",        patch_i915_byt_hdmi),
+HDA_CODEC_ENTRY(0x80862883, "Braswell HDMI",   patch_i915_byt_hdmi),
 HDA_CODEC_ENTRY(0x808629fb, "Crestline HDMI",  patch_generic_hdmi),
 /* special ID for generic HDMI */
 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC_HDMI, "Generic HDMI", patch_generic_hdmi),
index 4918ffa5ba6829e102519b3a7af700b049d93ae2..002f153bc65948e2a5bd46c484acbfba42d5b875 100644 (file)
@@ -342,6 +342,11 @@ static void alc_fill_eapd_coef(struct hda_codec *codec)
        case 0x10ec0293:
                alc_update_coef_idx(codec, 0xa, 1<<13, 0);
                break;
+       case 0x10ec0234:
+       case 0x10ec0274:
+       case 0x10ec0294:
+               alc_update_coef_idx(codec, 0x10, 1<<15, 0);
+               break;
        case 0x10ec0662:
                if ((coef & 0x00f0) == 0x0030)
                        alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
@@ -2647,6 +2652,7 @@ enum {
        ALC269_TYPE_ALC255,
        ALC269_TYPE_ALC256,
        ALC269_TYPE_ALC225,
+       ALC269_TYPE_ALC294,
 };
 
 /*
@@ -2677,6 +2683,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
        case ALC269_TYPE_ALC255:
        case ALC269_TYPE_ALC256:
        case ALC269_TYPE_ALC225:
+       case ALC269_TYPE_ALC294:
                ssids = alc269_ssids;
                break;
        default:
@@ -6028,6 +6035,11 @@ static int patch_alc269(struct hda_codec *codec)
        case 0x10ec0225:
                spec->codec_variant = ALC269_TYPE_ALC225;
                break;
+       case 0x10ec0234:
+       case 0x10ec0274:
+       case 0x10ec0294:
+               spec->codec_variant = ALC269_TYPE_ALC294;
+               break;
        }
 
        if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
@@ -6942,6 +6954,7 @@ static const struct hda_device_id snd_hda_id_realtek[] = {
        HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
+       HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
@@ -6952,6 +6965,7 @@ static const struct hda_device_id snd_hda_id_realtek[] = {
        HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
+       HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
@@ -6964,6 +6978,7 @@ static const struct hda_device_id snd_hda_id_realtek[] = {
        HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
+       HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
        HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
        HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
        HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
index 8151318a69a2fb65fa53f44f07233792338a2011..9720a30dbfff31fb412b385370647927e6ecef3a 100644 (file)
 #include <asm/pgtable.h>
 #include <asm/cacheflush.h>
 
-#ifdef CONFIG_KVM_GUEST
-#include <linux/kvm_para.h>
-#else
-#define kvm_para_available() (0)
-#endif
-
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("Intel 82801AA,82901AB,i810,i820,i830,i840,i845,MX440; SiS 7012; Ali 5455");
 MODULE_LICENSE("GPL");
@@ -2972,25 +2966,17 @@ static int snd_intel8x0_inside_vm(struct pci_dev *pci)
                goto fini;
        }
 
-       /* detect KVM and Parallels virtual environments */
-       result = kvm_para_available();
-#ifdef X86_FEATURE_HYPERVISOR
-       result = result || boot_cpu_has(X86_FEATURE_HYPERVISOR);
-#endif
-       if (!result)
-               goto fini;
-
        /* check for known (emulated) devices */
+       result = 0;
        if (pci->subsystem_vendor == PCI_SUBVENDOR_ID_REDHAT_QUMRANET &&
            pci->subsystem_device == PCI_SUBDEVICE_ID_QEMU) {
                /* KVM emulated sound, PCI SSID: 1af4:1100 */
                msg = "enable KVM";
+               result = 1;
        } else if (pci->subsystem_vendor == 0x1ab8) {
                /* Parallels VM emulated sound, PCI SSID: 1ab8:xxxx */
                msg = "enable Parallels VM";
-       } else {
-               msg = "disable (unknown or VT-d) VM";
-               result = 0;
+               result = 1;
        }
 
 fini:
index f3d62020ef66c95119461a8836a650f30071f39d..a80684bdc30d6ee3cdad09e6e99be4cef902b7c3 100644 (file)
@@ -644,7 +644,7 @@ static int lx_pipe_wait_for_state(struct lx6464es *chip, u32 pipe,
                if (err < 0)
                        return err;
 
-               if (current_state == state)
+               if (!err && current_state == state)
                        return 0;
 
                mdelay(1);
index 276897033639b0d719d0d4408e1ffb9ec9efe90d..1267e1af0fae420c694577b208c4643dcc3b41ad 100644 (file)
@@ -652,7 +652,7 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                rcmr =    SSC_BF(RCMR_PERIOD, ssc_p->rcmr_period)
                        | SSC_BF(RCMR_STTDLY, 1)
                        | SSC_BF(RCMR_START, SSC_START_RISING_RF)
-                       | SSC_BF(RCMR_CKI, SSC_CKI_FALLING)
+                       | SSC_BF(RCMR_CKI, SSC_CKI_RISING)
                        | SSC_BF(RCMR_CKO, SSC_CKO_NONE)
                        | SSC_BF(RCMR_CKS, SSC_CKS_DIV);
 
@@ -692,7 +692,7 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                rcmr =    SSC_BF(RCMR_PERIOD, 0)
                        | SSC_BF(RCMR_STTDLY, START_DELAY)
                        | SSC_BF(RCMR_START, SSC_START_RISING_RF)
-                       | SSC_BF(RCMR_CKI, SSC_CKI_FALLING)
+                       | SSC_BF(RCMR_CKI, SSC_CKI_RISING)
                        | SSC_BF(RCMR_CKO, SSC_CKO_NONE)
                        | SSC_BF(RCMR_CKS, ssc->clk_from_rk_pin ?
                                           SSC_CKS_PIN : SSC_CKS_CLOCK);
index 5741c0aa6c0303607cb738668ecaa2d023044354..b5d1caa04d8e77e275bfbfaaca2c9e6bd61a92ed 100644 (file)
@@ -206,8 +206,8 @@ static int au1xpsc_pcm_hw_params(struct snd_pcm_substream *substream,
        stype = substream->stream;
        pcd = to_dmadata(substream);
 
-       DBG("runtime->dma_area = 0x%08lx dma_addr_t = 0x%08lx dma_size = %d "
-           "runtime->min_align %d\n",
+       DBG("runtime->dma_area = 0x%08lx dma_addr_t = 0x%08lx dma_size = %zu "
+           "runtime->min_align %lu\n",
                (unsigned long)runtime->dma_area,
                (unsigned long)runtime->dma_addr, runtime->dma_bytes,
                runtime->min_align);
index 1c1f2210387b26e9551959378f6792f18648652e..6ba20498202ed36906b52096893a88867a79269f 100644 (file)
@@ -259,6 +259,9 @@ static int bcm2835_i2s_hw_params(struct snd_pcm_substream *substream,
        case SNDRV_PCM_FORMAT_S16_LE:
                data_length = 16;
                break;
+       case SNDRV_PCM_FORMAT_S24_LE:
+               data_length = 24;
+               break;
        case SNDRV_PCM_FORMAT_S32_LE:
                data_length = 32;
                break;
@@ -273,13 +276,20 @@ static int bcm2835_i2s_hw_params(struct snd_pcm_substream *substream,
                /* otherwise calculate a fitting block ratio */
                bclk_ratio = 2 * data_length;
 
-       /* set target clock rate*/
-       clk_set_rate(dev->clk, sampling_rate * bclk_ratio);
+       /* Clock should only be set up here if CPU is clock master */
+       switch (dev->fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+       case SND_SOC_DAIFMT_CBS_CFS:
+       case SND_SOC_DAIFMT_CBS_CFM:
+               clk_set_rate(dev->clk, sampling_rate * bclk_ratio);
+               break;
+       default:
+               break;
+       }
 
        /* Setup the frame format */
        format = BCM2835_I2S_CHEN;
 
-       if (data_length > 24)
+       if (data_length >= 24)
                format |= BCM2835_I2S_CHWEX;
 
        format |= BCM2835_I2S_CHWID((data_length-8)&0xf);
@@ -570,6 +580,7 @@ static struct snd_soc_dai_driver bcm2835_i2s_dai = {
                .channels_max = 2,
                .rates =        SNDRV_PCM_RATE_8000_192000,
                .formats =      SNDRV_PCM_FMTBIT_S16_LE
+                               | SNDRV_PCM_FMTBIT_S24_LE
                                | SNDRV_PCM_FMTBIT_S32_LE
                },
        .capture = {
@@ -577,6 +588,7 @@ static struct snd_soc_dai_driver bcm2835_i2s_dai = {
                .channels_max = 2,
                .rates =        SNDRV_PCM_RATE_8000_192000,
                .formats =      SNDRV_PCM_FMTBIT_S16_LE
+                               | SNDRV_PCM_FMTBIT_S24_LE
                                | SNDRV_PCM_FMTBIT_S32_LE
                },
        .ops = &bcm2835_i2s_dai_ops,
@@ -678,6 +690,15 @@ static int bcm2835_i2s_probe(struct platform_device *pdev)
        dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK].maxburst = 2;
        dev->dma_data[SNDRV_PCM_STREAM_CAPTURE].maxburst = 2;
 
+       /*
+        * Set the PACK flag to enable S16_LE support (2 S16_LE values
+        * packed into 32-bit transfers).
+        */
+       dev->dma_data[SNDRV_PCM_STREAM_PLAYBACK].flags =
+               SND_DMAENGINE_PCM_DAI_FLAG_PACK;
+       dev->dma_data[SNDRV_PCM_STREAM_CAPTURE].flags =
+               SND_DMAENGINE_PCM_DAI_FLAG_PACK;
+
        /* BCLK ratio - use default */
        dev->bclk_ratio = 0;
 
index 7ef3a0c16478d707b1ef843aecf0631a51813fb1..b3afae990e39633067b4050f0bee756a0aee128d 100644 (file)
@@ -88,12 +88,14 @@ config SND_SOC_ALL_CODECS
        select SND_SOC_MC13783 if MFD_MC13XXX
        select SND_SOC_ML26124 if I2C
        select SND_SOC_NAU8825 if I2C
+       select SND_SOC_HDMI_CODEC
        select SND_SOC_PCM1681 if I2C
        select SND_SOC_PCM179X_I2C if I2C
        select SND_SOC_PCM179X_SPI if SPI_MASTER
        select SND_SOC_PCM3008
        select SND_SOC_PCM3168A_I2C if I2C
        select SND_SOC_PCM3168A_SPI if SPI_MASTER
+       select SND_SOC_PCM5102A
        select SND_SOC_PCM512x_I2C if I2C
        select SND_SOC_PCM512x_SPI if SPI_MASTER
        select SND_SOC_RT286 if I2C
@@ -477,6 +479,11 @@ config SND_SOC_BT_SCO
 config SND_SOC_DMIC
        tristate
 
+config SND_SOC_HDMI_CODEC
+       tristate
+       select SND_PCM_ELD
+       select SND_PCM_IEC958
+
 config SND_SOC_ES8328
        tristate "Everest Semi ES8328 CODEC"
 
@@ -575,6 +582,9 @@ config SND_SOC_PCM3168A_SPI
        select SND_SOC_PCM3168A
        select REGMAP_SPI
 
+config SND_SOC_PCM5102A
+       tristate
+
 config SND_SOC_PCM512x
        tristate
 
index 185a712a7fe763bbba79fa1f4969cf5ba5424753..b7b99416537fd9016360e8b78676d0ea401d0ae6 100644 (file)
@@ -81,6 +81,7 @@ snd-soc-max9850-objs := max9850.o
 snd-soc-mc13783-objs := mc13783.o
 snd-soc-ml26124-objs := ml26124.o
 snd-soc-nau8825-objs := nau8825.o
+snd-soc-hdmi-codec-objs := hdmi-codec.o
 snd-soc-pcm1681-objs := pcm1681.o
 snd-soc-pcm179x-codec-objs := pcm179x.o
 snd-soc-pcm179x-i2c-objs := pcm179x-i2c.o
@@ -89,6 +90,7 @@ snd-soc-pcm3008-objs := pcm3008.o
 snd-soc-pcm3168a-objs := pcm3168a.o
 snd-soc-pcm3168a-i2c-objs := pcm3168a-i2c.o
 snd-soc-pcm3168a-spi-objs := pcm3168a-spi.o
+snd-soc-pcm5102a-objs := pcm5102a.o
 snd-soc-pcm512x-objs := pcm512x.o
 snd-soc-pcm512x-i2c-objs := pcm512x-i2c.o
 snd-soc-pcm512x-spi-objs := pcm512x-spi.o
@@ -290,6 +292,7 @@ obj-$(CONFIG_SND_SOC_MAX9850)       += snd-soc-max9850.o
 obj-$(CONFIG_SND_SOC_MC13783)  += snd-soc-mc13783.o
 obj-$(CONFIG_SND_SOC_ML26124)  += snd-soc-ml26124.o
 obj-$(CONFIG_SND_SOC_NAU8825)   += snd-soc-nau8825.o
+obj-$(CONFIG_SND_SOC_HDMI_CODEC)       += snd-soc-hdmi-codec.o
 obj-$(CONFIG_SND_SOC_PCM1681)  += snd-soc-pcm1681.o
 obj-$(CONFIG_SND_SOC_PCM179X)  += snd-soc-pcm179x-codec.o
 obj-$(CONFIG_SND_SOC_PCM179X_I2C)      += snd-soc-pcm179x-i2c.o
@@ -298,6 +301,7 @@ obj-$(CONFIG_SND_SOC_PCM3008)       += snd-soc-pcm3008.o
 obj-$(CONFIG_SND_SOC_PCM3168A) += snd-soc-pcm3168a.o
 obj-$(CONFIG_SND_SOC_PCM3168A_I2C)     += snd-soc-pcm3168a-i2c.o
 obj-$(CONFIG_SND_SOC_PCM3168A_SPI)     += snd-soc-pcm3168a-spi.o
+obj-$(CONFIG_SND_SOC_PCM5102A) += snd-soc-pcm5102a.o
 obj-$(CONFIG_SND_SOC_PCM512x)  += snd-soc-pcm512x.o
 obj-$(CONFIG_SND_SOC_PCM512x_I2C)      += snd-soc-pcm512x-i2c.o
 obj-$(CONFIG_SND_SOC_PCM512x_SPI)      += snd-soc-pcm512x-spi.o
index cda27c22812a71442dd3d927088c2118aa16dc17..1ee8506c06c75705ab643dc4f8ef6b04b9b55e64 100644 (file)
@@ -608,9 +608,7 @@ static struct clk *ak4642_of_parse_mcko(struct device *dev)
 
        of_property_read_string(np, "clock-output-names", &clk_name);
 
-       clk = clk_register_fixed_rate(dev, clk_name, parent_clk_name,
-                                     (parent_clk_name) ? 0 : CLK_IS_ROOT,
-                                     rate);
+       clk = clk_register_fixed_rate(dev, clk_name, parent_clk_name, 0, rate);
        if (!IS_ERR(clk))
                of_clk_add_provider(np, of_clk_src_simple_get, clk);
 
index 83959312f7a0f5d5e1fcee33385fd1cba0e4db6f..664a8c044ffb1c3abd58afe458ba538a775d9a47 100644 (file)
@@ -221,6 +221,8 @@ int arizona_init_spk(struct snd_soc_codec *codec)
 
        switch (arizona->type) {
        case WM8997:
+       case CS47L24:
+       case WM1831:
                break;
        default:
                ret = snd_soc_dapm_new_controls(dapm, &arizona_spkr, 1);
@@ -1134,7 +1136,6 @@ int arizona_anc_ev(struct snd_soc_dapm_widget *w,
                   int event)
 {
        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
-       unsigned int mask = 0x3 << w->shift;
        unsigned int val;
 
        switch (event) {
@@ -1148,7 +1149,7 @@ int arizona_anc_ev(struct snd_soc_dapm_widget *w,
                return 0;
        }
 
-       snd_soc_update_bits(codec, ARIZONA_CLOCK_CONTROL, mask, val);
+       snd_soc_write(codec, ARIZONA_CLOCK_CONTROL, val);
 
        return 0;
 }
@@ -2047,7 +2048,21 @@ static int arizona_calc_fratio(struct arizona_fll *fll,
                        init_ratio, Fref, refdiv);
 
        while (div <= ARIZONA_FLL_MAX_REFDIV) {
-               for (ratio = init_ratio; ratio <= ARIZONA_FLL_MAX_FRATIO;
+               /* start from init_ratio because this may already give a
+                * fractional N.K
+                */
+               for (ratio = init_ratio; ratio > 0; ratio--) {
+                       if (target % (ratio * Fref)) {
+                               cfg->refdiv = refdiv;
+                               cfg->fratio = ratio - 1;
+                               arizona_fll_dbg(fll,
+                                       "pseudo: found fref=%u refdiv=%d(%d) ratio=%d\n",
+                                       Fref, refdiv, div, ratio);
+                               return ratio;
+                       }
+               }
+
+               for (ratio = init_ratio + 1; ratio <= ARIZONA_FLL_MAX_FRATIO;
                     ratio++) {
                        if ((ARIZONA_FLL_VCO_CORNER / 2) /
                            (fll->vco_mult * ratio) < Fref) {
@@ -2073,17 +2088,6 @@ static int arizona_calc_fratio(struct arizona_fll *fll,
                        }
                }
 
-               for (ratio = init_ratio - 1; ratio > 0; ratio--) {
-                       if (target % (ratio * Fref)) {
-                               cfg->refdiv = refdiv;
-                               cfg->fratio = ratio - 1;
-                               arizona_fll_dbg(fll,
-                                       "pseudo: found fref=%u refdiv=%d(%d) ratio=%d\n",
-                                       Fref, refdiv, div, ratio);
-                               return ratio;
-                       }
-               }
-
                div *= 2;
                Fref /= 2;
                refdiv++;
index 7cd5f769bb614d207daaf26ca24efb51156d3aca..eec1ff853b98bdc1ca7c2390a9cd50ec44edbf2c 100644 (file)
@@ -56,7 +56,7 @@ struct  cs42l56_private {
        u8 iface;
        u8 iface_fmt;
        u8 iface_inv;
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
        struct input_dev *beep;
        struct work_struct beep_work;
        int beep_rate;
index 00e9b6fc1b5cab0ddf8b4c3d945a3b2ab27dc749..5ec5a682d186971daa09d532d0b4627806eecaa3 100644 (file)
@@ -807,6 +807,9 @@ static const struct snd_soc_dapm_route cs47l24_dapm_routes[] = {
        { "IN2L PGA", NULL, "IN2L" },
        { "IN2R PGA", NULL, "IN2R" },
 
+       { "Audio Trace DSP", NULL, "DSP2" },
+       { "Audio Trace DSP", NULL, "SYSCLK" },
+
        ARIZONA_MIXER_ROUTES("OUT1L", "HPOUT1L"),
        ARIZONA_MIXER_ROUTES("OUT1R", "HPOUT1R"),
 
@@ -1016,6 +1019,27 @@ static struct snd_soc_dai_driver cs47l24_dai[] = {
                        .formats = CS47L24_FORMATS,
                },
        },
+       {
+               .name = "cs47l24-cpu-trace",
+               .capture = {
+                       .stream_name = "Audio Trace CPU",
+                       .channels_min = 1,
+                       .channels_max = 6,
+                       .rates = CS47L24_RATES,
+                       .formats = CS47L24_FORMATS,
+               },
+               .compress_new = snd_soc_new_compress,
+       },
+       {
+               .name = "cs47l24-dsp-trace",
+               .capture = {
+                       .stream_name = "Audio Trace DSP",
+                       .channels_min = 1,
+                       .channels_max = 6,
+                       .rates = CS47L24_RATES,
+                       .formats = CS47L24_FORMATS,
+               },
+       },
 };
 
 static int cs47l24_open(struct snd_compr_stream *stream)
@@ -1027,6 +1051,8 @@ static int cs47l24_open(struct snd_compr_stream *stream)
 
        if (strcmp(rtd->codec_dai->name, "cs47l24-dsp-voicectrl") == 0) {
                n_adsp = 2;
+       } else if (strcmp(rtd->codec_dai->name, "cs47l24-dsp-trace") == 0) {
+               n_adsp = 1;
        } else {
                dev_err(arizona->dev,
                        "No suitable compressed stream for DAI '%s'\n",
@@ -1041,10 +1067,16 @@ static irqreturn_t cs47l24_adsp2_irq(int irq, void *data)
 {
        struct cs47l24_priv *priv = data;
        struct arizona *arizona = priv->core.arizona;
-       int ret;
+       int serviced = 0;
+       int i, ret;
 
-       ret = wm_adsp_compr_handle_irq(&priv->core.adsp[2]);
-       if (ret == -ENODEV) {
+       for (i = 1; i <= 2; ++i) {
+               ret = wm_adsp_compr_handle_irq(&priv->core.adsp[i]);
+               if (ret != -ENODEV)
+                       serviced++;
+       }
+
+       if (!serviced) {
                dev_err(arizona->dev, "Spurious compressed data IRQ\n");
                return IRQ_NONE;
        }
@@ -1160,6 +1192,7 @@ static struct snd_compr_ops cs47l24_compr_ops = {
 static struct snd_soc_platform_driver cs47l24_compr_platform = {
        .compr_ops = &cs47l24_compr_ops,
 };
+
 static int cs47l24_probe(struct platform_device *pdev)
 {
        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
@@ -1228,9 +1261,9 @@ static int cs47l24_probe(struct platform_device *pdev)
                dev_err(&pdev->dev, "Failed to register platform: %d\n", ret);
                return ret;
        }
+
        ret = snd_soc_register_codec(&pdev->dev, &soc_codec_dev_cs47l24,
                                      cs47l24_dai, ARRAY_SIZE(cs47l24_dai));
-
        if (ret < 0) {
                dev_err(&pdev->dev, "Failed to register codec: %d\n", ret);
                snd_soc_unregister_platform(&pdev->dev);
@@ -1241,10 +1274,15 @@ static int cs47l24_probe(struct platform_device *pdev)
 
 static int cs47l24_remove(struct platform_device *pdev)
 {
+       struct cs47l24_priv *cs47l24 = platform_get_drvdata(pdev);
+
        snd_soc_unregister_platform(&pdev->dev);
        snd_soc_unregister_codec(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
 
+       wm_adsp2_remove(&cs47l24->core.adsp[1]);
+       wm_adsp2_remove(&cs47l24->core.adsp[2]);
+
        return 0;
 }
 
index 7278f93460c1ee1f5eb48fafaf2f95d0aa406c62..e5527bc570ae550394807f8062092af3e8f0a6e1 100644 (file)
@@ -725,6 +725,68 @@ static const struct snd_kcontrol_new da7213_dapm_mixoutr_controls[] = {
 };
 
 
+/*
+ * DAPM Events
+ */
+
+static int da7213_dai_event(struct snd_soc_dapm_widget *w,
+                           struct snd_kcontrol *kcontrol, int event)
+{
+       struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+       struct da7213_priv *da7213 = snd_soc_codec_get_drvdata(codec);
+       u8 pll_ctrl, pll_status;
+       int i = 0;
+       bool srm_lock = false;
+
+       switch (event) {
+       case SND_SOC_DAPM_PRE_PMU:
+               /* Enable DAI clks for master mode */
+               if (da7213->master)
+                       snd_soc_update_bits(codec, DA7213_DAI_CLK_MODE,
+                                           DA7213_DAI_CLK_EN_MASK,
+                                           DA7213_DAI_CLK_EN_MASK);
+
+               /* PC synchronised to DAI */
+               snd_soc_update_bits(codec, DA7213_PC_COUNT,
+                                   DA7213_PC_FREERUN_MASK, 0);
+
+               /* Slave mode, if SRM not enabled no need for status checks */
+               pll_ctrl = snd_soc_read(codec, DA7213_PLL_CTRL);
+               if (!(pll_ctrl & DA7213_PLL_SRM_EN))
+                       return 0;
+
+               /* Check SRM has locked */
+               do {
+                       pll_status = snd_soc_read(codec, DA7213_PLL_STATUS);
+                       if (pll_status & DA7219_PLL_SRM_LOCK) {
+                               srm_lock = true;
+                       } else {
+                               ++i;
+                               msleep(50);
+                       }
+               } while ((i < DA7213_SRM_CHECK_RETRIES) & (!srm_lock));
+
+               if (!srm_lock)
+                       dev_warn(codec->dev, "SRM failed to lock\n");
+
+               return 0;
+       case SND_SOC_DAPM_POST_PMD:
+               /* PC free-running */
+               snd_soc_update_bits(codec, DA7213_PC_COUNT,
+                                   DA7213_PC_FREERUN_MASK,
+                                   DA7213_PC_FREERUN_MASK);
+
+               /* Disable DAI clks if in master mode */
+               if (da7213->master)
+                       snd_soc_update_bits(codec, DA7213_DAI_CLK_MODE,
+                                           DA7213_DAI_CLK_EN_MASK, 0);
+               return 0;
+       default:
+               return -EINVAL;
+       }
+}
+
+
 /*
  * DAPM widgets
  */
@@ -736,7 +798,8 @@ static const struct snd_soc_dapm_widget da7213_dapm_widgets[] = {
 
        /* Use a supply here as this controls both input & output DAIs */
        SND_SOC_DAPM_SUPPLY("DAI", DA7213_DAI_CTRL, DA7213_DAI_EN_SHIFT,
-                           DA7213_NO_INVERT, NULL, 0),
+                           DA7213_NO_INVERT, da7213_dai_event,
+                           SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 
        /*
         * Input
@@ -1143,11 +1206,9 @@ static int da7213_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
        /* Set master/slave mode */
        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
        case SND_SOC_DAIFMT_CBM_CFM:
-               dai_clk_mode |= DA7213_DAI_CLK_EN_MASTER_MODE;
                da7213->master = true;
                break;
        case SND_SOC_DAIFMT_CBS_CFS:
-               dai_clk_mode |= DA7213_DAI_CLK_EN_SLAVE_MODE;
                da7213->master = false;
                break;
        default:
@@ -1281,28 +1342,28 @@ static int da7213_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
        pll_ctrl = 0;
 
        /* Workout input divider based on MCLK rate */
-       if ((da7213->mclk_rate == 32768) && (source == DA7213_SYSCLK_PLL)) {
+       if (da7213->mclk_rate == 32768) {
                /* 32KHz PLL Mode */
-               indiv_bits = DA7213_PLL_INDIV_10_20_MHZ;
-               indiv = DA7213_PLL_INDIV_10_20_MHZ_VAL;
+               indiv_bits = DA7213_PLL_INDIV_9_TO_18_MHZ;
+               indiv = DA7213_PLL_INDIV_9_TO_18_MHZ_VAL;
                freq_ref = 3750000;
                pll_ctrl |= DA7213_PLL_32K_MODE;
        } else {
                /* 5 - 54MHz MCLK */
                if (da7213->mclk_rate < 5000000) {
                        goto pll_err;
-               } else if (da7213->mclk_rate <= 10000000) {
-                       indiv_bits = DA7213_PLL_INDIV_5_10_MHZ;
-                       indiv = DA7213_PLL_INDIV_5_10_MHZ_VAL;
-               } else if (da7213->mclk_rate <= 20000000) {
-                       indiv_bits = DA7213_PLL_INDIV_10_20_MHZ;
-                       indiv = DA7213_PLL_INDIV_10_20_MHZ_VAL;
-               } else if (da7213->mclk_rate <= 40000000) {
-                       indiv_bits = DA7213_PLL_INDIV_20_40_MHZ;
-                       indiv = DA7213_PLL_INDIV_20_40_MHZ_VAL;
+               } else if (da7213->mclk_rate <= 9000000) {
+                       indiv_bits = DA7213_PLL_INDIV_5_TO_9_MHZ;
+                       indiv = DA7213_PLL_INDIV_5_TO_9_MHZ_VAL;
+               } else if (da7213->mclk_rate <= 18000000) {
+                       indiv_bits = DA7213_PLL_INDIV_9_TO_18_MHZ;
+                       indiv = DA7213_PLL_INDIV_9_TO_18_MHZ_VAL;
+               } else if (da7213->mclk_rate <= 36000000) {
+                       indiv_bits = DA7213_PLL_INDIV_18_TO_36_MHZ;
+                       indiv = DA7213_PLL_INDIV_18_TO_36_MHZ_VAL;
                } else if (da7213->mclk_rate <= 54000000) {
-                       indiv_bits = DA7213_PLL_INDIV_40_54_MHZ;
-                       indiv = DA7213_PLL_INDIV_40_54_MHZ_VAL;
+                       indiv_bits = DA7213_PLL_INDIV_36_TO_54_MHZ;
+                       indiv = DA7213_PLL_INDIV_36_TO_54_MHZ_VAL;
                } else {
                        goto pll_err;
                }
@@ -1547,6 +1608,10 @@ static int da7213_probe(struct snd_soc_codec *codec)
        /* Default to using SRM for slave mode */
        da7213->srm_en = true;
 
+       /* Default PC counter to free-running */
+       snd_soc_update_bits(codec, DA7213_PC_COUNT, DA7213_PC_FREERUN_MASK,
+                           DA7213_PC_FREERUN_MASK);
+
        /* Enable all Gain Ramps */
        snd_soc_update_bits(codec, DA7213_AUX_L_CTRL,
                            DA7213_GAIN_RAMP_EN, DA7213_GAIN_RAMP_EN);
index 030fd691b07626ab599fe53bd0b3a1903268b94b..fbb7a356a5016d95c65f5fb8675751b40ac725ff 100644 (file)
  * Bit fields
  */
 
+/* DA7213_PLL_STATUS = 0x03 */
+#define DA7219_PLL_SRM_LOCK                                    (0x1 << 1)
+
 /* DA7213_SR = 0x22 */
 #define DA7213_SR_8000                                         (0x1 << 0)
 #define DA7213_SR_11025                                                (0x2 << 0)
 #define DA7213_VMID_EN                                         (0x1 << 7)
 
 /* DA7213_PLL_CTRL = 0x27 */
-#define DA7213_PLL_INDIV_5_10_MHZ                              (0x0 << 2)
-#define DA7213_PLL_INDIV_10_20_MHZ                             (0x1 << 2)
-#define DA7213_PLL_INDIV_20_40_MHZ                             (0x2 << 2)
-#define DA7213_PLL_INDIV_40_54_MHZ                             (0x3 << 2)
+#define DA7213_PLL_INDIV_5_TO_9_MHZ                            (0x0 << 2)
+#define DA7213_PLL_INDIV_9_TO_18_MHZ                           (0x1 << 2)
+#define DA7213_PLL_INDIV_18_TO_36_MHZ                          (0x2 << 2)
+#define DA7213_PLL_INDIV_36_TO_54_MHZ                          (0x3 << 2)
 #define DA7213_PLL_INDIV_MASK                                  (0x3 << 2)
 #define DA7213_PLL_MCLK_SQR_EN                                 (0x1 << 4)
 #define DA7213_PLL_32K_MODE                                    (0x1 << 5)
 #define DA7213_DAI_BCLKS_PER_WCLK_MASK                         (0x3 << 0)
 #define DA7213_DAI_CLK_POL_INV                                 (0x1 << 2)
 #define DA7213_DAI_WCLK_POL_INV                                        (0x1 << 3)
-#define DA7213_DAI_CLK_EN_SLAVE_MODE                           (0x0 << 7)
-#define DA7213_DAI_CLK_EN_MASTER_MODE                          (0x1 << 7)
 #define DA7213_DAI_CLK_EN_MASK                                 (0x1 << 7)
 
 /* DA7213_DAI_CTRL = 0x29 */
 #define DA7213_DMIC_CLK_RATE_SHIFT                             2
 #define DA7213_DMIC_CLK_RATE_MASK                              (0x1 << 2)
 
+/* DA7213_PC_COUNT = 0x94 */
+#define DA7213_PC_FREERUN_MASK                                 (0x1 << 0)
+
 /* DA7213_DIG_CTRL = 0x99 */
 #define DA7213_DAC_L_INV_SHIFT                                 3
 #define DA7213_DAC_R_INV_SHIFT                                 7
 #define DA7213_ALC_AVG_ITERATIONS      5
 
 /* PLL related */
-#define DA7213_SYSCLK_MCLK             0
-#define DA7213_SYSCLK_PLL              1
-#define DA7213_PLL_FREQ_OUT_90316800   90316800
-#define DA7213_PLL_FREQ_OUT_98304000   98304000
-#define DA7213_PLL_FREQ_OUT_94310400   94310400
-#define DA7213_PLL_INDIV_5_10_MHZ_VAL  2
-#define DA7213_PLL_INDIV_10_20_MHZ_VAL 4
-#define DA7213_PLL_INDIV_20_40_MHZ_VAL 8
-#define DA7213_PLL_INDIV_40_54_MHZ_VAL 16
+#define DA7213_SYSCLK_MCLK                     0
+#define DA7213_SYSCLK_PLL                      1
+#define DA7213_PLL_FREQ_OUT_90316800           90316800
+#define DA7213_PLL_FREQ_OUT_98304000           98304000
+#define DA7213_PLL_FREQ_OUT_94310400           94310400
+#define DA7213_PLL_INDIV_5_TO_9_MHZ_VAL                2
+#define DA7213_PLL_INDIV_9_TO_18_MHZ_VAL       4
+#define DA7213_PLL_INDIV_18_TO_36_MHZ_VAL      8
+#define DA7213_PLL_INDIV_36_TO_54_MHZ_VAL      16
+#define DA7213_SRM_CHECK_RETRIES               8
 
 enum da7213_clk_src {
        DA7213_CLKSRC_MCLK = 0,
index 93575f25186687f7fe21f5c6d514165c6cd27140..99ce23e113bf74804e671642e5d836a8ea273157 100644 (file)
@@ -1868,27 +1868,27 @@ static int da7218_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
 
        /* Verify 32KHz, 2MHz - 54MHz MCLK provided, and set input divider */
        if (da7218->mclk_rate == 32768) {
-               indiv_bits = DA7218_PLL_INDIV_2_5_MHZ;
-               indiv = DA7218_PLL_INDIV_2_10_MHZ_VAL;
+               indiv_bits = DA7218_PLL_INDIV_9_TO_18_MHZ;
+               indiv = DA7218_PLL_INDIV_9_TO_18_MHZ_VAL;
        } else if (da7218->mclk_rate < 2000000) {
                dev_err(codec->dev, "PLL input clock %d below valid range\n",
                        da7218->mclk_rate);
                return -EINVAL;
-       } else if (da7218->mclk_rate <= 5000000) {
-               indiv_bits = DA7218_PLL_INDIV_2_5_MHZ;
-               indiv = DA7218_PLL_INDIV_2_10_MHZ_VAL;
-       } else if (da7218->mclk_rate <= 10000000) {
-               indiv_bits = DA7218_PLL_INDIV_5_10_MHZ;
-               indiv = DA7218_PLL_INDIV_2_10_MHZ_VAL;
-       } else if (da7218->mclk_rate <= 20000000) {
-               indiv_bits = DA7218_PLL_INDIV_10_20_MHZ;
-               indiv = DA7218_PLL_INDIV_10_20_MHZ_VAL;
-       } else if (da7218->mclk_rate <= 40000000) {
-               indiv_bits = DA7218_PLL_INDIV_20_40_MHZ;
-               indiv = DA7218_PLL_INDIV_20_40_MHZ_VAL;
+       } else if (da7218->mclk_rate <= 4500000) {
+               indiv_bits = DA7218_PLL_INDIV_2_TO_4_5_MHZ;
+               indiv = DA7218_PLL_INDIV_2_TO_4_5_MHZ_VAL;
+       } else if (da7218->mclk_rate <= 9000000) {
+               indiv_bits = DA7218_PLL_INDIV_4_5_TO_9_MHZ;
+               indiv = DA7218_PLL_INDIV_4_5_TO_9_MHZ_VAL;
+       } else if (da7218->mclk_rate <= 18000000) {
+               indiv_bits = DA7218_PLL_INDIV_9_TO_18_MHZ;
+               indiv = DA7218_PLL_INDIV_9_TO_18_MHZ_VAL;
+       } else if (da7218->mclk_rate <= 36000000) {
+               indiv_bits = DA7218_PLL_INDIV_18_TO_36_MHZ;
+               indiv = DA7218_PLL_INDIV_18_TO_36_MHZ_VAL;
        } else if (da7218->mclk_rate <= 54000000) {
-               indiv_bits = DA7218_PLL_INDIV_40_54_MHZ;
-               indiv = DA7218_PLL_INDIV_40_54_MHZ_VAL;
+               indiv_bits = DA7218_PLL_INDIV_36_TO_54_MHZ;
+               indiv = DA7218_PLL_INDIV_36_TO_54_MHZ_VAL;
        } else {
                dev_err(codec->dev, "PLL input clock %d above valid range\n",
                        da7218->mclk_rate);
index c2c59049a2ad1e7bf2e0368728c06f1109fcbbb8..477cd37723cfd90a28cd0461e8f8ff277db58ef0 100644 (file)
 /* DA7218_PLL_CTRL = 0x91 */
 #define DA7218_PLL_INDIV_SHIFT         0
 #define DA7218_PLL_INDIV_MASK          (0x7 << 0)
-#define DA7218_PLL_INDIV_2_5_MHZ       (0x0 << 0)
-#define DA7218_PLL_INDIV_5_10_MHZ      (0x1 << 0)
-#define DA7218_PLL_INDIV_10_20_MHZ     (0x2 << 0)
-#define DA7218_PLL_INDIV_20_40_MHZ     (0x3 << 0)
-#define DA7218_PLL_INDIV_40_54_MHZ     (0x4 << 0)
-#define DA7218_PLL_INDIV_2_10_MHZ_VAL  2
-#define DA7218_PLL_INDIV_10_20_MHZ_VAL 4
-#define DA7218_PLL_INDIV_20_40_MHZ_VAL 8
-#define DA7218_PLL_INDIV_40_54_MHZ_VAL 16
+#define DA7218_PLL_INDIV_2_TO_4_5_MHZ  (0x0 << 0)
+#define DA7218_PLL_INDIV_4_5_TO_9_MHZ  (0x1 << 0)
+#define DA7218_PLL_INDIV_9_TO_18_MHZ   (0x2 << 0)
+#define DA7218_PLL_INDIV_18_TO_36_MHZ  (0x3 << 0)
+#define DA7218_PLL_INDIV_36_TO_54_MHZ  (0x4 << 0)
 #define DA7218_PLL_MCLK_SQR_EN_SHIFT   4
 #define DA7218_PLL_MCLK_SQR_EN_MASK    (0x1 << 4)
 #define DA7218_PLL_MODE_SHIFT          6
 #define DA7218_PLL_FREQ_OUT_90316      90316800
 #define DA7218_PLL_FREQ_OUT_98304      98304000
 
+/* PLL Frequency Dividers */
+#define DA7218_PLL_INDIV_2_TO_4_5_MHZ_VAL      1
+#define DA7218_PLL_INDIV_4_5_TO_9_MHZ_VAL      2
+#define DA7218_PLL_INDIV_9_TO_18_MHZ_VAL       4
+#define DA7218_PLL_INDIV_18_TO_36_MHZ_VAL      8
+#define DA7218_PLL_INDIV_36_TO_54_MHZ_VAL      16
+
 /* ALC Calibration */
 #define DA7218_ALC_CALIB_DELAY_MIN     2500
 #define DA7218_ALC_CALIB_DELAY_MAX     5000
index 81c0708b85c1569ad6e109dfac647c732d504b55..5c93899f1f0e51390f171c6f9cdf2c2482be4388 100644 (file)
@@ -11,6 +11,7 @@
  * option) any later version.
  */
 
+#include <linux/acpi.h>
 #include <linux/clk.h>
 #include <linux/i2c.h>
 #include <linux/of_device.h>
@@ -1025,7 +1026,7 @@ static int da7219_set_dai_sysclk(struct snd_soc_dai *codec_dai,
        if ((da7219->clk_src == clk_id) && (da7219->mclk_rate == freq))
                return 0;
 
-       if (((freq < 2000000) && (freq != 32768)) || (freq > 54000000)) {
+       if ((freq < 2000000) || (freq > 54000000)) {
                dev_err(codec_dai->dev, "Unsupported MCLK value %d\n",
                        freq);
                return -EINVAL;
@@ -1079,21 +1080,21 @@ static int da7219_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
                dev_err(codec->dev, "PLL input clock %d below valid range\n",
                        da7219->mclk_rate);
                return -EINVAL;
-       } else if (da7219->mclk_rate <= 5000000) {
-               indiv_bits = DA7219_PLL_INDIV_2_5_MHZ;
-               indiv = DA7219_PLL_INDIV_2_5_MHZ_VAL;
-       } else if (da7219->mclk_rate <= 10000000) {
-               indiv_bits = DA7219_PLL_INDIV_5_10_MHZ;
-               indiv = DA7219_PLL_INDIV_5_10_MHZ_VAL;
-       } else if (da7219->mclk_rate <= 20000000) {
-               indiv_bits = DA7219_PLL_INDIV_10_20_MHZ;
-               indiv = DA7219_PLL_INDIV_10_20_MHZ_VAL;
-       } else if (da7219->mclk_rate <= 40000000) {
-               indiv_bits = DA7219_PLL_INDIV_20_40_MHZ;
-               indiv = DA7219_PLL_INDIV_20_40_MHZ_VAL;
+       } else if (da7219->mclk_rate <= 4500000) {
+               indiv_bits = DA7219_PLL_INDIV_2_TO_4_5_MHZ;
+               indiv = DA7219_PLL_INDIV_2_TO_4_5_MHZ_VAL;
+       } else if (da7219->mclk_rate <= 9000000) {
+               indiv_bits = DA7219_PLL_INDIV_4_5_TO_9_MHZ;
+               indiv = DA7219_PLL_INDIV_4_5_TO_9_MHZ_VAL;
+       } else if (da7219->mclk_rate <= 18000000) {
+               indiv_bits = DA7219_PLL_INDIV_9_TO_18_MHZ;
+               indiv = DA7219_PLL_INDIV_9_TO_18_MHZ_VAL;
+       } else if (da7219->mclk_rate <= 36000000) {
+               indiv_bits = DA7219_PLL_INDIV_18_TO_36_MHZ;
+               indiv = DA7219_PLL_INDIV_18_TO_36_MHZ_VAL;
        } else if (da7219->mclk_rate <= 54000000) {
-               indiv_bits = DA7219_PLL_INDIV_40_54_MHZ;
-               indiv = DA7219_PLL_INDIV_40_54_MHZ_VAL;
+               indiv_bits = DA7219_PLL_INDIV_36_TO_54_MHZ;
+               indiv = DA7219_PLL_INDIV_36_TO_54_MHZ_VAL;
        } else {
                dev_err(codec->dev, "PLL input clock %d above valid range\n",
                        da7219->mclk_rate);
@@ -1426,6 +1427,12 @@ static const struct of_device_id da7219_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, da7219_of_match);
 
+static const struct acpi_device_id da7219_acpi_match[] = {
+       { .id = "DLGS7219", },
+       { }
+};
+MODULE_DEVICE_TABLE(acpi, da7219_acpi_match);
+
 static enum da7219_micbias_voltage
        da7219_of_micbias_lvl(struct snd_soc_codec *codec, u32 val)
 {
@@ -1955,6 +1962,7 @@ static struct i2c_driver da7219_i2c_driver = {
        .driver = {
                .name = "da7219",
                .of_match_table = of_match_ptr(da7219_of_match),
+               .acpi_match_table = ACPI_PTR(da7219_acpi_match),
        },
        .probe          = da7219_i2c_probe,
        .remove         = da7219_i2c_remove,
index 5a787e738084194e3cdd88a8f75eb034fd2ab032..ff2a2f02ce4049059218b35cc3beb0bddaf6e685 100644 (file)
 /* DA7219_PLL_CTRL = 0x20 */
 #define DA7219_PLL_INDIV_SHIFT         2
 #define DA7219_PLL_INDIV_MASK          (0x7 << 2)
-#define DA7219_PLL_INDIV_2_5_MHZ       (0x0 << 2)
-#define DA7219_PLL_INDIV_5_10_MHZ      (0x1 << 2)
-#define DA7219_PLL_INDIV_10_20_MHZ     (0x2 << 2)
-#define DA7219_PLL_INDIV_20_40_MHZ     (0x3 << 2)
-#define DA7219_PLL_INDIV_40_54_MHZ     (0x4 << 2)
+#define DA7219_PLL_INDIV_2_TO_4_5_MHZ  (0x0 << 2)
+#define DA7219_PLL_INDIV_4_5_TO_9_MHZ  (0x1 << 2)
+#define DA7219_PLL_INDIV_9_TO_18_MHZ   (0x2 << 2)
+#define DA7219_PLL_INDIV_18_TO_36_MHZ  (0x3 << 2)
+#define DA7219_PLL_INDIV_36_TO_54_MHZ  (0x4 << 2)
 #define DA7219_PLL_MCLK_SQR_EN_SHIFT   5
 #define DA7219_PLL_MCLK_SQR_EN_MASK    (0x1 << 5)
 #define DA7219_PLL_MODE_SHIFT          6
 #define DA7219_PLL_FREQ_OUT_98304      98304000
 
 /* PLL Frequency Dividers */
-#define DA7219_PLL_INDIV_2_5_MHZ_VAL   1
-#define DA7219_PLL_INDIV_5_10_MHZ_VAL  2
-#define DA7219_PLL_INDIV_10_20_MHZ_VAL 4
-#define DA7219_PLL_INDIV_20_40_MHZ_VAL 8
-#define DA7219_PLL_INDIV_40_54_MHZ_VAL 16
+#define DA7219_PLL_INDIV_2_TO_4_5_MHZ_VAL      1
+#define DA7219_PLL_INDIV_4_5_TO_9_MHZ_VAL      2
+#define DA7219_PLL_INDIV_9_TO_18_MHZ_VAL       4
+#define DA7219_PLL_INDIV_18_TO_36_MHZ_VAL      8
+#define DA7219_PLL_INDIV_36_TO_54_MHZ_VAL      16
 
 /* SRM */
 #define DA7219_SRM_CHECK_RETRIES       8
index afa6c5db9dccc9b00f049f8421b04e3091a1bcfc..2086d7107622d17ac3d750591f91c58db4993d8d 100644 (file)
 #include <sound/tlv.h>
 #include "es8328.h"
 
-#define ES8328_SYSCLK_RATE_1X 11289600
-#define ES8328_SYSCLK_RATE_2X 22579200
+static const unsigned int rates_12288[] = {
+       8000, 12000, 16000, 24000, 32000, 48000, 96000,
+};
 
-/* Run the codec at 22.5792 or 11.2896 MHz to support these rates */
-static struct {
-       int rate;
-       u8 ratio;
-} mclk_ratios[] = {
-       { 8000, 9 },
-       {11025, 7 },
-       {22050, 4 },
-       {44100, 2 },
+static const int ratios_12288[] = {
+       10, 7, 6, 4, 3, 2, 0,
+};
+
+static const struct snd_pcm_hw_constraint_list constraints_12288 = {
+       .count  = ARRAY_SIZE(rates_12288),
+       .list   = rates_12288,
+};
+
+static const unsigned int rates_11289[] = {
+       8018, 11025, 22050, 44100, 88200,
+};
+
+static const int ratios_11289[] = {
+       9, 7, 4, 2, 0,
+};
+
+static const struct snd_pcm_hw_constraint_list constraints_11289 = {
+       .count  = ARRAY_SIZE(rates_11289),
+       .list   = rates_11289,
 };
 
 /* regulator supplies for sgtl5000, VDDD is an optional external supply */
@@ -57,16 +69,28 @@ static const char * const supply_names[ES8328_SUPPLY_NUM] = {
        "HPVDD",
 };
 
-#define ES8328_RATES (SNDRV_PCM_RATE_44100 | \
+#define ES8328_RATES (SNDRV_PCM_RATE_96000 | \
+               SNDRV_PCM_RATE_48000 | \
+               SNDRV_PCM_RATE_44100 | \
+               SNDRV_PCM_RATE_32000 | \
                SNDRV_PCM_RATE_22050 | \
-               SNDRV_PCM_RATE_11025)
-#define ES8328_FORMATS (SNDRV_PCM_FMTBIT_S16_LE)
+               SNDRV_PCM_RATE_16000 | \
+               SNDRV_PCM_RATE_11025 | \
+               SNDRV_PCM_RATE_8000)
+#define ES8328_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \
+               SNDRV_PCM_FMTBIT_S18_3LE | \
+               SNDRV_PCM_FMTBIT_S20_3LE | \
+               SNDRV_PCM_FMTBIT_S24_LE | \
+               SNDRV_PCM_FMTBIT_S32_LE)
 
 struct es8328_priv {
        struct regmap *regmap;
        struct clk *clk;
        int playback_fs;
        bool deemph;
+       int mclkdiv2;
+       const struct snd_pcm_hw_constraint_list *sysclk_constraints;
+       const int *mclk_ratios;
        struct regulator_bulk_data supplies[ES8328_SUPPLY_NUM];
 };
 
@@ -439,54 +463,131 @@ static int es8328_mute(struct snd_soc_dai *dai, int mute)
                        mute ? ES8328_DACCONTROL3_DACMUTE : 0);
 }
 
+static int es8328_startup(struct snd_pcm_substream *substream,
+                         struct snd_soc_dai *dai)
+{
+       struct snd_soc_codec *codec = dai->codec;
+       struct es8328_priv *es8328 = snd_soc_codec_get_drvdata(codec);
+
+       if (es8328->sysclk_constraints)
+               snd_pcm_hw_constraint_list(substream->runtime, 0,
+                               SNDRV_PCM_HW_PARAM_RATE,
+                               es8328->sysclk_constraints);
+
+       return 0;
+}
+
 static int es8328_hw_params(struct snd_pcm_substream *substream,
        struct snd_pcm_hw_params *params,
        struct snd_soc_dai *dai)
 {
        struct snd_soc_codec *codec = dai->codec;
        struct es8328_priv *es8328 = snd_soc_codec_get_drvdata(codec);
-       int clk_rate;
        int i;
        int reg;
-       u8 ratio;
+       int wl;
+       int ratio;
+
+       if (!es8328->sysclk_constraints) {
+               dev_err(codec->dev, "No MCLK configured\n");
+               return -EINVAL;
+       }
 
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                reg = ES8328_DACCONTROL2;
        else
                reg = ES8328_ADCCONTROL5;
 
-       clk_rate = clk_get_rate(es8328->clk);
+       for (i = 0; i < es8328->sysclk_constraints->count; i++)
+               if (es8328->sysclk_constraints->list[i] == params_rate(params))
+                       break;
 
-       if ((clk_rate != ES8328_SYSCLK_RATE_1X) &&
-               (clk_rate != ES8328_SYSCLK_RATE_2X)) {
-               dev_err(codec->dev,
-                       "%s: clock is running at %d Hz, not %d or %d Hz\n",
-                        __func__, clk_rate,
-                        ES8328_SYSCLK_RATE_1X, ES8328_SYSCLK_RATE_2X);
+       if (i == es8328->sysclk_constraints->count) {
+               dev_err(codec->dev, "LRCLK %d unsupported with current clock\n",
+                       params_rate(params));
                return -EINVAL;
        }
 
-       /* find master mode MCLK to sampling frequency ratio */
-       ratio = mclk_ratios[0].rate;
-       for (i = 1; i < ARRAY_SIZE(mclk_ratios); i++)
-               if (params_rate(params) <= mclk_ratios[i].rate)
-                       ratio = mclk_ratios[i].ratio;
+       ratio = es8328->mclk_ratios[i];
+       snd_soc_update_bits(codec, ES8328_MASTERMODE,
+                       ES8328_MASTERMODE_MCLKDIV2,
+                       es8328->mclkdiv2 ? ES8328_MASTERMODE_MCLKDIV2 : 0);
+
+       switch (params_width(params)) {
+       case 16:
+               wl = 3;
+               break;
+       case 18:
+               wl = 2;
+               break;
+       case 20:
+               wl = 1;
+               break;
+       case 24:
+               wl = 0;
+               break;
+       case 32:
+               wl = 4;
+               break;
+       default:
+               return -EINVAL;
+       }
 
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+               snd_soc_update_bits(codec, ES8328_DACCONTROL1,
+                               ES8328_DACCONTROL1_DACWL_MASK,
+                               wl << ES8328_DACCONTROL1_DACWL_SHIFT);
+
                es8328->playback_fs = params_rate(params);
                es8328_set_deemph(codec);
-       }
+       } else
+               snd_soc_update_bits(codec, ES8328_ADCCONTROL4,
+                               ES8328_ADCCONTROL4_ADCWL_MASK,
+                               wl << ES8328_ADCCONTROL4_ADCWL_SHIFT);
 
        return snd_soc_update_bits(codec, reg, ES8328_RATEMASK, ratio);
 }
 
+static int es8328_set_sysclk(struct snd_soc_dai *codec_dai,
+               int clk_id, unsigned int freq, int dir)
+{
+       struct snd_soc_codec *codec = codec_dai->codec;
+       struct es8328_priv *es8328 = snd_soc_codec_get_drvdata(codec);
+       int mclkdiv2 = 0;
+
+       switch (freq) {
+       case 0:
+               es8328->sysclk_constraints = NULL;
+               es8328->mclk_ratios = NULL;
+               break;
+       case 22579200:
+               mclkdiv2 = 1;
+               /* fallthru */
+       case 11289600:
+               es8328->sysclk_constraints = &constraints_11289;
+               es8328->mclk_ratios = ratios_11289;
+               break;
+       case 24576000:
+               mclkdiv2 = 1;
+               /* fallthru */
+       case 12288000:
+               es8328->sysclk_constraints = &constraints_12288;
+               es8328->mclk_ratios = ratios_12288;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       es8328->mclkdiv2 = mclkdiv2;
+       return 0;
+}
+
 static int es8328_set_dai_fmt(struct snd_soc_dai *codec_dai,
                unsigned int fmt)
 {
        struct snd_soc_codec *codec = codec_dai->codec;
-       struct es8328_priv *es8328 = snd_soc_codec_get_drvdata(codec);
-       int clk_rate;
-       u8 mode = ES8328_DACCONTROL1_DACWL_16;
+       u8 dac_mode = 0;
+       u8 adc_mode = 0;
 
        /* set master/slave audio interface */
        if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBM_CFM)
@@ -495,13 +596,16 @@ static int es8328_set_dai_fmt(struct snd_soc_dai *codec_dai,
        /* interface format */
        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
        case SND_SOC_DAIFMT_I2S:
-               mode |= ES8328_DACCONTROL1_DACFORMAT_I2S;
+               dac_mode |= ES8328_DACCONTROL1_DACFORMAT_I2S;
+               adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_I2S;
                break;
        case SND_SOC_DAIFMT_RIGHT_J:
-               mode |= ES8328_DACCONTROL1_DACFORMAT_RJUST;
+               dac_mode |= ES8328_DACCONTROL1_DACFORMAT_RJUST;
+               adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_RJUST;
                break;
        case SND_SOC_DAIFMT_LEFT_J:
-               mode |= ES8328_DACCONTROL1_DACFORMAT_LJUST;
+               dac_mode |= ES8328_DACCONTROL1_DACFORMAT_LJUST;
+               adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_LJUST;
                break;
        default:
                return -EINVAL;
@@ -511,18 +615,14 @@ static int es8328_set_dai_fmt(struct snd_soc_dai *codec_dai,
        if ((fmt & SND_SOC_DAIFMT_INV_MASK) != SND_SOC_DAIFMT_NB_NF)
                return -EINVAL;
 
-       snd_soc_write(codec, ES8328_DACCONTROL1, mode);
-       snd_soc_write(codec, ES8328_ADCCONTROL4, mode);
+       snd_soc_update_bits(codec, ES8328_DACCONTROL1,
+                       ES8328_DACCONTROL1_DACFORMAT_MASK, dac_mode);
+       snd_soc_update_bits(codec, ES8328_ADCCONTROL4,
+                       ES8328_ADCCONTROL4_ADCFORMAT_MASK, adc_mode);
 
        /* Master serial port mode, with BCLK generated automatically */
-       clk_rate = clk_get_rate(es8328->clk);
-       if (clk_rate == ES8328_SYSCLK_RATE_1X)
-               snd_soc_write(codec, ES8328_MASTERMODE,
-                               ES8328_MASTERMODE_MSC);
-       else
-               snd_soc_write(codec, ES8328_MASTERMODE,
-                               ES8328_MASTERMODE_MCLKDIV2 |
-                               ES8328_MASTERMODE_MSC);
+       snd_soc_update_bits(codec, ES8328_MASTERMODE,
+                       ES8328_MASTERMODE_MSC, ES8328_MASTERMODE_MSC);
 
        return 0;
 }
@@ -579,8 +679,10 @@ static int es8328_set_bias_level(struct snd_soc_codec *codec,
 }
 
 static const struct snd_soc_dai_ops es8328_dai_ops = {
+       .startup        = es8328_startup,
        .hw_params      = es8328_hw_params,
        .digital_mute   = es8328_mute,
+       .set_sysclk     = es8328_set_sysclk,
        .set_fmt        = es8328_set_dai_fmt,
 };
 
@@ -601,6 +703,7 @@ static struct snd_soc_dai_driver es8328_dai = {
                .formats = ES8328_FORMATS,
        },
        .ops = &es8328_dai_ops,
+       .symmetric_rates = 1,
 };
 
 static int es8328_suspend(struct snd_soc_codec *codec)
@@ -708,6 +811,7 @@ const struct regmap_config es8328_regmap_config = {
        .val_bits       = 8,
        .max_register   = ES8328_REG_MAX,
        .cache_type     = REGCACHE_RBTREE,
+       .use_single_rw  = true,
 };
 EXPORT_SYMBOL_GPL(es8328_regmap_config);
 
index 156c748c89c7e55d86421b27522b22f9b16d6f76..1a736e72a929999d3117a154cf8bc