Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 9727b490e543de956b8ba356e2d5499097d0b7a2

Authored by Jeeja KP 2013-02-14 19:22:51 +0800

Committed by Takashi Iwai 2013-02-14 19:30:22 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

ALSA: compress: add support for gapless playback

this add new API for sound compress to support gapless playback.
As noted in Documentation change, we add API to send metadata of encoder and
padding delay to DSP. Also add API for indicating EOF and switching to
subsequent track

Also bump the compress API version

Signed-off-by: Jeeja KP <jeeja.kp@intel.com>
Signed-off-by: Vinod Koul <vinod.koul@intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

Showing 4 changed files with 180 additions and 1 deletions Inline Diff

Documentation/sound/alsa/compress_offload.txt
include/sound/compress_driver.h
include/uapi/sound/compress_offload.h
sound/core/compress_offload.c

Documentation/sound/alsa/compress_offload.txt

Diff comments View file @ 9727b49

 		compress_offload.txt
 		=====================
 	Pierre-Louis.Bossart <pierre-louis.bossart@linux.intel.com>
 		Vinod Koul <vinod.koul@linux.intel.com>
 Overview
 Since its early days, the ALSA API was defined with PCM support or
 constant bitrates payloads such as IEC61937 in mind. Arguments and
 returned values in frames are the norm, making it a challenge to
 extend the existing API to compressed data streams.
 In recent years, audio digital signal processors (DSP) were integrated
 in system-on-chip designs, and DSPs are also integrated in audio
 codecs. Processing compressed data on such DSPs results in a dramatic
 reduction of power consumption compared to host-based
 processing. Support for such hardware has not been very good in Linux,
 mostly because of a lack of a generic API available in the mainline
 kernel.
 Rather than requiring a compatibility break with an API change of the
 ALSA PCM interface, a new 'Compressed Data' API is introduced to
 provide a control and data-streaming interface for audio DSPs.
 The design of this API was inspired by the 2-year experience with the
 Intel Moorestown SOC, with many corrections required to upstream the
 API in the mainline kernel instead of the staging tree and make it
 usable by others.
 Requirements
 The main requirements are:
 - separation between byte counts and time. Compressed formats may have
   a header per file, per frame, or no header at all. The payload size
   may vary from frame-to-frame. As a result, it is not possible to
   estimate reliably the duration of audio buffers when handling
   compressed data. Dedicated mechanisms are required to allow for
   reliable audio-video synchronization, which requires precise
   reporting of the number of samples rendered at any given time.
 - Handling of multiple formats. PCM data only requires a specification
   of the sampling rate, number of channels and bits per sample. In
   contrast, compressed data comes in a variety of formats. Audio DSPs
   may also provide support for a limited number of audio encoders and
   decoders embedded in firmware, or may support more choices through
   dynamic download of libraries.
 - Focus on main formats. This API provides support for the most
   popular formats used for audio and video capture and playback. It is
   likely that as audio compression technology advances, new formats
   will be added.
 - Handling of multiple configurations. Even for a given format like
   AAC, some implementations may support AAC multichannel but HE-AAC
   stereo. Likewise WMA10 level M3 may require too much memory and cpu
   cycles. The new API needs to provide a generic way of listing these
   formats.
 - Rendering/Grabbing only. This API does not provide any means of
   hardware acceleration, where PCM samples are provided back to
   user-space for additional processing. This API focuses instead on
   streaming compressed data to a DSP, with the assumption that the
   decoded samples are routed to a physical output or logical back-end.
  - Complexity hiding. Existing user-space multimedia frameworks all
   have existing enums/structures for each compressed format. This new
   API assumes the existence of a platform-specific compatibility layer
   to expose, translate and make use of the capabilities of the audio
   DSP, eg. Android HAL or PulseAudio sinks. By construction, regular
   applications are not supposed to make use of this API.
 Design
 The new API shares a number of concepts with with the PCM API for flow
 control. Start, pause, resume, drain and stop commands have the same
 semantics no matter what the content is.
 The concept of memory ring buffer divided in a set of fragments is
 borrowed from the ALSA PCM API. However, only sizes in bytes can be
 specified.
 Seeks/trick modes are assumed to be handled by the host.
 The notion of rewinds/forwards is not supported. Data committed to the
 ring buffer cannot be invalidated, except when dropping all buffers.
 The Compressed Data API does not make any assumptions on how the data
 is transmitted to the audio DSP. DMA transfers from main memory to an
 embedded audio cluster or to a SPI interface for external DSPs are
 possible. As in the ALSA PCM case, a core set of routines is exposed;
 each driver implementer will have to write support for a set of
 mandatory routines and possibly make use of optional ones.
 The main additions are
 - get_caps
 This routine returns the list of audio formats supported. Querying the
 codecs on a capture stream will return encoders, decoders will be
 listed for playback streams.
 - get_codec_caps For each codec, this routine returns a list of
 capabilities. The intent is to make sure all the capabilities
 correspond to valid settings, and to minimize the risks of
 configuration failures. For example, for a complex codec such as AAC,
 the number of channels supported may depend on a specific profile. If
 the capabilities were exposed with a single descriptor, it may happen
 that a specific combination of profiles/channels/formats may not be
 supported. Likewise, embedded DSPs have limited memory and cpu cycles,
 it is likely that some implementations make the list of capabilities
 dynamic and dependent on existing workloads. In addition to codec
 settings, this routine returns the minimum buffer size handled by the
 implementation. This information can be a function of the DMA buffer
 sizes, the number of bytes required to synchronize, etc, and can be
 used by userspace to define how much needs to be written in the ring
 buffer before playback can start.
 - set_params
 This routine sets the configuration chosen for a specific codec. The
 most important field in the parameters is the codec type; in most
 cases decoders will ignore other fields, while encoders will strictly
 comply to the settings
 - get_params
 This routines returns the actual settings used by the DSP. Changes to
 the settings should remain the exception.
 - get_timestamp
 The timestamp becomes a multiple field structure. It lists the number
 of bytes transferred, the number of samples processed and the number
 of samples rendered/grabbed. All these values can be used to determine
 the avarage bitrate, figure out if the ring buffer needs to be
 refilled or the delay due to decoding/encoding/io on the DSP.
 Note that the list of codecs/profiles/modes was derived from the
 OpenMAX AL specification instead of reinventing the wheel.
 Modifications include:
 - Addition of FLAC and IEC formats
 - Merge of encoder/decoder capabilities
 - Profiles/modes listed as bitmasks to make descriptors more compact
 - Addition of set_params for decoders (missing in OpenMAX AL)
 - Addition of AMR/AMR-WB encoding modes (missing in OpenMAX AL)
 - Addition of format information for WMA
 - Addition of encoding options when required (derived from OpenMAX IL)
 - Addition of rateControlSupported (missing in OpenMAX AL)
