/* $NetBSD: ausoc.c,v 1.6 2021/01/27 03:10:21 thorpej Exp $ */

/*-
* Copyright (c) 2018 Jared McNeill <[email protected]>
* All rights reserved.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ausoc.c,v 1.6 2021/01/27 03:10:21 thorpej Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cpu.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/gpio.h>

#include <sys/audioio.h>
#include <dev/audio/audio_if.h>
#include <dev/audio/audio_dai.h>

#include <dev/fdt/fdtvar.h>

static const struct device_compatible_entry compat_data[] = {
       { .compat = "simple-audio-card" },
       DEVICE_COMPAT_EOL
};

struct ausoc_link {
       const char              *link_name;

       audio_dai_tag_t         link_cpu;
       audio_dai_tag_t         link_codec;
       audio_dai_tag_t         *link_aux;
       u_int                   link_naux;

       u_int                   link_mclk_fs;

       kmutex_t                link_lock;
       kmutex_t                link_intr_lock;
};

struct ausoc_softc {
       device_t                sc_dev;
       int                     sc_phandle;
       const char              *sc_name;

       struct ausoc_link       *sc_link;
       u_int                   sc_nlink;
};

static void
ausoc_close(void *priv)
{
       struct ausoc_link * const link = priv;
       u_int aux;

       for (aux = 0; aux < link->link_naux; aux++)
               audio_dai_close(link->link_aux[aux]);
       audio_dai_close(link->link_codec);
       audio_dai_close(link->link_cpu);
}

static int
ausoc_open(void *priv, int flags)
{
       struct ausoc_link * const link = priv;
       u_int aux;
       int error;

       error = audio_dai_open(link->link_cpu, flags);
       if (error)
               goto failed;

       error = audio_dai_open(link->link_codec, flags);
       if (error)
               goto failed;

       for (aux = 0; aux < link->link_naux; aux++) {
               error = audio_dai_open(link->link_aux[aux], flags);
               if (error)
                       goto failed;
       }

       return 0;

failed:
       ausoc_close(priv);
       return error;
}

static int
ausoc_query_format(void *priv, audio_format_query_t *afp)
{
       struct ausoc_link * const link = priv;

       return audio_dai_query_format(link->link_cpu, afp);
}

static int
ausoc_set_format(void *priv, int setmode,
   const audio_params_t *play, const audio_params_t *rec,
   audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
       struct ausoc_link * const link = priv;
       const audio_params_t *params = (setmode & AUMODE_PLAY) != 0 ?
           play : rec;
       int error;

       if (link->link_mclk_fs) {
               const u_int rate = params->sample_rate * link->link_mclk_fs;
               error = audio_dai_set_sysclk(link->link_codec, rate,
                   AUDIO_DAI_CLOCK_IN);
               if (error)
                       return error;
               error = audio_dai_set_sysclk(link->link_cpu, rate,
                   AUDIO_DAI_CLOCK_OUT);
               if (error)
                       return error;
       }

       error = audio_dai_mi_set_format(link->link_cpu, setmode,
           play, rec, pfil, rfil);
       if (error)
               return error;

       return audio_dai_mi_set_format(link->link_codec, setmode,
           play, rec, pfil, rfil);
}

static int
ausoc_set_port(void *priv, mixer_ctrl_t *mc)
{
       struct ausoc_link * const link = priv;

       return audio_dai_set_port(link->link_codec, mc);
}

static int
ausoc_get_port(void *priv, mixer_ctrl_t *mc)
{
       struct ausoc_link * const link = priv;

       return audio_dai_get_port(link->link_codec, mc);
}

static int
ausoc_query_devinfo(void *priv, mixer_devinfo_t *di)
{
       struct ausoc_link * const link = priv;

       return audio_dai_query_devinfo(link->link_codec, di);
}

static void *
ausoc_allocm(void *priv, int dir, size_t size)
{
       struct ausoc_link * const link = priv;

       return audio_dai_allocm(link->link_cpu, dir, size);
}

static void
ausoc_freem(void *priv, void *addr, size_t size)
{
       struct ausoc_link * const link = priv;

       return audio_dai_freem(link->link_cpu, addr, size);
}

static int
ausoc_getdev(void *priv, struct audio_device *adev)
{
       struct ausoc_link * const link = priv;

       /* Defaults */
       snprintf(adev->name, sizeof(adev->name), "%s", link->link_name);
       snprintf(adev->version, sizeof(adev->version), "");
       snprintf(adev->config, sizeof(adev->config), "ausoc");

       /* Codec can override */
       (void)audio_dai_getdev(link->link_codec, adev);

       return 0;
}

