// SPDX-License-Identifier: GPL-2.0 OR MIT

/*
 * Xen para-virtual sound device
 *
 * Copyright (C) 2016-2018 EPAM Systems Inc.
 *
 * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
 */

#include <xen/xenbus.h>

#include <xen/interface/io/sndif.h>

#include "xen_snd_front.h"
#include "xen_snd_front_cfg.h"

/* Maximum number of supported streams. */
#define VSND_MAX_STREAM         8

struct cfg_hw_sample_rate {
        const char *name;
        unsigned int mask;
        unsigned int value;
};

static const struct cfg_hw_sample_rate CFG_HW_SUPPORTED_RATES[] = {
        { .name = "5512",   .mask = SNDRV_PCM_RATE_5512,   .value = 5512 },
        { .name = "8000",   .mask = SNDRV_PCM_RATE_8000,   .value = 8000 },
        { .name = "11025",  .mask = SNDRV_PCM_RATE_11025,  .value = 11025 },
        { .name = "16000",  .mask = SNDRV_PCM_RATE_16000,  .value = 16000 },
        { .name = "22050",  .mask = SNDRV_PCM_RATE_22050,  .value = 22050 },
        { .name = "32000",  .mask = SNDRV_PCM_RATE_32000,  .value = 32000 },
        { .name = "44100",  .mask = SNDRV_PCM_RATE_44100,  .value = 44100 },
        { .name = "48000",  .mask = SNDRV_PCM_RATE_48000,  .value = 48000 },
        { .name = "64000",  .mask = SNDRV_PCM_RATE_64000,  .value = 64000 },
        { .name = "96000",  .mask = SNDRV_PCM_RATE_96000,  .value = 96000 },
        { .name = "176400", .mask = SNDRV_PCM_RATE_176400, .value = 176400 },
        { .name = "192000", .mask = SNDRV_PCM_RATE_192000, .value = 192000 },
};

struct cfg_hw_sample_format {
        const char *name;
        u64 mask;
};

static const struct cfg_hw_sample_format CFG_HW_SUPPORTED_FORMATS[] = {
        {
                .name = XENSND_PCM_FORMAT_U8_STR,
                .mask = SNDRV_PCM_FMTBIT_U8
        },
        {
                .name = XENSND_PCM_FORMAT_S8_STR,
                .mask = SNDRV_PCM_FMTBIT_S8
        },
        {
                .name = XENSND_PCM_FORMAT_U16_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_U16_LE
        },
        {
                .name = XENSND_PCM_FORMAT_U16_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_U16_BE
        },
        {
                .name = XENSND_PCM_FORMAT_S16_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_S16_LE
        },
        {
                .name = XENSND_PCM_FORMAT_S16_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_S16_BE
        },
        {
                .name = XENSND_PCM_FORMAT_U24_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_U24_LE
        },
        {
                .name = XENSND_PCM_FORMAT_U24_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_U24_BE
        },
        {
                .name = XENSND_PCM_FORMAT_S24_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_S24_LE
        },
        {
                .name = XENSND_PCM_FORMAT_S24_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_S24_BE
        },
        {
                .name = XENSND_PCM_FORMAT_U32_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_U32_LE
        },
        {
                .name = XENSND_PCM_FORMAT_U32_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_U32_BE
        },
        {
                .name = XENSND_PCM_FORMAT_S32_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_S32_LE
        },
        {
                .name = XENSND_PCM_FORMAT_S32_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_S32_BE
        },
        {
                .name = XENSND_PCM_FORMAT_A_LAW_STR,
                .mask = SNDRV_PCM_FMTBIT_A_LAW
        },
        {
                .name = XENSND_PCM_FORMAT_MU_LAW_STR,
                .mask = SNDRV_PCM_FMTBIT_MU_LAW
        },
        {
                .name = XENSND_PCM_FORMAT_F32_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_FLOAT_LE
        },
        {
                .name = XENSND_PCM_FORMAT_F32_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_FLOAT_BE
        },
        {
                .name = XENSND_PCM_FORMAT_F64_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_FLOAT64_LE
        },
        {
                .name = XENSND_PCM_FORMAT_F64_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_FLOAT64_BE
        },
        {
                .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE_STR,
                .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
        },
        {
                .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE_STR,
                .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
        },
        {
                .name = XENSND_PCM_FORMAT_IMA_ADPCM_STR,
                .mask = SNDRV_PCM_FMTBIT_IMA_ADPCM
        },
        {
                .name = XENSND_PCM_FORMAT_MPEG_STR,
                .mask = SNDRV_PCM_FMTBIT_MPEG
        },
        {
                .name = XENSND_PCM_FORMAT_GSM_STR,
                .mask = SNDRV_PCM_FMTBIT_GSM
        },
};