+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
+switching from one track to another
+Also, there might be low-intensity noises due to encoding. Perfect gapless is
+difficult to reach with all types of compressed data, but works fine with most
+music content. The decoder needs to know the encoder delay and encoder padding.
+So we need to pass this to DSP. This metadata is extracted from ID3/MP4 headers
+and are not present by default in the bitstream, hence the need for a new
+interface to pass this information to the DSP. Also DSP and userspace needs to
+switch from one track to another and start using data for second track.
+The main additions are:
+- set_metadata
+This routine sets the encoder delay and encoder padding. This can be used by
+decoder to strip the silence. This needs to be set before the data in the track
+is written.
+- set_next_track
+This routine tells DSP that metadata and write operation sent after this would
+correspond to subsequent track
+- partial drain
+This is called when end of file is reached. The userspace can inform DSP that
+EOF is reached and now DSP can start skipping padding delay. Also next write
+data would belong to next track
+Sequence flow for gapless would be:
+- Open
+- Get caps / codec caps
+- Set params
+- Set metadata of the first track
+- Fill data of the first track
+- Trigger start
+- User-space finished sending all,
+- Indicaite 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
+- DSP switches to second track
+(note: order for partial_drain and write for next track can be reversed as well)
 Not supported:
 - Support for VoIP/circuit-switched calls is not the target of this
   API. Support for dynamic bit-rate changes would require a tight
   coupling between the DSP and the host stack, limiting power savings.
 - Packet-loss concealment is not supported. This would require an
   additional interface to let the decoder synthesize data when frames
   are lost during transmission. This may be added in the future.
 - Volume control/routing is not handled by this API. Devices exposing a
   compressed data interface will be considered as regular ALSA devices;
   volume changes and routing information will be provided with regular
   ALSA kcontrols.
 - Embedded audio effects. Such effects should be enabled in the same
   manner, no matter if the input was PCM or compressed.
 - multichannel IEC encoding. Unclear if this is required.
 - Encoding/decoding acceleration is not supported as mentioned
   above. It is possible to route the output of a decoder to a capture
   stream, or even implement transcoding capabilities. This routing
   would be enabled with ALSA kcontrols.
 - Audio policy/resource management. This API does not provide any
   hooks to query the utilization of the audio DSP, nor any premption
   mechanisms.
 - No notion of underun/overrun. Since the bytes written are compressed
   in nature and data written/read doesn't translate directly to
   rendered output in time, this does not deal with underrun/overun and
   maybe dealt in user-library
 Credits:
 - Mark Brown and Liam Girdwood for discussions on the need for this API
 - Harsha Priya for her work on intel_sst compressed API
 - Rakesh Ughreja for valuable feedback
 - Sing Nallasellan, Sikkandar Madar and Prasanna Samaga for
   demonstrating and quantifying the benefits of audio offload on a
   real platform.

include/sound/compress_driver.h

