RE: [virtio-dev] Request for a new device number for a virtio-audio device.

[Anton Yakovlev <Anton.Yakovlev@opensynergy.com>]

[-- Attachment #1: Type: text/plain, Size: 999 bytes --]

Hi all,

I updated the header file according to the comments and overall flow of the discussion (see attachment). Also I replaced defines with enumerations and

1. Added new PCM request type for assigning particular virtual queue for particular substream.
2. Removed the rewind/forward request types, since these are actually not needed.

Looking forward for your comments.

Anton Yakovlev
Senior Software Engineer

OpenSynergy GmbH
Rotherstr. 20, 10245 Berlin

www.opensynergy.com

Please mind our privacy notice<https://www.opensynergy.com/datenschutzerklaerung/privacy-notice-for-business-partners-pursuant-to-article-13-of-the-general-data-protection-regulation-gdpr/> pursuant to Art. 13 GDPR. // Unsere Hinweise zum Datenschutz gem. Art. 13 DSGVO finden Sie hier.<https://www.opensynergy.com/de/datenschutzerklaerung/datenschutzhinweise-fuer-geschaeftspartner-gem-art-13-dsgvo/>
COQOS Hypervisor certified by TÜV SÜD
                [COQOS Hypervisor certified by TÜV SÜD]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: virtio_snd.h --]
[-- Type: text/x-chdr; name="virtio_snd.h", Size: 14175 bytes --]

/*
 * Copyright (C) 2019  OpenSynergy GmbH
 *
 * This header is BSD licensed so anyone can use the definitions to
 * implement compatible drivers/servers.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of OpenSynergy GmbH nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE. */

#ifndef VIRTIO_SND_IF_H
#define VIRTIO_SND_IF_H

#include <linux/virtio_types.h>

/*******************************************************************************
 * COMMON DEFINITIONS
 */

/* a configuration space */
struct virtio_snd_config
{
    /* maximum # of available virtual queues (including the control queue) */
    __virtio32 nqueues;
};

/* supported function types */
enum
{
    VIRTIO_SND_FN_BASE,
    VIRTIO_SND_FN_PCM
};

/* supported descriptor types */
enum
{
    VIRTIO_SND_DESC_PCM,
    VIRTIO_SND_DESC_PCM_STREAM
};

/* supported control request types */
enum
{
    /* --- base request types --- */
    VIRTIO_SND_BASE_R_GET_CFG,
    /* --- pcm request types --- */
    VIRTIO_SND_PCM_R_GET_FEATURE = 0x1000,
    VIRTIO_SND_PCM_R_SET_FEATURE,
    VIRTIO_SND_PCM_R_SET_QUEUE,
    VIRTIO_SND_PCM_R_SET_FORMAT,
    VIRTIO_SND_PCM_R_PREPARE,
    VIRTIO_SND_PCM_R_START,
    VIRTIO_SND_PCM_R_STOP,
    VIRTIO_SND_PCM_R_PAUSE,
    VIRTIO_SND_PCM_R_UNPAUSE
};

/* supported error codes */
enum
{
    /* --- generic error codes --- */
    /* no errors */
    VIRTIO_SND_E_SUCCESS,
    /* an undefined error */
    VIRTIO_SND_E_GENERAL,
    /* not supported input parameter(s) */
    VIRTIO_SND_E_NOTSUPPORTED,
    /* invalid input parameter(s) */
    VIRTIO_SND_E_INVALID,
    /* I/O error */
    VIRTIO_SND_E_IO,
    /* --- pcm error codes --- */
    VIRTIO_SND_PCM_E_NOT_READY = 0x1000
};

/* a generic request header */
struct virtio_snd_req
{
    __virtio16 function;
    __virtio16 request;
};

/* a generic response header */
struct virtio_snd_rsp
{
    __virtio32 status; /* VIRTIO_SND_E_XXX */
};

/* a generic descriptor */
struct virtio_snd_generic_desc
{
    __u8 length;
    __u8 type;
    __u16 padding;
};

/*******************************************************************************
 * BASE FUNCTION DEFINITIONS
 */

/* a maximum possible configuration data size (in bytes) */
#define VIRTIO_SND_BASE_CFG_MAX_SIZE    1024