static void cfg_hw_rates(char *list, unsigned int len,
                         const char *path, struct snd_pcm_hardware *pcm_hw)
{
        char *cur_rate;
        unsigned int cur_mask;
        unsigned int cur_value;
        unsigned int rates;
        unsigned int rate_min;
        unsigned int rate_max;
        int i;

        rates = 0;
        rate_min = -1;
        rate_max = 0;
        while ((cur_rate = strsep(&list, XENSND_LIST_SEPARATOR))) {
                for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_RATES); i++)
                        if (!strncasecmp(cur_rate,
                                         CFG_HW_SUPPORTED_RATES[i].name,
                                         XENSND_SAMPLE_RATE_MAX_LEN)) {
                                cur_mask = CFG_HW_SUPPORTED_RATES[i].mask;
                                cur_value = CFG_HW_SUPPORTED_RATES[i].value;
                                rates |= cur_mask;
                                if (rate_min > cur_value)
                                        rate_min = cur_value;
                                if (rate_max < cur_value)
                                        rate_max = cur_value;
                        }
        }

        if (rates) {
                pcm_hw->rates = rates;
                pcm_hw->rate_min = rate_min;
                pcm_hw->rate_max = rate_max;
        }
}

static void cfg_formats(char *list, unsigned int len,
                        const char *path, struct snd_pcm_hardware *pcm_hw)
{
        u64 formats;
        char *cur_format;
        int i;

        formats = 0;
        while ((cur_format = strsep(&list, XENSND_LIST_SEPARATOR))) {
                for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_FORMATS); i++)
                        if (!strncasecmp(cur_format,
                                         CFG_HW_SUPPORTED_FORMATS[i].name,
                                         XENSND_SAMPLE_FORMAT_MAX_LEN))
                                formats |= CFG_HW_SUPPORTED_FORMATS[i].mask;
        }

        if (formats)
                pcm_hw->formats = formats;
}

#define MAX_BUFFER_SIZE         (64 * 1024)
#define MIN_PERIOD_SIZE         64
#define MAX_PERIOD_SIZE         MAX_BUFFER_SIZE
#define USE_FORMATS             (SNDRV_PCM_FMTBIT_U8 | \
                                 SNDRV_PCM_FMTBIT_S16_LE)
#define USE_RATE                (SNDRV_PCM_RATE_CONTINUOUS | \
                                 SNDRV_PCM_RATE_8000_48000)
#define USE_RATE_MIN            5512
#define USE_RATE_MAX            48000
#define USE_CHANNELS_MIN        1
#define USE_CHANNELS_MAX        2
#define USE_PERIODS_MIN         2
#define USE_PERIODS_MAX         (MAX_BUFFER_SIZE / MIN_PERIOD_SIZE)

static const struct snd_pcm_hardware SND_DRV_PCM_HW_DEFAULT = {
        .info = (SNDRV_PCM_INFO_MMAP |
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_RESUME |
                 SNDRV_PCM_INFO_MMAP_VALID),
        .formats = USE_FORMATS,
        .rates = USE_RATE,
        .rate_min = USE_RATE_MIN,
        .rate_max = USE_RATE_MAX,
        .channels_min = USE_CHANNELS_MIN,
        .channels_max = USE_CHANNELS_MAX,
        .buffer_bytes_max = MAX_BUFFER_SIZE,
        .period_bytes_min = MIN_PERIOD_SIZE,
        .period_bytes_max = MAX_PERIOD_SIZE,
        .periods_min = USE_PERIODS_MIN,
        .periods_max = USE_PERIODS_MAX,
        .fifo_size = 0,
};

static void cfg_read_pcm_hw(const char *path,
                            struct snd_pcm_hardware *parent_pcm_hw,
                            struct snd_pcm_hardware *pcm_hw)
{
        char *list;
        int val;
        size_t buf_sz;
        unsigned int len;