Diff comments View file @ 9727b49

 /*
  *  compress_driver.h - compress offload driver definations
  *
  *  Copyright (C) 2011 Intel Corporation
  *  Authors:	Vinod Koul <vinod.koul@linux.intel.com>
  *		Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  *  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; version 2 of the License.
  *
  *  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.
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  */
 #ifndef __COMPRESS_DRIVER_H
 #define __COMPRESS_DRIVER_H
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <sound/compress_offload.h>
 #include <sound/asound.h>
 #include <sound/pcm.h>
 struct snd_compr_ops;
 /**
  * struct snd_compr_runtime: runtime stream description
  * @state: stream state
  * @ops: pointer to DSP callbacks
  * @buffer: pointer to kernel buffer, valid only when not in mmap mode or
  *	DSP doesn't implement copy
  * @buffer_size: size of the above buffer
  * @fragment_size: size of buffer fragment in bytes
  * @fragments: number of such fragments
  * @hw_pointer: offset of last location in buffer where DSP copied data
  * @app_pointer: offset of last location in buffer where app wrote data
  * @total_bytes_available: cumulative number of bytes made available in
  *	the ring buffer
  * @total_bytes_transferred: cumulative bytes transferred by offload DSP
  * @sleep: poll sleep
  */
 struct snd_compr_runtime {
 	snd_pcm_state_t state;
 	struct snd_compr_ops *ops;
 	void *buffer;
 	u64 buffer_size;
 	u32 fragment_size;
 	u32 fragments;
 	u64 hw_pointer;
 	u64 app_pointer;
 	u64 total_bytes_available;
 	u64 total_bytes_transferred;
 	wait_queue_head_t sleep;
 	void *private_data;
 };
 /**
  * struct snd_compr_stream: compressed stream
  * @name: device name
  * @ops: pointer to DSP callbacks
  * @runtime: pointer to runtime structure
  * @device: device pointer
  * @direction: stream direction, playback/recording
+ * @metadata_set: metadata set flag, true when set
+ * @next_track: has userspace signall next track transistion, true when set
  * @private_data: pointer to DSP private data
  */
 struct snd_compr_stream {
 	const char *name;
 	struct snd_compr_ops *ops;
 	struct snd_compr_runtime *runtime;
 	struct snd_compr *device;
 	enum snd_compr_direction direction;
+	bool metadata_set;
+	bool next_track;
 	void *private_data;
 };
 /**
  * struct snd_compr_ops: compressed path DSP operations
  * @open: Open the compressed stream
  * This callback is mandatory and shall keep dsp ready to receive the stream
  * parameter
  * @free: Close the compressed stream, mandatory
  * @set_params: Sets the compressed stream parameters, mandatory
  * This can be called in during stream creation only to set codec params
  * and the stream properties
  * @get_params: retrieve the codec parameters, mandatory
  * @trigger: Trigger operations like start, pause, resume, drain, stop.
  * This callback is mandatory
  * @pointer: Retrieve current h/w pointer information. Mandatory
  * @copy: Copy the compressed data to/from userspace, Optional
  * Can't be implemented if DSP supports mmap
  * @mmap: DSP mmap method to mmap DSP memory
  * @ack: Ack for DSP when data is written to audio buffer, Optional
  * Not valid if copy is implemented
  * @get_caps: Retrieve DSP capabilities, mandatory
  * @get_codec_caps: Retrieve capabilities for a specific codec, mandatory
  */
 struct snd_compr_ops {
 	int (*open)(struct snd_compr_stream *stream);
 	int (*free)(struct snd_compr_stream *stream);
 	int (*set_params)(struct snd_compr_stream *stream,
 			struct snd_compr_params *params);
 	int (*get_params)(struct snd_compr_stream *stream,
 			struct snd_codec *params);
+	int (*set_metadata)(struct snd_compr_stream *stream,
+			struct snd_compr_metadata *metadata);
+	int (*get_metadata)(struct snd_compr_stream *stream,
+			struct snd_compr_metadata *metadata);
 	int (*trigger)(struct snd_compr_stream *stream, int cmd);
 	int (*pointer)(struct snd_compr_stream *stream,
 			struct snd_compr_tstamp *tstamp);
 	int (*copy)(struct snd_compr_stream *stream, const char __user *buf,
 		       size_t count);
 	int (*mmap)(struct snd_compr_stream *stream,
 			struct vm_area_struct *vma);
 	int (*ack)(struct snd_compr_stream *stream, size_t bytes);
 	int (*get_caps) (struct snd_compr_stream *stream,
 			struct snd_compr_caps *caps);
 	int (*get_codec_caps) (struct snd_compr_stream *stream,
 			struct snd_compr_codec_caps *codec);
 };
 /**
  * struct snd_compr: Compressed device
  * @name: DSP device name
  * @dev: Device pointer
  * @ops: pointer to DSP callbacks
  * @private_data: pointer to DSP pvt data
  * @card: sound card pointer
  * @direction: Playback or capture direction
  * @lock: device lock
  * @device: device id
  */
 struct snd_compr {
 	const char *name;
 	struct device *dev;
 	struct snd_compr_ops *ops;
 	void *private_data;
 	struct snd_card *card;
 	unsigned int direction;
 	struct mutex lock;
 	int device;
 };
 /* compress device register APIs */
 int snd_compress_register(struct snd_compr *device);
 int snd_compress_deregister(struct snd_compr *device);
 int snd_compress_new(struct snd_card *card, int device,
 			int type, struct snd_compr *compr);
 /* dsp driver callback apis
  * For playback: driver should call snd_compress_fragment_elapsed() to let the
  * framework know that a fragment has been consumed from the ring buffer
  *
  * For recording: we want to know when a frame is available or when
  * at least one frame is available so snd_compress_frame_elapsed()
  * callback should be called when a encodeded frame is available
  */
 static inline void snd_compr_fragment_elapsed(struct snd_compr_stream *stream)
 {
 	wake_up(&stream->runtime->sleep);
 }
 #endif

include/uapi/sound/compress_offload.h

Diff comments View file @ 9727b49

 /*
  *  compress_offload.h - compress offload header definations
  *
  *  Copyright (C) 2011 Intel Corporation
  *  Authors:	Vinod Koul <vinod.koul@linux.intel.com>
  *		Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  *  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; version 2 of the License.
  *
  *  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.
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  */
 #ifndef __COMPRESS_OFFLOAD_H
 #define __COMPRESS_OFFLOAD_H
 #include <linux/types.h>
 #include <sound/asound.h>
 #include <sound/compress_params.h>