static int
ausoc_get_props(void *priv)
{
       struct ausoc_link * const link = priv;

       return audio_dai_get_props(link->link_cpu);
}

static int
ausoc_round_blocksize(void *priv, int bs, int mode,
   const audio_params_t *params)
{
       struct ausoc_link * const link = priv;

       return audio_dai_round_blocksize(link->link_cpu, bs, mode, params);
}

static size_t
ausoc_round_buffersize(void *priv, int dir, size_t bufsize)
{
       struct ausoc_link * const link = priv;

       return audio_dai_round_buffersize(link->link_cpu, dir, bufsize);
}

static int
ausoc_halt_output(void *priv)
{
       struct ausoc_link * const link = priv;
       u_int n;

       for (n = 0; n < link->link_naux; n++)
               audio_dai_halt(link->link_aux[n], AUMODE_PLAY);

       audio_dai_halt(link->link_codec, AUMODE_PLAY);

       return audio_dai_halt(link->link_cpu, AUMODE_PLAY);
}

static int
ausoc_halt_input(void *priv)
{
       struct ausoc_link * const link = priv;
       u_int n;

       for (n = 0; n < link->link_naux; n++)
               audio_dai_halt(link->link_aux[n], AUMODE_RECORD);

       audio_dai_halt(link->link_codec, AUMODE_RECORD);

       return audio_dai_halt(link->link_cpu, AUMODE_RECORD);
}

static int
ausoc_trigger_output(void *priv, void *start, void *end, int blksize,
   void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
       struct ausoc_link * const link = priv;
       int error;
       u_int n;

       for (n = 0; n < link->link_naux; n++) {
               error = audio_dai_trigger(link->link_aux[n], start, end,
                   blksize, intr, intrarg, params, AUMODE_PLAY);
               if (error)
                       goto failed;
       }
       error = audio_dai_trigger(link->link_codec, start, end, blksize,
           intr, intrarg, params, AUMODE_PLAY);
       if (error)
               goto failed;

       return audio_dai_trigger(link->link_cpu, start, end, blksize,
           intr, intrarg, params, AUMODE_PLAY);

failed:
       ausoc_halt_output(priv);
       return error;
}

static int
ausoc_trigger_input(void *priv, void *start, void *end, int blksize,
   void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
       struct ausoc_link * const link = priv;
       int error;
       u_int n;

       for (n = 0; n < link->link_naux; n++) {
               error = audio_dai_trigger(link->link_aux[n], start, end,
                   blksize, intr, intrarg, params, AUMODE_RECORD);
               if (error)
                       goto failed;
       }
       error = audio_dai_trigger(link->link_codec, start, end, blksize,
           intr, intrarg, params, AUMODE_RECORD);
       if (error)
               goto failed;

       return audio_dai_trigger(link->link_cpu, start, end, blksize,
           intr, intrarg, params, AUMODE_RECORD);

failed:
       ausoc_halt_input(priv);
       return error;
}

static void
ausoc_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread)
{
       struct ausoc_link * const link = priv;

       return audio_dai_get_locks(link->link_cpu, intr, thread);
}

static const struct audio_hw_if ausoc_hw_if = {
       .open = ausoc_open,
       .close = ausoc_close,
       .query_format = ausoc_query_format,
       .set_format = ausoc_set_format,
       .allocm = ausoc_allocm,
       .freem = ausoc_freem,
       .getdev = ausoc_getdev,
       .set_port = ausoc_set_port,
       .get_port = ausoc_get_port,
       .query_devinfo = ausoc_query_devinfo,
       .get_props = ausoc_get_props,
       .round_blocksize = ausoc_round_blocksize,
       .round_buffersize = ausoc_round_buffersize,
       .trigger_output = ausoc_trigger_output,
       .trigger_input = ausoc_trigger_input,
       .halt_output = ausoc_halt_output,
       .halt_input = ausoc_halt_input,
       .get_locks = ausoc_get_locks,
};

static int
ausoc_match(device_t parent, cfdata_t cf, void *aux)
{
       struct fdt_attach_args * const faa = aux;

       return of_compatible_match(faa->faa_phandle, compat_data);
}

static struct {
       const char *name;
       u_int fmt;
} ausoc_dai_formats[] = {
       { "i2s",        AUDIO_DAI_FORMAT_I2S },
       { "right_j",    AUDIO_DAI_FORMAT_RJ },
       { "left_j",     AUDIO_DAI_FORMAT_LJ },
       { "dsp_a",      AUDIO_DAI_FORMAT_DSPA },
       { "dsp_b",      AUDIO_DAI_FORMAT_DSPB },
       { "ac97",       AUDIO_DAI_FORMAT_AC97 },
       { "pdm",        AUDIO_DAI_FORMAT_PDM },
};