/* a response containing device configuration */
struct virtio_snd_base_configuration
{
    struct virtio_snd_rsp hdr;
    /* size in bytes of configuration data */
    __virtio32 length;
    /* configuration data */
    __u8 data[VIRTIO_SND_BASE_CFG_MAX_SIZE];
};

/*******************************************************************************
 * PCM FUNCTION DEFINITIONS
 */

/* supported PCM stream types */
enum
{
    VIRTIO_SND_PCM_T_PLAYBACK,
    VIRTIO_SND_PCM_T_CAPTURE
};

/* supported PCM stream features */
enum
{
    VIRTIO_SND_PCM_FEAT_UPDATE_FREQUENCY,
    VIRTIO_SND_PCM_FEAT_CHANNEL_MAP
};

#define VIRTIO_SND_PCM_FEATBIT(bit)     (1U << VIRTIO_SND_PCM_FEAT_ ## bit)

enum
{
    VIRTIO_SND_PCM_FEATBIT_UPDATE_FREQUENCY =
        VIRTIO_SND_PCM_FEATBIT(UPDATE_FREQUENCY),
    VIRTIO_SND_PCM_FEATBIT_CHANNEL_MAP =
        VIRTIO_SND_PCM_FEATBIT(CHANNEL_MAP)
};

/* supported PCM sample formats */
enum
{
    VIRTIO_SND_PCM_FMT_S8,
    VIRTIO_SND_PCM_FMT_U8,
    VIRTIO_SND_PCM_FMT_S16,
    VIRTIO_SND_PCM_FMT_U16,
    VIRTIO_SND_PCM_FMT_S24,
    VIRTIO_SND_PCM_FMT_U24,
    VIRTIO_SND_PCM_FMT_S32,
    VIRTIO_SND_PCM_FMT_U32,
    VIRTIO_SND_PCM_FMT_FLOAT,
    VIRTIO_SND_PCM_FMT_FLOAT64,
    VIRTIO_SND_PCM_FMT_S20,
    VIRTIO_SND_PCM_FMT_U20,
    VIRTIO_SND_PCM_FMT_S24_3,
    VIRTIO_SND_PCM_FMT_U24_3,
    VIRTIO_SND_PCM_FMT_S20_3,
    VIRTIO_SND_PCM_FMT_U20_3,
    VIRTIO_SND_PCM_FMT_S18_3,
    VIRTIO_SND_PCM_FMT_U18_3
};

#define VIRTIO_SND_PCM_FMTBIT(bit)      (1ULL << VIRTIO_SND_PCM_FMT_ ## bit)

enum
{
    VIRTIO_SND_PCM_FMTBIT_S8 = VIRTIO_SND_PCM_FMTBIT(S8),
    VIRTIO_SND_PCM_FMTBIT_U8 = VIRTIO_SND_PCM_FMTBIT(U8),
    VIRTIO_SND_PCM_FMTBIT_S16 = VIRTIO_SND_PCM_FMTBIT(S16),
    VIRTIO_SND_PCM_FMTBIT_U16 = VIRTIO_SND_PCM_FMTBIT(U16),
    VIRTIO_SND_PCM_FMTBIT_S24 = VIRTIO_SND_PCM_FMTBIT(S24),
    VIRTIO_SND_PCM_FMTBIT_U24 = VIRTIO_SND_PCM_FMTBIT(U24),
    VIRTIO_SND_PCM_FMTBIT_S32 = VIRTIO_SND_PCM_FMTBIT(S32),
    VIRTIO_SND_PCM_FMTBIT_U32 = VIRTIO_SND_PCM_FMTBIT(U32),
    VIRTIO_SND_PCM_FMTBIT_FLOAT = VIRTIO_SND_PCM_FMTBIT(FLOAT),
    VIRTIO_SND_PCM_FMTBIT_FLOAT64 = VIRTIO_SND_PCM_FMTBIT(FLOAT64),
    VIRTIO_SND_PCM_FMTBIT_S20 = VIRTIO_SND_PCM_FMTBIT(S20),
    VIRTIO_SND_PCM_FMTBIT_U20 = VIRTIO_SND_PCM_FMTBIT(U20),
    VIRTIO_SND_PCM_FMTBIT_S24_3 = VIRTIO_SND_PCM_FMTBIT(S24_3),
    VIRTIO_SND_PCM_FMTBIT_U24_3 = VIRTIO_SND_PCM_FMTBIT(U24_3),
    VIRTIO_SND_PCM_FMTBIT_S20_3 = VIRTIO_SND_PCM_FMTBIT(S20_3),
    VIRTIO_SND_PCM_FMTBIT_U20_3 = VIRTIO_SND_PCM_FMTBIT(U20_3),
    VIRTIO_SND_PCM_FMTBIT_S18_3 = VIRTIO_SND_PCM_FMTBIT(S18_3),
    VIRTIO_SND_PCM_FMTBIT_U18_3 = VIRTIO_SND_PCM_FMTBIT(U18_3)
};