        /* Inherit parent's PCM HW and read overrides from XenStore. */
        if (parent_pcm_hw)
                *pcm_hw = *parent_pcm_hw;
        else
                *pcm_hw = SND_DRV_PCM_HW_DEFAULT;

        val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MIN, 0);
        if (val)
                pcm_hw->channels_min = val;

        val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MAX, 0);
        if (val)
                pcm_hw->channels_max = val;

        list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_RATES, &len);
        if (!IS_ERR(list)) {
                cfg_hw_rates(list, len, path, pcm_hw);
                kfree(list);
        }

        list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_FORMATS, &len);
        if (!IS_ERR(list)) {
                cfg_formats(list, len, path, pcm_hw);
                kfree(list);
        }

        buf_sz = xenbus_read_unsigned(path, XENSND_FIELD_BUFFER_SIZE, 0);
        if (buf_sz)
                pcm_hw->buffer_bytes_max = buf_sz;

        /* Update configuration to match new values. */
        if (pcm_hw->channels_min > pcm_hw->channels_max)
                pcm_hw->channels_min = pcm_hw->channels_max;

        if (pcm_hw->rate_min > pcm_hw->rate_max)
                pcm_hw->rate_min = pcm_hw->rate_max;

        pcm_hw->period_bytes_max = pcm_hw->buffer_bytes_max;

        pcm_hw->periods_max = pcm_hw->period_bytes_max /
                pcm_hw->period_bytes_min;
}

static int cfg_get_stream_type(const char *path, int index,
                               int *num_pb, int *num_cap)
{
        char *str = NULL;
        char *stream_path;
        int ret;

        *num_pb = 0;
        *num_cap = 0;
        stream_path = kasprintf(GFP_KERNEL, "%s/%d", path, index);
        if (!stream_path) {
                ret = -ENOMEM;
                goto fail;
        }

        str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL);
        if (IS_ERR(str)) {
                ret = PTR_ERR(str);
                str = NULL;
                goto fail;
        }

        if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK,
                         sizeof(XENSND_STREAM_TYPE_PLAYBACK))) {
                (*num_pb)++;
        } else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE,
                              sizeof(XENSND_STREAM_TYPE_CAPTURE))) {
                (*num_cap)++;
        } else {
                ret = -EINVAL;
                goto fail;
        }
        ret = 0;

fail:
        kfree(stream_path);
        kfree(str);
        return ret;
}

static int cfg_stream(struct xen_snd_front_info *front_info,
                      struct xen_front_cfg_pcm_instance *pcm_instance,
                      const char *path, int index, int *cur_pb, int *cur_cap,
                      int *stream_cnt)
{
        char *str = NULL;
        char *stream_path;
        struct xen_front_cfg_stream *stream;
        int ret;

        stream_path = devm_kasprintf(&front_info->xb_dev->dev,
                                     GFP_KERNEL, "%s/%d", path, index);
        if (!stream_path) {
                ret = -ENOMEM;
                goto fail;
        }

        str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL);
        if (IS_ERR(str)) {
                ret = PTR_ERR(str);
                str = NULL;
                goto fail;
        }

        if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK,
                         sizeof(XENSND_STREAM_TYPE_PLAYBACK))) {
                stream = &pcm_instance->streams_pb[(*cur_pb)++];
        } else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE,
                              sizeof(XENSND_STREAM_TYPE_CAPTURE))) {
                stream = &pcm_instance->streams_cap[(*cur_cap)++];
        } else {
                ret = -EINVAL;
                goto fail;
        }

        /* Get next stream index. */
        stream->index = (*stream_cnt)++;
        stream->xenstore_path = stream_path;
        /*
         * Check XenStore if PCM HW configuration exists for this stream
         * and update if so, e.g. we inherit all values from device's PCM HW,
         * but can still override some of the values for the stream.
         */
        cfg_read_pcm_hw(stream->xenstore_path,
                        &pcm_instance->pcm_hw, &stream->pcm_hw);
        ret = 0;

fail:
        kfree(str);
        return ret;
}