-#define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 1, 0)
+#define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 1, 1)
 /**
  * struct snd_compressed_buffer: compressed buffer
  * @fragment_size: size of buffer fragment in bytes
  * @fragments: number of such fragments
  */
 struct snd_compressed_buffer {
 	__u32 fragment_size;
 	__u32 fragments;
 };
 /**
  * struct snd_compr_params: compressed stream params
  * @buffer: buffer description
  * @codec: codec parameters
  * @no_wake_mode: dont wake on fragment elapsed
  */
 struct snd_compr_params {
 	struct snd_compressed_buffer buffer;
 	struct snd_codec codec;
 	__u8 no_wake_mode;
 };
 /**
  * struct snd_compr_tstamp: timestamp descriptor
  * @byte_offset: Byte offset in ring buffer to DSP
  * @copied_total: Total number of bytes copied from/to ring buffer to/by DSP
  * @pcm_frames: Frames decoded or encoded by DSP. This field will evolve by
  *	large steps and should only be used to monitor encoding/decoding
  *	progress. It shall not be used for timing estimates.
  * @pcm_io_frames: Frames rendered or received by DSP into a mixer or an audio
  * output/input. This field should be used for A/V sync or time estimates.
  * @sampling_rate: sampling rate of audio
  */
 struct snd_compr_tstamp {
 	__u32 byte_offset;
 	__u32 copied_total;
 	snd_pcm_uframes_t pcm_frames;
 	snd_pcm_uframes_t pcm_io_frames;
 	__u32 sampling_rate;
 };
 /**
  * struct snd_compr_avail: avail descriptor
  * @avail: Number of bytes available in ring buffer for writing/reading
  * @tstamp: timestamp infomation
  */
 struct snd_compr_avail {
 	__u64 avail;
 	struct snd_compr_tstamp tstamp;
 };
 enum snd_compr_direction {
 	SND_COMPRESS_PLAYBACK = 0,
 	SND_COMPRESS_CAPTURE
 };
 /**
  * struct snd_compr_caps: caps descriptor
  * @codecs: pointer to array of codecs
  * @direction: direction supported. Of type snd_compr_direction
  * @min_fragment_size: minimum fragment supported by DSP
  * @max_fragment_size: maximum fragment supported by DSP
  * @min_fragments: min fragments supported by DSP
  * @max_fragments: max fragments supported by DSP
  * @num_codecs: number of codecs supported
  * @reserved: reserved field
  */
 struct snd_compr_caps {
 	__u32 num_codecs;
 	__u32 direction;
 	__u32 min_fragment_size;
 	__u32 max_fragment_size;
 	__u32 min_fragments;
 	__u32 max_fragments;
 	__u32 codecs[MAX_NUM_CODECS];
 	__u32 reserved[11];
 };
 /**
  * struct snd_compr_codec_caps: query capability of codec
  * @codec: codec for which capability is queried
  * @num_descriptors: number of codec descriptors
  * @descriptor: array of codec capability descriptor
  */
 struct snd_compr_codec_caps {
 	__u32 codec;
 	__u32 num_descriptors;
 	struct snd_codec_desc descriptor[MAX_NUM_CODEC_DESCRIPTORS];
 };
 /**
+ * @SNDRV_COMPRESS_ENCODER_PADDING: no of samples appended by the encoder at the
+ * end of the track
+ * @SNDRV_COMPRESS_ENCODER_DELAY: no of samples inserted by the encoder at the
+ * beginning of the track
+ */
+enum {
+	SNDRV_COMPRESS_ENCODER_PADDING = 1,
+	SNDRV_COMPRESS_ENCODER_DELAY = 2,
+};
+/**
+ * struct snd_compr_metadata: compressed stream metadata
+ * @key: key id
+ * @value: key value
+ */
+struct snd_compr_metadata {
+	 __u32 key;
+	 __u32 value[8];
+};
+/**
  * compress path ioctl definitions
  * SNDRV_COMPRESS_GET_CAPS: Query capability of DSP
  * SNDRV_COMPRESS_GET_CODEC_CAPS: Query capability of a codec
  * SNDRV_COMPRESS_SET_PARAMS: Set codec and stream parameters
  * Note: only codec params can be changed runtime and stream params cant be
  * SNDRV_COMPRESS_GET_PARAMS: Query codec params
  * SNDRV_COMPRESS_TSTAMP: get the current timestamp value
  * SNDRV_COMPRESS_AVAIL: get the current buffer avail value.
  * This also queries the tstamp properties
  * SNDRV_COMPRESS_PAUSE: Pause the running stream
  * SNDRV_COMPRESS_RESUME: resume a paused stream
  * SNDRV_COMPRESS_START: Start a stream
  * SNDRV_COMPRESS_STOP: stop a running stream, discarding ring buffer content
  * and the buffers currently with DSP
  * SNDRV_COMPRESS_DRAIN: Play till end of buffers and stop after that
  * SNDRV_COMPRESS_IOCTL_VERSION: Query the API version
  */
 #define SNDRV_COMPRESS_IOCTL_VERSION	_IOR('C', 0x00, int)
 #define SNDRV_COMPRESS_GET_CAPS		_IOWR('C', 0x10, struct snd_compr_caps)
 #define SNDRV_COMPRESS_GET_CODEC_CAPS	_IOWR('C', 0x11,\
 						struct snd_compr_codec_caps)
 #define SNDRV_COMPRESS_SET_PARAMS	_IOW('C', 0x12, struct snd_compr_params)
 #define SNDRV_COMPRESS_GET_PARAMS	_IOR('C', 0x13, struct snd_codec)
+#define SNDRV_COMPRESS_SET_METADATA	_IOW('C', 0x14,\
+						 struct snd_compr_metadata)
+#define SNDRV_COMPRESS_GET_METADATA	_IOWR('C', 0x15,\
+						 struct snd_compr_metadata)
 #define SNDRV_COMPRESS_TSTAMP		_IOR('C', 0x20, struct snd_compr_tstamp)
 #define SNDRV_COMPRESS_AVAIL		_IOR('C', 0x21, struct snd_compr_avail)
 #define SNDRV_COMPRESS_PAUSE		_IO('C', 0x30)
 #define SNDRV_COMPRESS_RESUME		_IO('C', 0x31)
 #define SNDRV_COMPRESS_START		_IO('C', 0x32)
 #define SNDRV_COMPRESS_STOP		_IO('C', 0x33)
 #define SNDRV_COMPRESS_DRAIN		_IO('C', 0x34)
+#define SNDRV_COMPRESS_NEXT_TRACK	_IO('C', 0x35)
+#define SNDRV_COMPRESS_PARTIAL_DRAIN	_IO('C', 0x36)
 /*
  * TODO
  * 1. add mmap support
  *
  */
 #define SND_COMPR_TRIGGER_DRAIN 7 /*FIXME move this to pcm.h */
+#define SND_COMPR_TRIGGER_NEXT_TRACK 8
+#define SND_COMPR_TRIGGER_PARTIAL_DRAIN 9
 #endif

sound/core/compress_offload.c

