From patchwork Mon Aug 7 11:50:44 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oleksandr Andrushchenko X-Patchwork-Id: 9885147 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 679A160363 for ; Mon, 7 Aug 2017 11:53:17 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 599B628514 for ; Mon, 7 Aug 2017 11:53:17 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 4E8382860D; Mon, 7 Aug 2017 11:53:17 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.8 required=2.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED, FREEMAIL_FROM, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=no version=3.3.1 Received: from alsa0.perex.cz (alsa0.perex.cz [77.48.224.243]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 1B85128514 for ; Mon, 7 Aug 2017 11:53:16 +0000 (UTC) Received: from alsa0.perex.cz (localhost [127.0.0.1]) by alsa0.perex.cz (Postfix) with ESMTP id B51AF26721F; Mon, 7 Aug 2017 13:51:15 +0200 (CEST) X-Original-To: alsa-devel@alsa-project.org Delivered-To: alsa-devel@alsa-project.org Received: by alsa0.perex.cz (Postfix, from userid 1000) id 9E96D26721F; Mon, 7 Aug 2017 13:51:12 +0200 (CEST) Received: from mail-lf0-f65.google.com (mail-lf0-f65.google.com [209.85.215.65]) by alsa0.perex.cz (Postfix) with ESMTP id 714312671CC for ; Mon, 7 Aug 2017 13:51:07 +0200 (CEST) Received: by mail-lf0-f65.google.com with SMTP id y15so148600lfd.5 for ; Mon, 07 Aug 2017 04:51:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=DpzgR9/XQL1KGtZDcxYEyxAJfzhH+y6vvaRCN9gS+R0=; b=jxXQ2+JQkEpRb6QJlR1FZEnaOhSjYyl2/n0+cFl2yMcgmEsyQEpmSwl5qwtg1OiGY6 HXVJ+HFuAWJixY5YnuoriLUL3y7fr1Rk1amBwF1xVa6QiQtBCfc/8tatKSKOrQ2+jYrP uhvHu+ZkUfpiS8uGeJOVfxpiukme5+/hJ0LQ8+va92EIk4xYKAGmw5GJKLM2bgPyZikA Htq5yV3yTRirb0Q+B6E8BiJCG57qZ0P5mUDKaPa1lLx35cxK9jhM9UHcGGH5gWlZaRYZ 24TIetZQ5h0wcyAtqeH20+8wT8Ef2yo7DILjWI7O29OXxza4thtoEQO5hi80eruso267 9/wA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=DpzgR9/XQL1KGtZDcxYEyxAJfzhH+y6vvaRCN9gS+R0=; b=NmKYfTpW2nsVxKWFeEEje2BFhNi57lyKKp81xVPz088z283FwR+a6i6ZQBVCdA21G3 cYyakUPQcIDslg8hwq6hF73tgReeP44gJcjLFYVEuirF1fdKCJZ762pEkCju5+Y/FcgO QG2EU0DEwNXtg+vwhIuzaCSLi/SoS1xL066VapZpsiGinH70ADQvlyXnQGmKoljXUlB4 owm7ReysLGAtcPrM39lcuOVYvjle647d1iOZRMZ8vXBaq3y+P6KLYsThw6jezyaWmXpa Rk16IvUeKv6EOPmkeTXtWiBEBPWeHYPmk1rmv/46iwaz21mqMVCDRCqHCO40wF5JEu4A 3bTA== X-Gm-Message-State: AHYfb5inQezeAkknZBirl6PCRMqFzxMdX3R1cl+loZMy/oxyNkdmI8YE +YBKvJFqS2E+aZBZ X-Received: by 10.25.142.9 with SMTP id q9mr81661lfd.33.1502106666325; Mon, 07 Aug 2017 04:51:06 -0700 (PDT) Received: from a2k-HP-ProDesk-600-G2-SFF.kyiv.epam.com (ll-51.209.223.85.sovam.net.ua. [85.223.209.51]) by smtp.gmail.com with ESMTPSA id n88sm2844587lja.43.2017.08.07.04.51.05 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 07 Aug 2017 04:51:05 -0700 (PDT) From: Oleksandr Andrushchenko To: alsa-devel@alsa-project.org, xen-devel@lists.xen.org, linux-kernel@vger.kernel.org Date: Mon, 7 Aug 2017 14:50:44 +0300 Message-Id: <1502106645-6731-11-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502106645-6731-1-git-send-email-andr2000@gmail.com> References: <1502106645-6731-1-git-send-email-andr2000@gmail.com> Cc: andr2000@gmail.com, Oleksandr Andrushchenko , tiwai@suse.com Subject: [alsa-devel] [PATCH RESEND 10/11] ALSA: vsnd: Implement communication with backend X-BeenThere: alsa-devel@alsa-project.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Alsa-devel mailing list for ALSA developers - http://www.alsa-project.org" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: alsa-devel-bounces@alsa-project.org Sender: alsa-devel-bounces@alsa-project.org X-Virus-Scanned: ClamAV using ClamSMTP From: Oleksandr Andrushchenko Implement frontend to backend communication according to the para-virtualized sound protocol: xen/interface/io/sndif.h. Signed-off-by: Oleksandr Andrushchenko --- sound/drivers/xen-front.c | 302 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 288 insertions(+), 14 deletions(-) diff --git a/sound/drivers/xen-front.c b/sound/drivers/xen-front.c index 7275e9cb38c0..8bfec43ef03a 100644 --- a/sound/drivers/xen-front.c +++ b/sound/drivers/xen-front.c @@ -38,6 +38,8 @@ * because of the fact it is already in use/reserved by the PV console. */ #define GRANT_INVALID_REF 0 +/* timeout in ms to wait for backend to respond */ +#define VSND_WAIT_BACK_MS 3000 /* maximum number of supported streams */ #define VSND_MAX_STREAM 8 @@ -151,10 +153,12 @@ struct xdrv_info { struct sdev_card_plat_data cfg_plat_data; }; +static inline void xdrv_evtchnl_flush(struct xdrv_evtchnl_info *channel); static inline void sh_buf_clear(struct sh_buf_info *buf); static void sh_buf_free(struct sh_buf_info *buf); static int sh_buf_alloc(struct xenbus_device *xb_dev, struct sh_buf_info *buf, unsigned int buffer_size); +static grant_ref_t sh_buf_get_dir_start(struct sh_buf_info *buf); static struct sdev_pcm_stream_info *sdrv_stream_get( struct snd_pcm_substream *substream) @@ -314,6 +318,234 @@ static void sdrv_copy_pcm_hw(struct snd_pcm_hardware *dst, } } +struct ALSA_SNDIF_SAMPLE_FORMAT { + uint8_t sndif; + snd_pcm_format_t alsa; +}; + +static struct ALSA_SNDIF_SAMPLE_FORMAT alsa_sndif_formats[] = { + { + .sndif = XENSND_PCM_FORMAT_U8, + .alsa = SNDRV_PCM_FORMAT_U8 + }, + { + .sndif = XENSND_PCM_FORMAT_S8, + .alsa = SNDRV_PCM_FORMAT_S8 + }, + { + .sndif = XENSND_PCM_FORMAT_U16_LE, + .alsa = SNDRV_PCM_FORMAT_U16_LE + }, + { + .sndif = XENSND_PCM_FORMAT_U16_BE, + .alsa = SNDRV_PCM_FORMAT_U16_BE + }, + { + .sndif = XENSND_PCM_FORMAT_S16_LE, + .alsa = SNDRV_PCM_FORMAT_S16_LE + }, + { + .sndif = XENSND_PCM_FORMAT_S16_BE, + .alsa = SNDRV_PCM_FORMAT_S16_BE + }, + { + .sndif = XENSND_PCM_FORMAT_U24_LE, + .alsa = SNDRV_PCM_FORMAT_U24_LE + }, + { + .sndif = XENSND_PCM_FORMAT_U24_BE, + .alsa = SNDRV_PCM_FORMAT_U24_BE + }, + { + .sndif = XENSND_PCM_FORMAT_S24_LE, + .alsa = SNDRV_PCM_FORMAT_S24_LE + }, + { + .sndif = XENSND_PCM_FORMAT_S24_BE, + .alsa = SNDRV_PCM_FORMAT_S24_BE + }, + { + .sndif = XENSND_PCM_FORMAT_U32_LE, + .alsa = SNDRV_PCM_FORMAT_U32_LE + }, + { + .sndif = XENSND_PCM_FORMAT_U32_BE, + .alsa = SNDRV_PCM_FORMAT_U32_BE + }, + { + .sndif = XENSND_PCM_FORMAT_S32_LE, + .alsa = SNDRV_PCM_FORMAT_S32_LE + }, + { + .sndif = XENSND_PCM_FORMAT_S32_BE, + .alsa = SNDRV_PCM_FORMAT_S32_BE + }, + { + .sndif = XENSND_PCM_FORMAT_A_LAW, + .alsa = SNDRV_PCM_FORMAT_A_LAW + }, + { + .sndif = XENSND_PCM_FORMAT_MU_LAW, + .alsa = SNDRV_PCM_FORMAT_MU_LAW + }, + { + .sndif = XENSND_PCM_FORMAT_F32_LE, + .alsa = SNDRV_PCM_FORMAT_FLOAT_LE + }, + { + .sndif = XENSND_PCM_FORMAT_F32_BE, + .alsa = SNDRV_PCM_FORMAT_FLOAT_BE + }, + { + .sndif = XENSND_PCM_FORMAT_F64_LE, + .alsa = SNDRV_PCM_FORMAT_FLOAT64_LE + }, + { + .sndif = XENSND_PCM_FORMAT_F64_BE, + .alsa = SNDRV_PCM_FORMAT_FLOAT64_BE + }, + { + .sndif = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE, + .alsa = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE + }, + { + .sndif = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE, + .alsa = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE + }, + { + .sndif = XENSND_PCM_FORMAT_IMA_ADPCM, + .alsa = SNDRV_PCM_FORMAT_IMA_ADPCM + }, + { + .sndif = XENSND_PCM_FORMAT_MPEG, + .alsa = SNDRV_PCM_FORMAT_MPEG + }, + { + .sndif = XENSND_PCM_FORMAT_GSM, + .alsa = SNDRV_PCM_FORMAT_GSM + }, +}; + +static int alsa_to_sndif_format(snd_pcm_format_t format) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(alsa_sndif_formats); i++) + if (alsa_sndif_formats[i].alsa == format) + return alsa_sndif_formats[i].sndif; + return -EINVAL; +} + +static void sdrv_stream_clear(struct sdev_pcm_stream_info *stream) +{ + stream->is_open = false; + stream->req_next_id = 0; + sh_buf_clear(&stream->sh_buf); +} + +static struct xensnd_req *sdrv_be_stream_prepare_req( + struct sdev_pcm_stream_info *stream, uint8_t operation) +{ + struct xensnd_req *req; + + req = RING_GET_REQUEST(&stream->evt_chnl->ring, + stream->evt_chnl->ring.req_prod_pvt); + req->operation = operation; + req->id = stream->req_next_id++; + stream->evt_chnl->resp_id = req->id; + return req; +} + +static void sdrv_be_stream_free(struct sdev_pcm_stream_info *stream) +{ + sh_buf_free(&stream->sh_buf); + sdrv_stream_clear(stream); +} + +static int sdrv_be_stream_do_io(struct xdrv_evtchnl_info *evtchnl) +{ + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + return -EIO; + + reinit_completion(&evtchnl->completion); + xdrv_evtchnl_flush(evtchnl); + return 0; +} + +static inline int sdrv_be_stream_wait_io(struct xdrv_evtchnl_info *evtchnl) +{ + if (wait_for_completion_timeout( + &evtchnl->completion, + msecs_to_jiffies(VSND_WAIT_BACK_MS)) <= 0) + return -ETIMEDOUT; + return 0; +} + +static int sdrv_be_stream_open(struct snd_pcm_substream *substream, + struct sdev_pcm_stream_info *stream) +{ + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct snd_pcm_runtime *runtime = substream->runtime; + struct xdrv_info *xdrv_info; + struct xensnd_req *req; + unsigned long flags; + int ret; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + ret = alsa_to_sndif_format(runtime->format); + if (ret < 0) { + dev_err(&xdrv_info->xb_dev->dev, + "Unsupported sample format: %d\n", runtime->format); + return ret; + } + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + stream->is_open = false; + req = sdrv_be_stream_prepare_req(stream, XENSND_OP_OPEN); + req->op.open.pcm_format = (uint8_t)ret; + req->op.open.pcm_channels = runtime->channels; + req->op.open.pcm_rate = runtime->rate; + req->op.open.buffer_sz = stream->sh_buf.vbuffer_sz; + req->op.open.gref_directory = sh_buf_get_dir_start(&stream->sh_buf); + + ret = sdrv_be_stream_do_io(stream->evt_chnl); + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); + + if (ret < 0) + return ret; + + ret = sdrv_be_stream_wait_io(stream->evt_chnl); + stream->is_open = ret < 0 ? false : true; + return ret; +} + +static int sdrv_be_stream_close(struct snd_pcm_substream *substream, + struct sdev_pcm_stream_info *stream) +{ + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct xdrv_info *xdrv_info; + struct xensnd_req *req; + unsigned long flags; + int ret; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + stream->is_open = false; + req = sdrv_be_stream_prepare_req(stream, XENSND_OP_CLOSE); + + ret = sdrv_be_stream_do_io(stream->evt_chnl); + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); + + if (ret < 0) + return ret; + + return sdrv_be_stream_wait_io(stream->evt_chnl); +} + static int sdrv_alsa_open(struct snd_pcm_substream *substream) { struct sdev_pcm_instance_info *pcm_instance = @@ -339,7 +571,7 @@ static int sdrv_alsa_open(struct snd_pcm_substream *substream) ret = sdrv_alsa_timer_create(substream); spin_lock_irqsave(&xdrv_info->io_lock, flags); - sh_buf_clear(&stream->sh_buf); + sdrv_stream_clear(stream); stream->evt_chnl = &xdrv_info->evt_chnls[stream->unique_id]; if (ret < 0) stream->evt_chnl->state = EVTCHNL_STATE_DISCONNECTED; @@ -378,7 +610,7 @@ static int sdrv_alsa_hw_params(struct snd_pcm_substream *substream, int ret; buffer_size = params_buffer_bytes(params); - sh_buf_clear(&stream->sh_buf); + sdrv_stream_clear(stream); xdrv_info = pcm_instance->card_info->xdrv_info; ret = sh_buf_alloc(xdrv_info->xb_dev, &stream->sh_buf, buffer_size); @@ -390,22 +622,18 @@ static int sdrv_alsa_hw_params(struct snd_pcm_substream *substream, dev_err(&xdrv_info->xb_dev->dev, "Failed to allocate buffers for stream idx %d\n", stream->unique_id); + sdrv_be_stream_free(stream); return ret; } static int sdrv_alsa_hw_free(struct snd_pcm_substream *substream) { - struct sdev_pcm_instance_info *pcm_instance = - snd_pcm_substream_chip(substream); struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); - struct xdrv_info *xdrv_info; - unsigned long flags; + int ret; - xdrv_info = pcm_instance->card_info->xdrv_info; - spin_lock_irqsave(&xdrv_info->io_lock, flags); - sh_buf_free(&stream->sh_buf); - spin_unlock_irqrestore(&xdrv_info->io_lock, flags); - return 0; + ret = sdrv_be_stream_close(substream, stream); + sdrv_be_stream_free(stream); + return ret; } static int sdrv_alsa_prepare(struct snd_pcm_substream *substream) @@ -413,8 +641,12 @@ static int sdrv_alsa_prepare(struct snd_pcm_substream *substream) struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); int ret = 0; - if (!stream->is_open) + if (!stream->is_open) { + ret = sdrv_be_stream_open(substream, stream); + if (ret < 0) + return ret; ret = sdrv_alsa_timer_prepare(substream); + } return ret; } @@ -446,7 +678,28 @@ static inline snd_pcm_uframes_t sdrv_alsa_pointer( static int sdrv_alsa_playback_do_write(struct snd_pcm_substream *substream, unsigned long pos, unsigned long count) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct xdrv_info *xdrv_info; + struct xensnd_req *req; + unsigned long flags; + int ret; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + req = sdrv_be_stream_prepare_req(stream, XENSND_OP_WRITE); + req->op.rw.length = count; + req->op.rw.offset = pos; + + ret = sdrv_be_stream_do_io(stream->evt_chnl); + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); + + if (ret < 0) + return ret; + + return sdrv_be_stream_wait_io(stream->evt_chnl); } static int sdrv_alsa_playback_copy_user(struct snd_pcm_substream *substream, @@ -479,7 +732,28 @@ static int sdrv_alsa_playback_copy_kernel(struct snd_pcm_substream *substream, static int sdrv_alsa_playback_do_read(struct snd_pcm_substream *substream, unsigned long pos, unsigned long count) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct xdrv_info *xdrv_info; + struct xensnd_req *req; + unsigned long flags; + int ret; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + req = sdrv_be_stream_prepare_req(stream, XENSND_OP_READ); + req->op.rw.length = count; + req->op.rw.offset = pos; + + ret = sdrv_be_stream_do_io(stream->evt_chnl); + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); + + if (ret < 0) + return ret; + + return sdrv_be_stream_wait_io(stream->evt_chnl); } static int sdrv_alsa_capture_copy_user(struct snd_pcm_substream *substream,