1 /*-
2 * Copyright (c) 2019 Oleksandr Tymoshenko <gonzo@FreeBSD.org>
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 *
24 */
25
26 #include <sys/cdefs.h>
27 #include "opt_platform.h"
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/bus.h>
32 #include <sys/clock.h>
33 #include <sys/kernel.h>
34 #include <sys/lock.h>
35 #include <sys/module.h>
36 #include <sys/endian.h>
37
38 #include <dev/ofw/ofw_bus.h>
39 #include <dev/ofw/ofw_bus_subr.h>
40
41 #include <dev/sound/fdt/audio_dai.h>
42 #include <dev/sound/pcm/sound.h>
43 #include "audio_dai_if.h"
44
45 #define AUDIO_BUFFER_SIZE 48000 * 4
46
47 struct audio_soc_aux_node {
48 SLIST_ENTRY(audio_soc_aux_node) link;
49 device_t dev;
50 };
51
52 struct audio_soc_channel {
53 struct audio_soc_softc *sc; /* parent device's softc */
54 struct pcm_channel *pcm; /* PCM channel */
55 struct snd_dbuf *buf; /* PCM buffer */
56 int dir; /* direction */
57 };
58
59 struct audio_soc_softc {
60 /*
61 * pcm_register assumes that sc is snddev_info,
62 * so this has to be first structure member for "compatibility"
63 */
64 struct snddev_info info;
65 device_t dev;
66 char *name;
67 struct intr_config_hook init_hook;
68 device_t cpu_dev;
69 device_t codec_dev;
70 SLIST_HEAD(, audio_soc_aux_node) aux_devs;
71 unsigned int mclk_fs;
72 struct audio_soc_channel play_channel;
73 struct audio_soc_channel rec_channel;
74 /*
75 * The format is from the CPU node, for CODEC node clock roles
76 * need to be reversed.
77 */
78 uint32_t format;
79 uint32_t link_mclk_fs;
80 };
81
82 static struct ofw_compat_data compat_data[] = {
83 {"simple-audio-card", 1},
84 {NULL, 0},
85 };
86
87 static struct {
88 const char *name;
89 unsigned int fmt;
90 } ausoc_dai_formats[] = {
91 { "i2s", AUDIO_DAI_FORMAT_I2S },
92 { "right_j", AUDIO_DAI_FORMAT_RJ },
93 { "left_j", AUDIO_DAI_FORMAT_LJ },
94 { "dsp_a", AUDIO_DAI_FORMAT_DSPA },
95 { "dsp_b", AUDIO_DAI_FORMAT_DSPB },
96 { "ac97", AUDIO_DAI_FORMAT_AC97 },
97 { "pdm", AUDIO_DAI_FORMAT_PDM },
98 };
99
100 static int audio_soc_probe(device_t dev);
101 static int audio_soc_attach(device_t dev);
102 static int audio_soc_detach(device_t dev);
103
104 /*
105 * Invert master/slave roles for CODEC side of the node
106 */
107 static uint32_t
audio_soc_reverse_clocks(uint32_t format)108 audio_soc_reverse_clocks(uint32_t format)
109 {
110 int fmt, pol, clk;
111
112 fmt = AUDIO_DAI_FORMAT_FORMAT(format);
113 pol = AUDIO_DAI_FORMAT_POLARITY(format);
114 clk = AUDIO_DAI_FORMAT_CLOCK(format);
115
116 switch (clk) {
117 case AUDIO_DAI_CLOCK_CBM_CFM:
118 clk = AUDIO_DAI_CLOCK_CBS_CFS;
119 break;
120 case AUDIO_DAI_CLOCK_CBS_CFM:
121 clk = AUDIO_DAI_CLOCK_CBM_CFS;
122 break;
123 case AUDIO_DAI_CLOCK_CBM_CFS:
124 clk = AUDIO_DAI_CLOCK_CBS_CFM;
125 break;
126 case AUDIO_DAI_CLOCK_CBS_CFS:
127 clk = AUDIO_DAI_CLOCK_CBM_CFM;
128 break;
129 }
130
131 return AUDIO_DAI_FORMAT(fmt, pol, clk);
132 }
133
134 static uint32_t
audio_soc_chan_setblocksize(kobj_t obj,void * data,uint32_t blocksz)135 audio_soc_chan_setblocksize(kobj_t obj, void *data, uint32_t blocksz)
136 {
137
138 return (blocksz);
139 }
140
141 static int
audio_soc_chan_setformat(kobj_t obj,void * data,uint32_t format)142 audio_soc_chan_setformat(kobj_t obj, void *data, uint32_t format)
143 {
144
145 struct audio_soc_softc *sc;
146 struct audio_soc_channel *ausoc_chan;
147
148 ausoc_chan = data;
149 sc = ausoc_chan->sc;
150
151 return AUDIO_DAI_SET_CHANFORMAT(sc->cpu_dev, format);
152 }
153
154 static uint32_t
audio_soc_chan_setspeed(kobj_t obj,void * data,uint32_t speed)155 audio_soc_chan_setspeed(kobj_t obj, void *data, uint32_t speed)
156 {
157
158 struct audio_soc_softc *sc;
159 struct audio_soc_channel *ausoc_chan;
160 uint32_t rate;
161 struct audio_soc_aux_node *aux_node;
162
163 ausoc_chan = data;
164 sc = ausoc_chan->sc;
165
166 if (sc->link_mclk_fs) {
167 rate = speed * sc->link_mclk_fs;
168 if (AUDIO_DAI_SET_SYSCLK(sc->cpu_dev, rate, AUDIO_DAI_CLOCK_IN))
169 device_printf(sc->dev, "failed to set sysclk for CPU node\n");
170
171 if (AUDIO_DAI_SET_SYSCLK(sc->codec_dev, rate, AUDIO_DAI_CLOCK_OUT))
172 device_printf(sc->dev, "failed to set sysclk for codec node\n");
173
174 SLIST_FOREACH(aux_node, &sc->aux_devs, link) {
175 if (AUDIO_DAI_SET_SYSCLK(aux_node->dev, rate, AUDIO_DAI_CLOCK_OUT))
176 device_printf(sc->dev, "failed to set sysclk for aux node\n");
177 }
178 }
179
180 /*
181 * Let CPU node determine speed
182 */
183 speed = AUDIO_DAI_SET_CHANSPEED(sc->cpu_dev, speed);
184 AUDIO_DAI_SET_CHANSPEED(sc->codec_dev, speed);
185 SLIST_FOREACH(aux_node, &sc->aux_devs, link) {
186 AUDIO_DAI_SET_CHANSPEED(aux_node->dev, speed);
187 }
188
189 return (speed);
190 }
191
192 static uint32_t
audio_soc_chan_getptr(kobj_t obj,void * data)193 audio_soc_chan_getptr(kobj_t obj, void *data)
194 {
195 struct audio_soc_softc *sc;
196 struct audio_soc_channel *ausoc_chan;
197
198 ausoc_chan = data;
199 sc = ausoc_chan->sc;
200
201 return AUDIO_DAI_GET_PTR(sc->cpu_dev, ausoc_chan->dir);
202 }
203
204 static void *
audio_soc_chan_init(kobj_t obj,void * devinfo,struct snd_dbuf * b,struct pcm_channel * c,int dir)205 audio_soc_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
206 struct pcm_channel *c, int dir)
207 {
208 struct audio_soc_channel *ausoc_chan;
209 void *buffer;
210
211 ausoc_chan = devinfo;
212 buffer = malloc(AUDIO_BUFFER_SIZE, M_DEVBUF, M_WAITOK | M_ZERO);
213
214 if (sndbuf_setup(b, buffer, AUDIO_BUFFER_SIZE) != 0) {
215 free(buffer, M_DEVBUF);
216 return NULL;
217 }
218
219 ausoc_chan->dir = dir;
220 ausoc_chan->buf = b;
221 ausoc_chan->pcm = c;
222
223 return (devinfo);
224 }
225
226 static int
audio_soc_chan_trigger(kobj_t obj,void * data,int go)227 audio_soc_chan_trigger(kobj_t obj, void *data, int go)
228 {
229 struct audio_soc_softc *sc;
230 struct audio_soc_channel *ausoc_chan;
231 struct audio_soc_aux_node *aux_node;
232
233 ausoc_chan = (struct audio_soc_channel *)data;
234 sc = ausoc_chan->sc;
235 AUDIO_DAI_TRIGGER(sc->codec_dev, go, ausoc_chan->dir);
236 SLIST_FOREACH(aux_node, &sc->aux_devs, link) {
237 AUDIO_DAI_TRIGGER(aux_node->dev, go, ausoc_chan->dir);
238 }
239
240 return AUDIO_DAI_TRIGGER(sc->cpu_dev, go, ausoc_chan->dir);
241 }
242
243 static int
audio_soc_chan_free(kobj_t obj,void * data)244 audio_soc_chan_free(kobj_t obj, void *data)
245 {
246
247 struct audio_soc_channel *ausoc_chan;
248 void *buffer;
249
250 ausoc_chan = (struct audio_soc_channel *)data;
251
252 buffer = ausoc_chan->buf->buf;
253 free(buffer, M_DEVBUF);
254
255 return (0);
256 }
257
258 static struct pcmchan_caps *
audio_soc_chan_getcaps(kobj_t obj,void * data)259 audio_soc_chan_getcaps(kobj_t obj, void *data)
260 {
261 struct audio_soc_softc *sc;
262 struct audio_soc_channel *ausoc_chan;
263
264 ausoc_chan = data;
265 sc = ausoc_chan->sc;
266
267 return AUDIO_DAI_GET_CAPS(sc->cpu_dev);
268 }
269
270 static kobj_method_t audio_soc_chan_methods[] = {
271 KOBJMETHOD(channel_init, audio_soc_chan_init),
272 KOBJMETHOD(channel_free, audio_soc_chan_free),
273 KOBJMETHOD(channel_setformat, audio_soc_chan_setformat),
274 KOBJMETHOD(channel_setspeed, audio_soc_chan_setspeed),
275 KOBJMETHOD(channel_setblocksize,audio_soc_chan_setblocksize),
276 KOBJMETHOD(channel_trigger, audio_soc_chan_trigger),
277 KOBJMETHOD(channel_getptr, audio_soc_chan_getptr),
278 KOBJMETHOD(channel_getcaps, audio_soc_chan_getcaps),
279 KOBJMETHOD_END
280 };
281 CHANNEL_DECLARE(audio_soc_chan);
282
283 static void
audio_soc_intr(void * arg)284 audio_soc_intr(void *arg)
285 {
286 struct audio_soc_softc *sc;
287 int channel_intr_required;
288
289 sc = (struct audio_soc_softc *)arg;
290 channel_intr_required = AUDIO_DAI_INTR(sc->cpu_dev, sc->play_channel.buf, sc->rec_channel.buf);
291 if (channel_intr_required & AUDIO_DAI_PLAY_INTR)
292 chn_intr(sc->play_channel.pcm);
293 if (channel_intr_required & AUDIO_DAI_REC_INTR)
294 chn_intr(sc->rec_channel.pcm);
295 }
296
297 static int
audio_soc_probe(device_t dev)298 audio_soc_probe(device_t dev)
299 {
300
301 if (!ofw_bus_status_okay(dev))
302 return (ENXIO);
303
304 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) {
305 device_set_desc(dev, "simple-audio-card");
306 return (BUS_PROBE_DEFAULT);
307 }
308
309 return (ENXIO);
310 }
311
312 static void
audio_soc_init(void * arg)313 audio_soc_init(void *arg)
314 {
315 struct audio_soc_softc *sc;
316 phandle_t node, child;
317 device_t daidev, auxdev;
318 uint32_t xref;
319 uint32_t *aux_devs;
320 int ncells, i;
321 struct audio_soc_aux_node *aux_node;
322
323 sc = (struct audio_soc_softc *)arg;
324 config_intrhook_disestablish(&sc->init_hook);
325
326 node = ofw_bus_get_node(sc->dev);
327 /* TODO: handle multi-link nodes */
328 child = ofw_bus_find_child(node, "simple-audio-card,cpu");
329 if (child == 0) {
330 device_printf(sc->dev, "cpu node is missing\n");
331 return;
332 }
333 if ((OF_getencprop(child, "sound-dai", &xref, sizeof(xref))) <= 0) {
334 device_printf(sc->dev, "missing sound-dai property in cpu node\n");
335 return;
336 }
337 daidev = OF_device_from_xref(xref);
338 if (daidev == NULL) {
339 device_printf(sc->dev, "no driver attached to cpu node\n");
340 return;
341 }
342 sc->cpu_dev = daidev;
343
344 child = ofw_bus_find_child(node, "simple-audio-card,codec");
345 if (child == 0) {
346 device_printf(sc->dev, "codec node is missing\n");
347 return;
348 }
349 if ((OF_getencprop(child, "sound-dai", &xref, sizeof(xref))) <= 0) {
350 device_printf(sc->dev, "missing sound-dai property in codec node\n");
351 return;
352 }
353 daidev = OF_device_from_xref(xref);
354 if (daidev == NULL) {
355 device_printf(sc->dev, "no driver attached to codec node\n");
356 return;
357 }
358 sc->codec_dev = daidev;
359
360 /* Add AUX devices */
361 aux_devs = NULL;
362 ncells = OF_getencprop_alloc_multi(node, "simple-audio-card,aux-devs", sizeof(*aux_devs),
363 (void **)&aux_devs);
364
365 for (i = 0; i < ncells; i++) {
366 auxdev = OF_device_from_xref(aux_devs[i]);
367 if (auxdev == NULL)
368 device_printf(sc->dev, "warning: no driver attached to aux node\n");
369 aux_node = malloc(sizeof(*aux_node), M_DEVBUF, M_NOWAIT);
370 if (aux_node == NULL) {
371 device_printf(sc->dev, "failed to allocate aux node struct\n");
372 return;
373 }
374 aux_node->dev = auxdev;
375 SLIST_INSERT_HEAD(&sc->aux_devs, aux_node, link);
376 }
377
378 if (aux_devs)
379 OF_prop_free(aux_devs);
380
381 if (AUDIO_DAI_INIT(sc->cpu_dev, sc->format)) {
382 device_printf(sc->dev, "failed to initialize cpu node\n");
383 return;
384 }
385
386 /* Reverse clock roles for CODEC */
387 if (AUDIO_DAI_INIT(sc->codec_dev, audio_soc_reverse_clocks(sc->format))) {
388 device_printf(sc->dev, "failed to initialize codec node\n");
389 return;
390 }
391
392 SLIST_FOREACH(aux_node, &sc->aux_devs, link) {
393 if (AUDIO_DAI_INIT(aux_node->dev, audio_soc_reverse_clocks(sc->format))) {
394 device_printf(sc->dev, "failed to initialize aux node\n");
395 return;
396 }
397 }
398
399 pcm_init(sc->dev, sc);
400
401 AUDIO_DAI_SETUP_MIXER(sc->codec_dev, sc->dev);
402 SLIST_FOREACH(aux_node, &sc->aux_devs, link) {
403 AUDIO_DAI_SETUP_MIXER(aux_node->dev, sc->dev);
404 }
405
406 sc->play_channel.sc = sc;
407 sc->rec_channel.sc = sc;
408
409 pcm_addchan(sc->dev, PCMDIR_PLAY, &audio_soc_chan_class, &sc->play_channel);
410 pcm_addchan(sc->dev, PCMDIR_REC, &audio_soc_chan_class, &sc->rec_channel);
411
412 if (pcm_register(sc->dev, "at simplebus")) {
413 device_printf(sc->dev, "failed to register PCM\n");
414 return;
415 }
416
417 AUDIO_DAI_SETUP_INTR(sc->cpu_dev, audio_soc_intr, sc);
418 }
419
420 static int
audio_soc_attach(device_t dev)421 audio_soc_attach(device_t dev)
422 {
423 struct audio_soc_softc *sc;
424 char *name;
425 phandle_t node, cpu_child;
426 uint32_t xref;
427 int i, ret;
428 char tmp[32];
429 unsigned int fmt, pol, clk;
430 bool frame_master, bitclock_master;
431
432 sc = device_get_softc(dev);
433 sc->dev = dev;
434 node = ofw_bus_get_node(dev);
435
436 ret = OF_getprop_alloc(node, "name", (void **)&name);
437 if (ret == -1)
438 name = "SoC audio";
439
440 sc->name = strdup(name, M_DEVBUF);
441 device_set_desc(dev, sc->name);
442
443 if (ret != -1)
444 OF_prop_free(name);
445
446 SLIST_INIT(&sc->aux_devs);
447
448 ret = OF_getprop(node, "simple-audio-card,format", tmp, sizeof(tmp));
449 if (ret == 0) {
450 for (i = 0; i < nitems(ausoc_dai_formats); i++) {
451 if (strcmp(tmp, ausoc_dai_formats[i].name) == 0) {
452 fmt = ausoc_dai_formats[i].fmt;
453 break;
454 }
455 }
456 if (i == nitems(ausoc_dai_formats))
457 return (EINVAL);
458 } else
459 fmt = AUDIO_DAI_FORMAT_I2S;
460
461 if (OF_getencprop(node, "simple-audio-card,mclk-fs",
462 &sc->link_mclk_fs, sizeof(sc->link_mclk_fs)) <= 0)
463 sc->link_mclk_fs = 0;
464
465 /* Unless specified otherwise, CPU node is the master */
466 frame_master = bitclock_master = true;
467
468 cpu_child = ofw_bus_find_child(node, "simple-audio-card,cpu");
469
470 if ((OF_getencprop(node, "simple-audio-card,frame-master", &xref, sizeof(xref))) > 0)
471 frame_master = cpu_child == OF_node_from_xref(xref);
472
473 if ((OF_getencprop(node, "simple-audio-card,bitclock-master", &xref, sizeof(xref))) > 0)
474 bitclock_master = cpu_child == OF_node_from_xref(xref);
475
476 if (frame_master) {
477 clk = bitclock_master ?
478 AUDIO_DAI_CLOCK_CBM_CFM : AUDIO_DAI_CLOCK_CBS_CFM;
479 } else {
480 clk = bitclock_master ?
481 AUDIO_DAI_CLOCK_CBM_CFS : AUDIO_DAI_CLOCK_CBS_CFS;
482 }
483
484 bool bitclock_inversion = OF_hasprop(node, "simple-audio-card,bitclock-inversion");
485 bool frame_inversion = OF_hasprop(node, "simple-audio-card,frame-inversion");
486 if (bitclock_inversion) {
487 pol = frame_inversion ?
488 AUDIO_DAI_POLARITY_IB_IF : AUDIO_DAI_POLARITY_IB_NF;
489 } else {
490 pol = frame_inversion ?
491 AUDIO_DAI_POLARITY_NB_IF : AUDIO_DAI_POLARITY_NB_NF;
492 }
493
494 sc->format = AUDIO_DAI_FORMAT(fmt, pol, clk);
495
496 sc->init_hook.ich_func = audio_soc_init;
497 sc->init_hook.ich_arg = sc;
498 if (config_intrhook_establish(&sc->init_hook) != 0)
499 return (ENOMEM);
500
501 return (0);
502 }
503
504 static int
audio_soc_detach(device_t dev)505 audio_soc_detach(device_t dev)
506 {
507 struct audio_soc_softc *sc;
508 struct audio_soc_aux_node *aux;
509
510 sc = device_get_softc(dev);
511 free(sc->name, M_DEVBUF);
512
513 while ((aux = SLIST_FIRST(&sc->aux_devs)) != NULL) {
514 SLIST_REMOVE_HEAD(&sc->aux_devs, link);
515 free(aux, M_DEVBUF);
516 }
517
518 return (0);
519 }
520
521 static device_method_t audio_soc_methods[] = {
522 /* device_if methods */
523 DEVMETHOD(device_probe, audio_soc_probe),
524 DEVMETHOD(device_attach, audio_soc_attach),
525 DEVMETHOD(device_detach, audio_soc_detach),
526
527 DEVMETHOD_END,
528 };
529
530 static driver_t audio_soc_driver = {
531 "pcm",
532 audio_soc_methods,
533 sizeof(struct audio_soc_softc),
534 };
535
536 DRIVER_MODULE(audio_soc, simplebus, audio_soc_driver, NULL, NULL);
537 MODULE_VERSION(audio_soc, 1);
538