Diff comments View file @ 9727b49

 /*
  *  compress_core.c - compress offload core
  *
  *  Copyright (C) 2011 Intel Corporation
  *  Authors:	Vinod Koul <vinod.koul@linux.intel.com>
  *		Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  *  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; version 2 of the License.
  *
  *  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.
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  */
 #define FORMAT(fmt) "%s: %d: " fmt, __func__, __LINE__
 #define pr_fmt(fmt) KBUILD_MODNAME ": " FORMAT(fmt)
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/list.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/uio.h>
 #include <linux/uaccess.h>
 #include <linux/module.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/compress_params.h>
 #include <sound/compress_offload.h>
 #include <sound/compress_driver.h>
 /* TODO:
  * - add substream support for multiple devices in case of
  *	SND_DYNAMIC_MINORS is not used
  * - Multiple node representation
  *	driver should be able to register multiple nodes
  */
 static DEFINE_MUTEX(device_mutex);
 struct snd_compr_file {
 	unsigned long caps;
 	struct snd_compr_stream stream;
 };
 /*
  * a note on stream states used:
  * we use follwing states in the compressed core
  * SNDRV_PCM_STATE_OPEN: When stream has been opened.
  * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by
  *	calling SNDRV_COMPRESS_SET_PARAMS. running streams will come to this
  *	state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain.
  * SNDRV_PCM_STATE_RUNNING: When stream has been started and is
  *	decoding/encoding and rendering/capturing data.
  * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
  *	by calling SNDRV_COMPRESS_DRAIN.
  * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
  *	SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling
  *	SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively.
  */
 static int snd_compr_open(struct inode *inode, struct file *f)
 {
 	struct snd_compr *compr;
 	struct snd_compr_file *data;
 	struct snd_compr_runtime *runtime;
 	enum snd_compr_direction dirn;
 	int maj = imajor(inode);
 	int ret;
 	if ((f->f_flags & O_ACCMODE) == O_WRONLY)
 		dirn = SND_COMPRESS_PLAYBACK;
 	else if ((f->f_flags & O_ACCMODE) == O_RDONLY)
 		dirn = SND_COMPRESS_CAPTURE;
 	else
 		return -EINVAL;
 	if (maj == snd_major)
 		compr = snd_lookup_minor_data(iminor(inode),
 					SNDRV_DEVICE_TYPE_COMPRESS);
 	else
 		return -EBADFD;
 	if (compr == NULL) {
 		pr_err("no device data!!!\n");
 		return -ENODEV;
 	}
 	if (dirn != compr->direction) {
 		pr_err("this device doesn't support this direction\n");
 		snd_card_unref(compr->card);
 		return -EINVAL;
 	}
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (!data) {
 		snd_card_unref(compr->card);
 		return -ENOMEM;
 	}
 	data->stream.ops = compr->ops;
 	data->stream.direction = dirn;
 	data->stream.private_data = compr->private_data;
 	data->stream.device = compr;
 	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
 	if (!runtime) {
 		kfree(data);
 		snd_card_unref(compr->card);
 		return -ENOMEM;
 	}
 	runtime->state = SNDRV_PCM_STATE_OPEN;
 	init_waitqueue_head(&runtime->sleep);
 	data->stream.runtime = runtime;
 	f->private_data = (void *)data;
 	mutex_lock(&compr->lock);
 	ret = compr->ops->open(&data->stream);
 	mutex_unlock(&compr->lock);
 	if (ret) {
 		kfree(runtime);
 		kfree(data);
 	}
 	snd_card_unref(compr->card);
 	return 0;
 }
 static int snd_compr_free(struct inode *inode, struct file *f)
 {
 	struct snd_compr_file *data = f->private_data;
 	data->stream.ops->free(&data->stream);
 	kfree(data->stream.runtime->buffer);
 	kfree(data->stream.runtime);
 	kfree(data);
 	return 0;
 }
 static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
 		struct snd_compr_tstamp *tstamp)
 {
 	if (!stream->ops->pointer)
 		return -ENOTSUPP;
 	stream->ops->pointer(stream, tstamp);
 	pr_debug("dsp consumed till %d total %d bytes\n",
 		tstamp->byte_offset, tstamp->copied_total);
 	stream->runtime->hw_pointer = tstamp->byte_offset;
 	stream->runtime->total_bytes_transferred = tstamp->copied_total;
 	return 0;
 }
 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
 		struct snd_compr_avail *avail)
 {
 	long avail_calc; /*this needs to be signed variable */
 	memset(avail, 0, sizeof(*avail));
 	snd_compr_update_tstamp(stream, &avail->tstamp);
 	/* Still need to return avail even if tstamp can't be filled in */
 	/* FIXME: This needs to be different for capture stream,
 	   available is # of compressed data, for playback it's
 	   remainder of buffer */
 	if (stream->runtime->total_bytes_available == 0 &&
 			stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
 		pr_debug("detected init and someone forgot to do a write\n");
 		return stream->runtime->buffer_size;
 	}
 	pr_debug("app wrote %lld, DSP consumed %lld\n",
 			stream->runtime->total_bytes_available,
 			stream->runtime->total_bytes_transferred);
 	if (stream->runtime->total_bytes_available ==
 				stream->runtime->total_bytes_transferred) {
 		pr_debug("both pointers are same, returning full avail\n");
 		return stream->runtime->buffer_size;
 	}
 	/* FIXME: this routine isn't consistent, in one test we use
 	 * cumulative values and in the other byte offsets. Do we
 	 * really need the byte offsets if the cumulative values have
 	 * been updated? In the PCM interface app_ptr and hw_ptr are
 	 * already cumulative */
 	avail_calc = stream->runtime->buffer_size -
 		(stream->runtime->app_pointer - stream->runtime->hw_pointer);
 	pr_debug("calc avail as %ld, app_ptr %lld, hw+ptr %lld\n", avail_calc,
 			stream->runtime->app_pointer,
 			stream->runtime->hw_pointer);
 	if (avail_calc >= stream->runtime->buffer_size)
 		avail_calc -= stream->runtime->buffer_size;
 	pr_debug("ret avail as %ld\n", avail_calc);
 	avail->avail = avail_calc;
 	return avail_calc;
 }
 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
 {
 	struct snd_compr_avail avail;
 	return snd_compr_calc_avail(stream, &avail);
 }
 static int
 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
 {
 	struct snd_compr_avail ioctl_avail;
 	size_t avail;
 	avail = snd_compr_calc_avail(stream, &ioctl_avail);
 	ioctl_avail.avail = avail;
 	if (copy_to_user((__u64 __user *)arg,
 				&ioctl_avail, sizeof(ioctl_avail)))
 		return -EFAULT;
 	return 0;
 }
 static int snd_compr_write_data(struct snd_compr_stream *stream,
 	       const char __user *buf, size_t count)
 {
 	void *dstn;
 	size_t copy;
 	struct snd_compr_runtime *runtime = stream->runtime;
 	dstn = runtime->buffer + runtime->app_pointer;
 	pr_debug("copying %ld at %lld\n",
 			(unsigned long)count, runtime->app_pointer);
 	if (count < runtime->buffer_size - runtime->app_pointer) {
 		if (copy_from_user(dstn, buf, count))
 			return -EFAULT;
 		runtime->app_pointer += count;
 	} else {
 		copy = runtime->buffer_size - runtime->app_pointer;
 		if (copy_from_user(dstn, buf, copy))
 			return -EFAULT;
 		if (copy_from_user(runtime->buffer, buf + copy, count - copy))
 			return -EFAULT;
 		runtime->app_pointer = count - copy;
 	}
 	/* if DSP cares, let it know data has been written */
 	if (stream->ops->ack)
 		stream->ops->ack(stream, count);
 	return count;
 }
 static ssize_t snd_compr_write(struct file *f, const char __user *buf,
 		size_t count, loff_t *offset)
 {
 	struct snd_compr_file *data = f->private_data;
 	struct snd_compr_stream *stream;
 	size_t avail;
 	int retval;
 	if (snd_BUG_ON(!data))
 		return -EFAULT;
 	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_RUNNING) {
 		mutex_unlock(&stream->device->lock);
 		return -EBADFD;
 	}
 	avail = snd_compr_get_avail(stream);
 	pr_debug("avail returned %ld\n", (unsigned long)avail);
 	/* calculate how much we can write to buffer */
 	if (avail > count)
 		avail = count;
 	if (stream->ops->copy)
 		retval = stream->ops->copy(stream, buf, avail);
 	else
 		retval = snd_compr_write_data(stream, buf, avail);
 	if (retval > 0)
 		stream->runtime->total_bytes_available += retval;
 	/* while initiating the stream, write should be called before START
 	 * call, so in setup move state */
 	if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
 		stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
 		pr_debug("stream prepared, Houston we are good to go\n");
 	}
 	mutex_unlock(&stream->device->lock);
 	return retval;
 }
 static ssize_t snd_compr_read(struct file *f, char __user *buf,
 		size_t count, loff_t *offset)
 {
 	return -ENXIO;
 }
 static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma)
 {
 	return -ENXIO;
 }
 static inline int snd_compr_get_poll(struct snd_compr_stream *stream)
 {
 	if (stream->direction == SND_COMPRESS_PLAYBACK)
 		return POLLOUT | POLLWRNORM;
 	else
 		return POLLIN | POLLRDNORM;
 }
 static unsigned int snd_compr_poll(struct file *f, poll_table *wait)
 {
 	struct snd_compr_file *data = f->private_data;
 	struct snd_compr_stream *stream;
 	size_t avail;
 	int retval = 0;
 	if (snd_BUG_ON(!data))
 		return -EFAULT;
 	stream = &data->stream;
 	if (snd_BUG_ON(!stream))
 		return -EFAULT;
 	mutex_lock(&stream->device->lock);
 	if (stream->runtime->state == SNDRV_PCM_STATE_PAUSED ||
 			stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
 		retval = -EBADFD;
 		goto out;
 	}
 	poll_wait(f, &stream->runtime->sleep, wait);
 	avail = snd_compr_get_avail(stream);
 	pr_debug("avail is %ld\n", (unsigned long)avail);
 	/* check if we have at least one fragment to fill */
 	switch (stream->runtime->state) {
 	case SNDRV_PCM_STATE_DRAINING:
 		/* stream has been woken up after drain is complete
 		 * draining done so set stream state to stopped
 		 */
 		retval = snd_compr_get_poll(stream);
 		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 		break;
 	case SNDRV_PCM_STATE_RUNNING:
 	case SNDRV_PCM_STATE_PREPARED:
 	case SNDRV_PCM_STATE_PAUSED:
 		if (avail >= stream->runtime->fragment_size)
 			retval = snd_compr_get_poll(stream);
 		break;
 	default:
 		if (stream->direction == SND_COMPRESS_PLAYBACK)
 			retval = POLLOUT | POLLWRNORM | POLLERR;
 		else
 			retval = POLLIN | POLLRDNORM | POLLERR;
 		break;
 	}
 out:
 	mutex_unlock(&stream->device->lock);
 	return retval;
 }
 static int
 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
 {
 	int retval;
 	struct snd_compr_caps caps;
 	if (!stream->ops->get_caps)
 		return -ENXIO;
 	retval = stream->ops->get_caps(stream, &caps);
 	if (retval)
 		goto out;
 	if (copy_to_user((void __user *)arg, &caps, sizeof(caps)))
 		retval = -EFAULT;
 out:
 	return retval;
 }
 static int
 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
 {
 	int retval;
 	struct snd_compr_codec_caps *caps;
 	if (!stream->ops->get_codec_caps)
 		return -ENXIO;
 	caps = kmalloc(sizeof(*caps), GFP_KERNEL);
 	if (!caps)
 		return -ENOMEM;
 	retval = stream->ops->get_codec_caps(stream, caps);
 	if (retval)
 		goto out;
 	if (copy_to_user((void __user *)arg, caps, sizeof(*caps)))
 		retval = -EFAULT;
 out:
 	kfree(caps);
 	return retval;
 }
 /* revisit this with snd_pcm_preallocate_xxx */
 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
 		struct snd_compr_params *params)
 {
 	unsigned int buffer_size;
 	void *buffer;
 	buffer_size = params->buffer.fragment_size * params->buffer.fragments;
 	if (stream->ops->copy) {
 		buffer = NULL;
 		/* if copy is defined the driver will be required to copy
 		 * the data from core
 		 */
 	} else {
 		buffer = kmalloc(buffer_size, GFP_KERNEL);
 		if (!buffer)
 			return -ENOMEM;
 	}
 	stream->runtime->fragment_size = params->buffer.fragment_size;
 	stream->runtime->fragments = params->buffer.fragments;
 	stream->runtime->buffer = buffer;
 	stream->runtime->buffer_size = buffer_size;
 	return 0;
 }
 static int snd_compress_check_input(struct snd_compr_params *params)
 {
 	/* first let's check the buffer parameter's */
 	if (params->buffer.fragment_size == 0 ||
 			params->buffer.fragments > SIZE_MAX / params->buffer.fragment_size)
 		return -EINVAL;
 	/* now codec parameters */
 	if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX)
 		return -EINVAL;
 	if (params->codec.ch_in == 0 || params->codec.ch_out == 0)
 		return -EINVAL;
 	if (!(params->codec.sample_rate & SNDRV_PCM_RATE_8000_192000))
 		return -EINVAL;
 	return 0;
 }
 static int
 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
 {
 	struct snd_compr_params *params;
 	int retval;
 	if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {
 		/*
 		 * we should allow parameter change only when stream has been
 		 * opened not in other cases
 		 */
 		params = kmalloc(sizeof(*params), GFP_KERNEL);
 		if (!params)
 			return -ENOMEM;
 		if (copy_from_user(params, (void __user *)arg, sizeof(*params))) {
 			retval = -EFAULT;
 			goto out;
 		}
 		retval = snd_compress_check_input(params);
 		if (retval)
 			goto out;
 		retval = snd_compr_allocate_buffer(stream, params);
 		if (retval) {
 			retval = -ENOMEM;
 			goto out;
 		}
 		retval = stream->ops->set_params(stream, params);
 		if (retval)
 			goto out;
 		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
+		stream->metadata_set = false;
+		stream->next_track = false;
 	} else {
 		return -EPERM;
 	}
 out:
 	kfree(params);
 	return retval;
 }
 static int
 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
 {
 	struct snd_codec *params;
 	int retval;
 	if (!stream->ops->get_params)
 		return -EBADFD;
 	params = kmalloc(sizeof(*params), GFP_KERNEL);
 	if (!params)
 		return -ENOMEM;
 	retval = stream->ops->get_params(stream, params);
 	if (retval)
 		goto out;
 	if (copy_to_user((char __user *)arg, params, sizeof(*params)))
 		retval = -EFAULT;
 out:
 	kfree(params);
 	return retval;
 }