/* supported PCM frame rates */
enum
{
    VIRTIO_SND_PCM_RATE_8000,
    VIRTIO_SND_PCM_RATE_11025,
    VIRTIO_SND_PCM_RATE_16000,
    VIRTIO_SND_PCM_RATE_22050,
    VIRTIO_SND_PCM_RATE_32000,
    VIRTIO_SND_PCM_RATE_44100,
    VIRTIO_SND_PCM_RATE_48000,
    VIRTIO_SND_PCM_RATE_64000,
    VIRTIO_SND_PCM_RATE_88200,
    VIRTIO_SND_PCM_RATE_96000,
    VIRTIO_SND_PCM_RATE_176400,
    VIRTIO_SND_PCM_RATE_192000
};

#define VIRTIO_SND_PCM_RATEBIT(bit)     (1U << VIRTIO_SND_PCM_RATE_ ## bit)

enum
{
    VIRTIO_SND_PCM_RATEBIT_8000 = VIRTIO_SND_PCM_RATEBIT(8000),
    VIRTIO_SND_PCM_RATEBIT_11025 = VIRTIO_SND_PCM_RATEBIT(11025),
    VIRTIO_SND_PCM_RATEBIT_16000 = VIRTIO_SND_PCM_RATEBIT(16000),
    VIRTIO_SND_PCM_RATEBIT_22050 = VIRTIO_SND_PCM_RATEBIT(22050),
    VIRTIO_SND_PCM_RATEBIT_32000 = VIRTIO_SND_PCM_RATEBIT(32000),
    VIRTIO_SND_PCM_RATEBIT_44100 = VIRTIO_SND_PCM_RATEBIT(44100),
    VIRTIO_SND_PCM_RATEBIT_48000 = VIRTIO_SND_PCM_RATEBIT(48000),
    VIRTIO_SND_PCM_RATEBIT_64000 = VIRTIO_SND_PCM_RATEBIT(64000),
    VIRTIO_SND_PCM_RATEBIT_88200 = VIRTIO_SND_PCM_RATEBIT(88200),
    VIRTIO_SND_PCM_RATEBIT_96000 = VIRTIO_SND_PCM_RATEBIT(96000),
    VIRTIO_SND_PCM_RATEBIT_176400 = VIRTIO_SND_PCM_RATEBIT(176400),
    VIRTIO_SND_PCM_RATEBIT_192000 = VIRTIO_SND_PCM_RATEBIT(192000)
};

/* PCM channel map definitions */

enum
{
    /* All channels have fixed channel positions */
    VIRTIO_SND_PCM_CHMAP_FIXED,
    /* All channels are swappable (e.g. {FL/FR/RL/RR} -> {RR/RL/FR/FL}) */
    VIRTIO_SND_PCM_CHMAP_VARIABLE,
    /* Only pair-wise channels are swappable (e.g. {FL/FR/RL/RR} -> {RL/RR/FL/FR}) */
    VIRTIO_SND_PCM_CHMAP_PAIRED
};