static int cfg_device(struct xen_snd_front_info *front_info,
                      struct xen_front_cfg_pcm_instance *pcm_instance,
                      struct snd_pcm_hardware *parent_pcm_hw,
                      const char *path, int node_index, int *stream_cnt)
{
        char *str;
        char *device_path;
        int ret, i, num_streams;
        int num_pb, num_cap;
        int cur_pb, cur_cap;
        char node[3];

        device_path = kasprintf(GFP_KERNEL, "%s/%d", path, node_index);
        if (!device_path)
                return -ENOMEM;

        str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL);
        if (!IS_ERR(str)) {
                strscpy(pcm_instance->name, str, sizeof(pcm_instance->name));
                kfree(str);
        }

        pcm_instance->device_id = node_index;

        /*
         * Check XenStore if PCM HW configuration exists for this device
         * and update if so, e.g. we inherit all values from card's PCM HW,
         * but can still override some of the values for the device.
         */
        cfg_read_pcm_hw(device_path, parent_pcm_hw, &pcm_instance->pcm_hw);

        /* Find out how many streams were configured in Xen store. */
        num_streams = 0;
        do {
                snprintf(node, sizeof(node), "%d", num_streams);
                if (!xenbus_exists(XBT_NIL, device_path, node))
                        break;

                num_streams++;
        } while (num_streams < VSND_MAX_STREAM);

        pcm_instance->num_streams_pb = 0;
        pcm_instance->num_streams_cap = 0;
        /* Get number of playback and capture streams. */
        for (i = 0; i < num_streams; i++) {
                ret = cfg_get_stream_type(device_path, i, &num_pb, &num_cap);
                if (ret < 0)
                        goto fail;

                pcm_instance->num_streams_pb += num_pb;
                pcm_instance->num_streams_cap += num_cap;
        }

        if (pcm_instance->num_streams_pb) {
                pcm_instance->streams_pb =
                                devm_kcalloc(&front_info->xb_dev->dev,
                                             pcm_instance->num_streams_pb,
                                             sizeof(struct xen_front_cfg_stream),
                                             GFP_KERNEL);
                if (!pcm_instance->streams_pb) {
                        ret = -ENOMEM;
                        goto fail;
                }
        }

        if (pcm_instance->num_streams_cap) {
                pcm_instance->streams_cap =
                                devm_kcalloc(&front_info->xb_dev->dev,
                                             pcm_instance->num_streams_cap,
                                             sizeof(struct xen_front_cfg_stream),
                                             GFP_KERNEL);
                if (!pcm_instance->streams_cap) {
                        ret = -ENOMEM;
                        goto fail;
                }
        }

        cur_pb = 0;
        cur_cap = 0;
        for (i = 0; i < num_streams; i++) {
                ret = cfg_stream(front_info, pcm_instance, device_path, i,
                                 &cur_pb, &cur_cap, stream_cnt);
                if (ret < 0)
                        goto fail;
        }
        ret = 0;

fail:
        kfree(device_path);
        return ret;
}

int xen_snd_front_cfg_card(struct xen_snd_front_info *front_info,
                           int *stream_cnt)
{
        struct xenbus_device *xb_dev = front_info->xb_dev;
        struct xen_front_cfg_card *cfg = &front_info->cfg;
        int ret, num_devices, i;
        char node[3];

        *stream_cnt = 0;
        num_devices = 0;
        do {
                scnprintf(node, sizeof(node), "%d", num_devices);
                if (!xenbus_exists(XBT_NIL, xb_dev->nodename, node))
                        break;

                num_devices++;
        } while (num_devices < SNDRV_PCM_DEVICES);

        if (!num_devices) {
                dev_warn(&xb_dev->dev,
                         "No devices configured for sound card at %s\n",
                         xb_dev->nodename);
                return -ENODEV;
        }

        /* Start from default PCM HW configuration for the card. */
        cfg_read_pcm_hw(xb_dev->nodename, NULL, &cfg->pcm_hw);

        cfg->pcm_instances =
                        devm_kcalloc(&front_info->xb_dev->dev, num_devices,
                                     sizeof(struct xen_front_cfg_pcm_instance),
                                     GFP_KERNEL);
        if (!cfg->pcm_instances)
                return -ENOMEM;

        for (i = 0; i < num_devices; i++) {
                ret = cfg_device(front_info, &cfg->pcm_instances[i],
                                 &cfg->pcm_hw, xb_dev->nodename, i, stream_cnt);
                if (ret < 0)
                        return ret;
        }
        cfg->num_pcm_instances = num_devices;
        return 0;
}