+static int
+snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
+{
+	struct snd_compr_metadata metadata;
+	int retval;
+	if (!stream->ops->get_metadata)
+		return -ENXIO;
+	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
+		return -EFAULT;
+	retval = stream->ops->get_metadata(stream, &metadata);
+	if (retval != 0)
+		return retval;
+	if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata)))
+		return -EFAULT;
+	return 0;
+}
+static int
+snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
+{
+	struct snd_compr_metadata metadata;
+	int retval;
+	if (!stream->ops->set_metadata)
+		return -ENXIO;
+	/*
+	* we should allow parameter change only when stream has been
+	* opened not in other cases
+	*/
+	if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata)))
+		return -EFAULT;
+	retval = stream->ops->set_metadata(stream, &metadata);
+	stream->metadata_set = true;
+	return retval;
+}
 static inline int
 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
 {
 	struct snd_compr_tstamp tstamp = {0};
 	int ret;
 	ret = snd_compr_update_tstamp(stream, &tstamp);
 	if (ret == 0)
 		ret = copy_to_user((struct snd_compr_tstamp __user *)arg,
 			&tstamp, sizeof(tstamp)) ? -EFAULT : 0;
 	return ret;
 }
 static int snd_compr_pause(struct snd_compr_stream *stream)
 {
 	int retval;
 	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
 		return -EPERM;
 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
 	if (!retval)
 		stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
 	return retval;
 }
 static int snd_compr_resume(struct snd_compr_stream *stream)
 {
 	int retval;
 	if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED)
 		return -EPERM;
 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
 	if (!retval)
 		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 	return retval;
 }
 static int snd_compr_start(struct snd_compr_stream *stream)
 {
 	int retval;
 	if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED)
 		return -EPERM;
 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
 	if (!retval)
 		stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
 	return retval;
 }
 static int snd_compr_stop(struct snd_compr_stream *stream)
 {
 	int retval;
 	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
 			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
 		return -EPERM;
 	retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
 	if (!retval) {
 		stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 		wake_up(&stream->runtime->sleep);
 		stream->runtime->hw_pointer = 0;
 		stream->runtime->app_pointer = 0;
 		stream->runtime->total_bytes_available = 0;
 		stream->runtime->total_bytes_transferred = 0;
 	}
 	return retval;
 }
 static int snd_compr_drain(struct snd_compr_stream *stream)
 {
 	int retval;
 	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
 			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
 		return -EPERM;
 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
 	if (!retval) {
 		stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
 		wake_up(&stream->runtime->sleep);
 	}
 	return retval;
 }