/* Standard channel position definition */
enum
{
    VIRTIO_SND_PCM_CH_NONE,     /* undefined */
    VIRTIO_SND_PCM_CH_NA,       /* silent */
    VIRTIO_SND_PCM_CH_MONO,     /* mono stream */
    VIRTIO_SND_PCM_CH_FL,       /* front left */
    VIRTIO_SND_PCM_CH_FR,       /* front right */
    VIRTIO_SND_PCM_CH_RL,       /* rear left */
    VIRTIO_SND_PCM_CH_RR,       /* rear right */
    VIRTIO_SND_PCM_CH_FC,       /* front center */
    VIRTIO_SND_PCM_CH_LFE,      /* low frequency (LFE) */
    VIRTIO_SND_PCM_CH_SL,       /* side left */
    VIRTIO_SND_PCM_CH_SR,       /* side right */
    VIRTIO_SND_PCM_CH_RC,       /* rear center */
    VIRTIO_SND_PCM_CH_FLC,      /* front left center */
    VIRTIO_SND_PCM_CH_FRC,      /* front right center */
    VIRTIO_SND_PCM_CH_RLC,      /* rear left center */
    VIRTIO_SND_PCM_CH_RRC,      /* rear right center */
    VIRTIO_SND_PCM_CH_FLW,      /* front left wide */
    VIRTIO_SND_PCM_CH_FRW,      /* front right wide */
    VIRTIO_SND_PCM_CH_FLH,      /* front left high */
    VIRTIO_SND_PCM_CH_FCH,      /* front center high */
    VIRTIO_SND_PCM_CH_FRH,      /* front right high */
    VIRTIO_SND_PCM_CH_TC,       /* top center */
    VIRTIO_SND_PCM_CH_TFL,      /* top front left */
    VIRTIO_SND_PCM_CH_TFR,      /* top front right */
    VIRTIO_SND_PCM_CH_TFC,      /* top front center */
    VIRTIO_SND_PCM_CH_TRL,      /* top rear left */
    VIRTIO_SND_PCM_CH_TRR,      /* top rear right */
    VIRTIO_SND_PCM_CH_TRC,      /* top rear center */
    VIRTIO_SND_PCM_CH_TFLC,     /* top front left center */
    VIRTIO_SND_PCM_CH_TFRC,     /* top front right center */
    VIRTIO_SND_PCM_CH_TSL,      /* top side left */
    VIRTIO_SND_PCM_CH_TSR,      /* top side right */
    VIRTIO_SND_PCM_CH_LLFE,     /* left LFE */
    VIRTIO_SND_PCM_CH_RLFE,     /* right LFE */
    VIRTIO_SND_PCM_CH_BC,       /* bottom center */
    VIRTIO_SND_PCM_CH_BLC,      /* bottom left center */
    VIRTIO_SND_PCM_CH_BRC       /* bottom right center */
};

/*
 * The channel is phase inverted (thus summing left and right channels would
 * result in almost silence).
 */
enum
{
    VIRTIO_SND_PCM_CH_F_PHASE_INVERSE = 0x01
};

/* PCM function descriptor */
struct virtio_snd_pcm_desc
{
    /* sizeof(struct virtio_snd_pcm_desc) */
    __u8 length;
    /* VIRTIO_SND_DESC_PCM */
    __u8 type;
    /* a PCM function ID (assigned by the device) */
    __u8 pcm_id;
    /* # of PCM stream descriptors in the configuration (one per supported PCM stream type) */
    __u8 nstreams;
};

/* PCM stream descriptor */
struct virtio_snd_pcm_stream_desc
{
    /* sizeof(struct virtio_snd_pcm_stream_desc) */
    __u8 length;
    /* VIRTIO_SND_DESC_PCM_STREAM */
    __u8 type;
    /* a PCM stream type (VIRTIO_SND_PCM_T_XXX) */
    __u8 stream_type;
    /* # of substreams for the specified stream type */
    __u8 nsubstreams;
    /* minimum # of supported channels */
    __u8 channels_min;
    /* maximum # of supported channels */
    __u8 channels_max;
    /* supported PCM stream features (VIRTIO_SND_PCM_FEATBIT_XXX, can be ORed) */
    __u8 features;
    /* # of supported channel maps */
    __u8 nchmaps;
    /* supported sample formats (VIRTIO_SND_PCM_FMTBIT_XXX, can be ORed) */
    __virtio32 formats;
    /* supported frame rates (VIRTIO_SND_PCM_RATEBIT_XXX, can be ORed) */
    __virtio32 rates;
};

