NetBSD/sys/dev/fdt/ausoc.c

583 lines
15 KiB
C

/* $NetBSD: ausoc.c,v 1.6 2021/01/27 03:10:21 thorpej Exp $ */
/*-
* Copyright (c) 2018 Jared McNeill <jmcneill@invisible.ca>
* 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);