+static int snd_compr_next_track(struct snd_compr_stream *stream)
+{
+	int retval;
+	/* only a running stream can transition to next track */
+	if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
+		return -EPERM;
+	/* you can signal next track isf this is intended to be a gapless stream
+	 * and current track metadata is set
+	 */
+	if (stream->metadata_set == false)
+		return -EPERM;
+	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
+	if (retval != 0)
+		return retval;
+	stream->metadata_set = false;
+	stream->next_track = true;
+	return 0;
+}
+static int snd_compr_partial_drain(struct snd_compr_stream *stream)
+{
+	int retval;
+	if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
+			stream->runtime->state == SNDRV_PCM_STATE_SETUP)
+		return -EPERM;
+	/* stream can be drained only when next track has been signalled */
+	if (stream->next_track == false)
+		return -EPERM;
+	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
+	stream->next_track = false;
+	return retval;
+}
 static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 {
 	struct snd_compr_file *data = f->private_data;
 	struct snd_compr_stream *stream;
 	int retval = -ENOTTY;
 	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):
 		put_user(SNDRV_COMPRESS_VERSION,
 				(int __user *)arg) ? -EFAULT : 0;
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
 		retval = snd_compr_get_caps(stream, arg);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
 		retval = snd_compr_get_codec_caps(stream, arg);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
 		retval = snd_compr_set_params(stream, arg);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
 		retval = snd_compr_get_params(stream, arg);
 		break;