/* PCM substream request header */
struct virtio_snd_pcm_hdr
{
    /* VIRTIO_SND_FN_PCM */
    __virtio16 function;
    /* a PCM request type (VIRTIO_SND_PCM_R_XXX) */
    __virtio16 request;
    /* a PCM identifier (assigned in configuration) */
    __u8 pcm_id;
    /* a PCM stream type (VIRTIO_SND_PCM_T_XXX) */
    __u8 stream_type;
    /* a PCM substream identifier [0 .. virtio_snd_pcm_stream_desc::nsubstreams - 1] */
    __u8 substream_id;
    __u8 padding;
};

/* get/set PCM substream feature */
struct virtio_snd_pcm_feature
{
    /* VIRTIO_SND_FN_PCM */
    __virtio16 function;
    /* VIRTIO_SND_PCM_R_GET_FEATURE / VIRTIO_SND_PCM_R_SET_FEATURE */
    __virtio16 request;
    /* a PCM identifier (assigned in configuration) */
    __u8 pcm_id;
    /* a PCM stream type (VIRTIO_SND_PCM_T_XXX) */
    __u8 stream_type;
    /* a PCM substream identifier [0 .. virtio_snd_pcm_stream_desc::nsubstreams - 1] */
    __u8 substream_id;
    /* a selected PCM substream feature (VIRTIO_SND_PCM_FEAT_XXX) */
    __u8 feature;
    /* a feature-specific request data */
    /*
     * VIRTIO_SND_PCM_FEAT_UPDATE_FREQUENCY [SET-only]
     *   .data = an approximate update frequency in bytes
     * VIRTIO_SND_PCM_FEAT_CHANNEL_MAP [GET/SET]
     *   GET:
     *     .data = a channel map index [0 .. virtio_snd_pcm_stream_desc::nchmaps - 1]
     *   SET:
     *     .data = a pseudophysical start address of the virtio_snd_pcm_chmap_data structure
     */
    __virtio64 data;
};

#define VIRTIO_SND_PCM_CH_MAX           256

/* PCM channel information */
struct virtio_snd_pcm_chinfo
{
    /* a PCM channel position (VIRTIO_SND_PCM_CH_XXX) */
    __u8 position;
    /* a PCM channel flags (VIRTIO_SND_PCM_CH_F_XXX, can be ORed) */
    __u8 flags;
};

/* PCM channel map data */
struct virtio_snd_pcm_chmap_data
{
    /* # of valid entries in the PCM channel map */
    __virtio32 nchannels;
    /* a PCM channel map */
    struct virtio_snd_pcm_chinfo channel_map[VIRTIO_SND_PCM_CH_MAX];
};

/* a response containing PCM channel map */
struct virtio_snd_pcm_chmap
{
    struct virtio_snd_rsp hdr;
    /* a channel map type (VIRTIO_SND_PCM_CHMAP_XXX) */
    __u8 type;
    /* reserved, must be zero */
    __u8 reserved[3];
    /* a channel map data */
    struct virtio_snd_pcm_chmap_data data;
};

/* assign data queue for PCM substream */
struct virtio_snd_pcm_set_queue
{
    /* .request = VIRTIO_SND_PCM_R_SET_QUEUE */
    struct virtio_snd_pcm_hdr hdr;
    /* a virtual queue index */
    __virtio32 queue;
};

/* set PCM substream format */
struct virtio_snd_pcm_set_format
{
    /* .request = VIRTIO_SND_PCM_R_SET_FORMAT */
    struct virtio_snd_pcm_hdr hdr;
    /* # of channels */
    __virtio16 channels;
    /* a PCM sample format (VIRTIO_SND_PCM_FMT_XXX) */
    __virtio16 format;
    /* a PCM frame rate (VIRTIO_SND_PCM_RATE_XXX) */
    __virtio16 rate;
    __u16 padding;
};

#endif /* VIRTIO_SND_IF_H */

[-- Attachment #3: Type: text/plain, Size: 208 bytes --]


---------------------------------------------------------------------
To unsubscribe, e-mail: virtio-dev-unsubscribe@lists.oasis-open.org
For additional commands, e-mail: virtio-dev-help@lists.oasis-open.org