static int
ausoc_link_format(struct ausoc_softc *sc, struct ausoc_link *link, int phandle,
   int dai_phandle, bool single_link, u_int *format)
{
       const char *format_prop = single_link ?
           "simple-audio-card,format" : "format";
       const char *frame_master_prop = single_link ?
           "simple-audio-card,frame-master" : "frame-master";
       const char *bitclock_master_prop = single_link ?
           "simple-audio-card,bitclock-master" : "bitclock-master";
       const char *bitclock_inversion_prop = single_link ?
           "simple-audio-card,bitclock-inversion" : "bitclock-inversion";
       const char *frame_inversion_prop = single_link ?
           "simple-audio-card,frame-inversion" : "frame-inversion";

       u_int fmt, pol, clk;
       const char *s;
       u_int n;

       s = fdtbus_get_string(phandle, format_prop);
       if (s) {
               for (n = 0; n < __arraycount(ausoc_dai_formats); n++) {
                       if (strcmp(s, ausoc_dai_formats[n].name) == 0) {
                               fmt = ausoc_dai_formats[n].fmt;
                               break;
                       }
               }
               if (n == __arraycount(ausoc_dai_formats))
                       return EINVAL;
       } else {
               fmt = AUDIO_DAI_FORMAT_I2S;
       }

       const bool frame_master =
           dai_phandle == fdtbus_get_phandle(phandle, frame_master_prop);
       const bool bitclock_master =
           dai_phandle == fdtbus_get_phandle(phandle, bitclock_master_prop);
       if (frame_master) {
               clk = bitclock_master ?
                   AUDIO_DAI_CLOCK_CBM_CFM : AUDIO_DAI_CLOCK_CBS_CFM;
       } else {
               clk = bitclock_master ?
                   AUDIO_DAI_CLOCK_CBM_CFS : AUDIO_DAI_CLOCK_CBS_CFS;
       }

       const bool bitclock_inversion = of_hasprop(phandle, bitclock_inversion_prop);
       const bool frame_inversion = of_hasprop(phandle, frame_inversion_prop);
       if (bitclock_inversion) {
               pol = frame_inversion ?
                   AUDIO_DAI_POLARITY_IB_IF : AUDIO_DAI_POLARITY_IB_NF;
       } else {
               pol = frame_inversion ?
                   AUDIO_DAI_POLARITY_NB_IF : AUDIO_DAI_POLARITY_NB_NF;
       }

       *format = __SHIFTIN(fmt, AUDIO_DAI_FORMAT_MASK) |
                 __SHIFTIN(pol, AUDIO_DAI_POLARITY_MASK) |
                 __SHIFTIN(clk, AUDIO_DAI_CLOCK_MASK);

       return 0;
}