+	case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
+		retval = snd_compr_set_metadata(stream, arg);
+		break;
+	case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
+		retval = snd_compr_get_metadata(stream, arg);
+		break;
 	case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
 		retval = snd_compr_tstamp(stream, arg);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_AVAIL):
 		retval = snd_compr_ioctl_avail(stream, arg);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_PAUSE):
 		retval = snd_compr_pause(stream);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_RESUME):
 		retval = snd_compr_resume(stream);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_START):
 		retval = snd_compr_start(stream);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_STOP):
 		retval = snd_compr_stop(stream);
 		break;
 	case _IOC_NR(SNDRV_COMPRESS_DRAIN):
 		retval = snd_compr_drain(stream);
 		break;
+	case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
+		retval = snd_compr_partial_drain(stream);
+		break;
+	case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
+		retval = snd_compr_next_track(stream);
+		break;
 	}
 	mutex_unlock(&stream->device->lock);
 	return retval;
 }
 static const struct file_operations snd_compr_file_ops = {
 		.owner =	THIS_MODULE,
 		.open =		snd_compr_open,
 		.release =	snd_compr_free,
 		.write =	snd_compr_write,
 		.read =		snd_compr_read,
 		.unlocked_ioctl = snd_compr_ioctl,
 		.mmap =		snd_compr_mmap,
 		.poll =		snd_compr_poll,
 };
 static int snd_compress_dev_register(struct snd_device *device)
 {
 	int ret = -EINVAL;
 	char str[16];
 	struct snd_compr *compr;
 	if (snd_BUG_ON(!device || !device->device_data))
 		return -EBADFD;
 	compr = device->device_data;
 	sprintf(str, "comprC%iD%i", compr->card->number, compr->device);
 	pr_debug("reg %s for device %s, direction %d\n", str, compr->name,
 			compr->direction);
 	/* register compressed device */
 	ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card,
 			compr->device, &snd_compr_file_ops, compr, str);
 	if (ret < 0) {
 		pr_err("snd_register_device failed\n %d", ret);
 		return ret;
 	}
 	return ret;
 }
 static int snd_compress_dev_disconnect(struct snd_device *device)
 {
 	struct snd_compr *compr;
 	compr = device->device_data;
 	snd_unregister_device(compr->direction, compr->card, compr->device);
 	return 0;
 }
 /*
  * snd_compress_new: create new compress device
  * @card: sound card pointer
  * @device: device number
  * @dirn: device direction, should be of type enum snd_compr_direction
  * @compr: compress device pointer
  */
 int snd_compress_new(struct snd_card *card, int device,
 			int dirn, struct snd_compr *compr)
 {
 	static struct snd_device_ops ops = {
 		.dev_free = NULL,
 		.dev_register = snd_compress_dev_register,
 		.dev_disconnect = snd_compress_dev_disconnect,
 	};
 	compr->card = card;
 	compr->device = device;
 	compr->direction = dirn;
 	return snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
 }
 EXPORT_SYMBOL_GPL(snd_compress_new);
 static int snd_compress_add_device(struct snd_compr *device)
 {
 	int ret;
 	if (!device->card)
 		return -EINVAL;
 	/* register the card */
 	ret = snd_card_register(device->card);
 	if (ret)
 		goto out;
 	return 0;
 out:
 	pr_err("failed with %d\n", ret);
 	return ret;
 }
 static int snd_compress_remove_device(struct snd_compr *device)
 {
 	return snd_card_free(device->card);
 }
 /**
  * snd_compress_register - register compressed device
  *
  * @device: compressed device to register
  */
 int snd_compress_register(struct snd_compr *device)
 {
 	int retval;
 	if (device->name == NULL || device->dev == NULL || device->ops == NULL)
 		return -EINVAL;
 	pr_debug("Registering compressed device %s\n", device->name);
 	if (snd_BUG_ON(!device->ops->open))
 		return -EINVAL;
 	if (snd_BUG_ON(!device->ops->free))
 		return -EINVAL;
 	if (snd_BUG_ON(!device->ops->set_params))
 		return -EINVAL;
 	if (snd_BUG_ON(!device->ops->trigger))
 		return -EINVAL;
 	mutex_init(&device->lock);
 	/* register a compressed card */
 	mutex_lock(&device_mutex);
 	retval = snd_compress_add_device(device);
 	mutex_unlock(&device_mutex);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(snd_compress_register);
 int snd_compress_deregister(struct snd_compr *device)
 {
 	pr_debug("Removing compressed device %s\n", device->name);
 	mutex_lock(&device_mutex);
 	snd_compress_remove_device(device);
 	mutex_unlock(&device_mutex);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(snd_compress_deregister);
 static int __init snd_compress_init(void)
 {
 	return 0;
 }
 static void __exit snd_compress_exit(void)
 {
 }
 module_init(snd_compress_init);
 module_exit(snd_compress_exit);
 MODULE_DESCRIPTION("ALSA Compressed offload framework");
 MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>");
 MODULE_LICENSE("GPL v2");