static void
ausoc_attach_link(struct ausoc_softc *sc, struct ausoc_link *link,
   int card_phandle, int link_phandle)
{
       const bool single_link = card_phandle == link_phandle;
       const char *cpu_prop = single_link ?
           "simple-audio-card,cpu" : "cpu";
       const char *codec_prop = single_link ?
           "simple-audio-card,codec" : "codec";
       const char *mclk_fs_prop = single_link ?
           "simple-audio-card,mclk-fs" : "mclk-fs";
       const char *node_name = fdtbus_get_string(link_phandle, "name");
       u_int n, format;

       const int cpu_phandle = of_find_firstchild_byname(link_phandle, cpu_prop);
       if (cpu_phandle <= 0) {
               aprint_error_dev(sc->sc_dev, "missing %s prop on %s node\n",
                   cpu_prop, node_name);
               return;
       }

       link->link_cpu = fdtbus_dai_acquire(cpu_phandle, "sound-dai");
       if (!link->link_cpu) {
               aprint_error_dev(sc->sc_dev,
                   "couldn't acquire cpu dai on %s node\n", node_name);
               return;
       }

       const int codec_phandle = of_find_firstchild_byname(link_phandle, codec_prop);
       if (codec_phandle <= 0) {
               aprint_error_dev(sc->sc_dev, "missing %s prop on %s node\n",
                   codec_prop, node_name);
               return;
       }

       link->link_codec = fdtbus_dai_acquire(codec_phandle, "sound-dai");
       if (!link->link_codec) {
               aprint_error_dev(sc->sc_dev,
                   "couldn't acquire codec dai on %s node\n", node_name);
               return;
       }

       for (;;) {
               if (fdtbus_dai_acquire_index(card_phandle,
                   "simple-audio-card,aux-devs", link->link_naux) == NULL)
                       break;
               link->link_naux++;
       }
       if (link->link_naux) {
               link->link_aux = kmem_zalloc(sizeof(audio_dai_tag_t) * link->link_naux, KM_SLEEP);
               for (n = 0; n < link->link_naux; n++) {
                       link->link_aux[n] = fdtbus_dai_acquire_index(card_phandle,
                           "simple-audio-card,aux-devs", n);
                       KASSERT(link->link_aux[n] != NULL);

                       /* Attach aux devices to codec */
                       audio_dai_add_device(link->link_codec, link->link_aux[n]);
               }
       }

       of_getprop_uint32(link_phandle, mclk_fs_prop, &link->link_mclk_fs);
       if (ausoc_link_format(sc, link, link_phandle, codec_phandle, single_link, &format) != 0) {
               aprint_error_dev(sc->sc_dev, "couldn't parse format properties\n");
               return;
       }
       if (audio_dai_set_format(link->link_cpu, format) != 0) {
               aprint_error_dev(sc->sc_dev, "couldn't set cpu format\n");
               return;
       }
       if (audio_dai_set_format(link->link_codec, format) != 0) {
               aprint_error_dev(sc->sc_dev, "couldn't set codec format\n");
               return;
       }

       aprint_normal_dev(sc->sc_dev, "codec: %s, cpu: %s",
           device_xname(audio_dai_device(link->link_codec)),
           device_xname(audio_dai_device(link->link_cpu)));
       for (n = 0; n < link->link_naux; n++) {
               if (n == 0)
                       aprint_normal(", aux:");
               aprint_normal(" %s",
                   device_xname(audio_dai_device(link->link_aux[n])));
       }
       aprint_normal("\n");

       audio_attach_mi(&ausoc_hw_if, link, sc->sc_dev);
}

static void
ausoc_attach_cb(device_t self)
{
       struct ausoc_softc * const sc = device_private(self);
       const int phandle = sc->sc_phandle;
       const char *name;
       int child, n;
       size_t len;

       /*
        * If the root node defines a cpu and codec, there is only one link. For
        * cards with multiple links, there will be simple-audio-card,dai-link
        * child nodes for each one.
        */
       if (of_find_firstchild_byname(phandle, "simple-audio-card,cpu") > 0 &&
           of_find_firstchild_byname(phandle, "simple-audio-card,codec") > 0) {
               sc->sc_nlink = 1;
               sc->sc_link = kmem_zalloc(sizeof(*sc->sc_link), KM_SLEEP);
               sc->sc_link[0].link_name = sc->sc_name;
               ausoc_attach_link(sc, &sc->sc_link[0], phandle, phandle);
       } else {
               for (child = OF_child(phandle); child; child = OF_peer(child)) {
                       name = fdtbus_get_string(child, "name");
                       len = strlen("simple-audio-card,dai-link");
                       if (strncmp(name, "simple-audio-card,dai-link", len) != 0)
                               continue;
                       sc->sc_nlink++;
               }
               if (sc->sc_nlink == 0)
                       return;
               sc->sc_link = kmem_zalloc(sizeof(*sc->sc_link) * sc->sc_nlink,
                   KM_SLEEP);
               for (child = OF_child(phandle), n = 0; child; child = OF_peer(child)) {
                       name = fdtbus_get_string(child, "name");
                       len = strlen("simple-audio-card,dai-link");
                       if (strncmp(name, "simple-audio-card,dai-link", len) != 0)
                               continue;
                       sc->sc_link[n].link_name = sc->sc_name;
                       ausoc_attach_link(sc, &sc->sc_link[n], phandle, child);
                       n++;
               }
       }
}

static void
ausoc_attach(device_t parent, device_t self, void *aux)
{
       struct ausoc_softc * const sc = device_private(self);
       struct fdt_attach_args * const faa = aux;
       const int phandle = faa->faa_phandle;

       sc->sc_dev = self;
       sc->sc_phandle = phandle;
       sc->sc_name = fdtbus_get_string(phandle, "simple-audio-card,name");
       if (!sc->sc_name)
               sc->sc_name = "SoC Audio";

       aprint_naive("\n");
       aprint_normal(": %s\n", sc->sc_name);

       /*
        * Defer attachment until all other drivers are ready.
        */
       config_defer(self, ausoc_attach_cb);
}

CFATTACH_DECL_NEW(ausoc, sizeof(struct ausoc_softc),
   ausoc_match, ausoc_attach, NULL, NULL);

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.