bwdsp.c revision 1.1
1 /* $NetBSD: bwdsp.c,v 1.1 2024/01/22 21:28:15 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2024 Jared McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: bwdsp.c,v 1.1 2024/01/22 21:28:15 jmcneill Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/bus.h> 34 #include <sys/cpu.h> 35 #include <sys/device.h> 36 #include <sys/kmem.h> 37 38 #include <sys/audioio.h> 39 #include <dev/audio/audio_if.h> 40 #include <dev/audio/audio_dai.h> 41 42 #include "mainbus.h" 43 #include "bwai.h" 44 45 #define BWDSP_MAP_FLAGS BUS_DMA_NOCACHE 46 47 #define DSP_CONTROL_STATUS 0x0a 48 #define DSP_CONTROL_STATUS_DSPINT __BIT(7) 49 #define DSP_CONTROL_STATUS_ARINT __BIT(5) 50 #define DSP_CONTROL_STATUS_AIDINTMASK __BIT(4) 51 #define DSP_CONTROL_STATUS_AIDINT __BIT(3) 52 #define DSP_CONTROL_STATUS_HALT __BIT(2) 53 #define DSP_CONTROL_STATUS_PIINT __BIT(1) 54 #define DSP_DMA_START_ADDR_H 0x30 55 #define DSP_DMA_START_ADDR_L 0x32 56 #define DSP_DMA_CONTROL_LENGTH 0x36 57 #define DSP_DMA_CONTROL_LENGTH_CTRL __BIT(15) 58 #define DSP_DMA_CONTROL_LENGTH_NUM_CLS __BITS(14,0) 59 60 #define DSP_DMA_ALIGN 32 61 #define DSP_DMA_MAX_BUFSIZE (DSP_DMA_CONTROL_LENGTH_NUM_CLS * 32) 62 63 struct bwdsp_dma { 64 LIST_ENTRY(bwdsp_dma) dma_list; 65 bus_dmamap_t dma_map; 66 void *dma_addr; 67 size_t dma_size; 68 bus_dma_segment_t dma_segs[1]; 69 int dma_nsegs; 70 }; 71 72 struct bwdsp_softc { 73 device_t sc_dev; 74 bus_space_tag_t sc_bst; 75 bus_space_handle_t sc_bsh; 76 bus_dma_tag_t sc_dmat; 77 78 LIST_HEAD(, bwdsp_dma) sc_dmalist; 79 80 kmutex_t sc_lock; 81 kmutex_t sc_intr_lock; 82 83 struct audio_format sc_format; 84 85 audio_dai_tag_t sc_dai; 86 }; 87 88 #define RD2(sc, reg) \ 89 bus_space_read_2((sc)->sc_bst, (sc)->sc_bsh, (reg)) 90 #define WR2(sc, reg, val) \ 91 bus_space_write_2((sc)->sc_bst, (sc)->sc_bsh, (reg), (val)) 92 93 static int 94 bwdsp_allocdma(struct bwdsp_softc *sc, size_t size, 95 size_t align, struct bwdsp_dma *dma) 96 { 97 int error; 98 99 dma->dma_size = size; 100 error = bus_dmamem_alloc(sc->sc_dmat, dma->dma_size, align, 0, 101 dma->dma_segs, 1, &dma->dma_nsegs, BUS_DMA_WAITOK); 102 if (error) 103 return error; 104 105 error = bus_dmamem_map(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs, 106 dma->dma_size, &dma->dma_addr, BUS_DMA_WAITOK | BWDSP_MAP_FLAGS); 107 if (error) 108 goto free; 109 110 error = bus_dmamap_create(sc->sc_dmat, dma->dma_size, dma->dma_nsegs, 111 dma->dma_size, 0, BUS_DMA_WAITOK, &dma->dma_map); 112 if (error) 113 goto unmap; 114 115 error = bus_dmamap_load(sc->sc_dmat, dma->dma_map, dma->dma_addr, 116 dma->dma_size, NULL, BUS_DMA_WAITOK); 117 if (error) 118 goto destroy; 119 120 return 0; 121 122 destroy: 123 bus_dmamap_destroy(sc->sc_dmat, dma->dma_map); 124 unmap: 125 bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size); 126 free: 127 bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs); 128 129 return error; 130 } 131 132 static void 133 bwdsp_freedma(struct bwdsp_softc *sc, struct bwdsp_dma *dma) 134 { 135 bus_dmamap_unload(sc->sc_dmat, dma->dma_map); 136 bus_dmamap_destroy(sc->sc_dmat, dma->dma_map); 137 bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size); 138 bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs); 139 } 140 141 static int 142 bwdsp_query_format(void *priv, audio_format_query_t *afp) 143 { 144 struct bwdsp_softc * const sc = priv; 145 146 return audio_query_format(&sc->sc_format, 1, afp); 147 } 148 149 static int 150 bwdsp_set_format(void *priv, int setmode, 151 const audio_params_t *play, const audio_params_t *rec, 152 audio_filter_reg_t *pfil, audio_filter_reg_t *rfil) 153 { 154 struct bwdsp_softc * const sc = priv; 155 156 return audio_dai_mi_set_format(sc->sc_dai, setmode, play, rec, 157 pfil, rfil); 158 } 159 160 static int 161 bwdsp_set_port(void *priv, mixer_ctrl_t *mc) 162 { 163 struct bwdsp_softc * const sc = priv; 164 165 return audio_dai_set_port(sc->sc_dai, mc); 166 } 167 168 static int 169 bwdsp_get_port(void *priv, mixer_ctrl_t *mc) 170 { 171 struct bwdsp_softc * const sc = priv; 172 173 return audio_dai_get_port(sc->sc_dai, mc); 174 } 175 176 static int 177 bwdsp_query_devinfo(void *priv, mixer_devinfo_t *di) 178 { 179 struct bwdsp_softc * const sc = priv; 180 181 return audio_dai_query_devinfo(sc->sc_dai, di); 182 } 183 184 static void * 185 bwdsp_allocm(void *priv, int dir, size_t size) 186 { 187 struct bwdsp_softc * const sc = priv; 188 struct bwdsp_dma *dma; 189 int error; 190 191 dma = kmem_alloc(sizeof(*dma), KM_SLEEP); 192 193 error = bwdsp_allocdma(sc, size, DSP_DMA_ALIGN, dma); 194 if (error) { 195 kmem_free(dma, sizeof(*dma)); 196 device_printf(sc->sc_dev, "couldn't allocate DMA memory (%d)\n", 197 error); 198 return NULL; 199 } 200 201 LIST_INSERT_HEAD(&sc->sc_dmalist, dma, dma_list); 202 203 return dma->dma_addr; 204 } 205 206 static void 207 bwdsp_freem(void *priv, void *addr, size_t size) 208 { 209 struct bwdsp_softc * const sc = priv; 210 struct bwdsp_dma *dma; 211 212 LIST_FOREACH(dma, &sc->sc_dmalist, dma_list) 213 if (dma->dma_addr == addr) { 214 bwdsp_freedma(sc, dma); 215 LIST_REMOVE(dma, dma_list); 216 kmem_free(dma, sizeof(*dma)); 217 break; 218 } 219 } 220 221 static int 222 bwdsp_getdev(void *priv, struct audio_device *adev) 223 { 224 snprintf(adev->name, sizeof(adev->name), "Broadway DSP"); 225 snprintf(adev->version, sizeof(adev->version), ""); 226 snprintf(adev->config, sizeof(adev->config), "bwdsp"); 227 228 return 0; 229 } 230 231 static int 232 bwdsp_get_props(void *priv) 233 { 234 return AUDIO_PROP_PLAYBACK; 235 } 236 237 static int 238 bwdsp_round_blocksize(void *priv, int bs, int mode, 239 const audio_params_t *params) 240 { 241 bs = roundup(bs, DSP_DMA_ALIGN); 242 if (bs > DSP_DMA_MAX_BUFSIZE) { 243 bs = DSP_DMA_MAX_BUFSIZE; 244 } 245 return bs; 246 } 247 248 static size_t 249 bwdsp_round_buffersize(void *priv, int dir, size_t bufsize) 250 { 251 if (bufsize > DSP_DMA_MAX_BUFSIZE) { 252 bufsize = DSP_DMA_MAX_BUFSIZE; 253 } 254 return bufsize; 255 } 256 257 static void 258 bwdsp_transfer(struct bwdsp_softc *sc, uint32_t phys_addr, size_t bufsize) 259 { 260 if (bufsize != 0) { 261 WR2(sc, DSP_DMA_START_ADDR_H, phys_addr >> 16); 262 WR2(sc, DSP_DMA_START_ADDR_L, phys_addr & 0xffff); 263 WR2(sc, DSP_DMA_CONTROL_LENGTH, 264 DSP_DMA_CONTROL_LENGTH_CTRL | (bufsize / 32)); 265 } else { 266 WR2(sc, DSP_DMA_CONTROL_LENGTH, 0); 267 } 268 } 269 270 static int 271 bwdsp_trigger_output(void *priv, void *start, void *end, int blksize, 272 void (*intr)(void *), void *intrarg, const audio_params_t *params) 273 { 274 struct bwdsp_softc * const sc = priv; 275 struct bwdsp_dma *dma; 276 bus_addr_t pstart; 277 bus_size_t psize; 278 int error; 279 280 pstart = 0; 281 psize = (uintptr_t)end - (uintptr_t)start; 282 283 LIST_FOREACH(dma, &sc->sc_dmalist, dma_list) 284 if (dma->dma_addr == start) { 285 pstart = dma->dma_map->dm_segs[0].ds_addr; 286 break; 287 } 288 if (pstart == 0) { 289 device_printf(sc->sc_dev, "bad addr %p\n", start); 290 return EINVAL; 291 } 292 293 error = audio_dai_trigger(sc->sc_dai, start, end, blksize, 294 intr, intrarg, params, AUMODE_PLAY); 295 if (error != 0) { 296 return error; 297 } 298 299 /* Start DMA transfer */ 300 bwdsp_transfer(sc, pstart, psize); 301 302 return 0; 303 } 304 305 static int 306 bwdsp_halt_output(void *priv) 307 { 308 struct bwdsp_softc * const sc = priv; 309 310 /* Stop DMA transfer */ 311 bwdsp_transfer(sc, 0, 0); 312 313 return audio_dai_halt(sc->sc_dai, AUMODE_PLAY); 314 } 315 316 static void 317 bwdsp_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread) 318 { 319 struct bwdsp_softc * const sc = priv; 320 321 *intr = &sc->sc_intr_lock; 322 *thread = &sc->sc_lock; 323 } 324 325 static const struct audio_hw_if bwdsp_hw_if = { 326 .query_format = bwdsp_query_format, 327 .set_format = bwdsp_set_format, 328 .allocm = bwdsp_allocm, 329 .freem = bwdsp_freem, 330 .getdev = bwdsp_getdev, 331 .set_port = bwdsp_set_port, 332 .get_port = bwdsp_get_port, 333 .query_devinfo = bwdsp_query_devinfo, 334 .get_props = bwdsp_get_props, 335 .round_blocksize = bwdsp_round_blocksize, 336 .round_buffersize = bwdsp_round_buffersize, 337 .trigger_output = bwdsp_trigger_output, 338 .halt_output = bwdsp_halt_output, 339 .get_locks = bwdsp_get_locks, 340 }; 341 342 static int 343 bwdsp_intr(void *priv) 344 { 345 struct bwdsp_softc * const sc = priv; 346 uint16_t val; 347 348 val = RD2(sc, DSP_CONTROL_STATUS); 349 if ((val & DSP_CONTROL_STATUS_AIDINT) != 0) { 350 /* Acknowledge audio interrupt */ 351 val &= ~(DSP_CONTROL_STATUS_DSPINT | 352 DSP_CONTROL_STATUS_ARINT | 353 DSP_CONTROL_STATUS_PIINT); 354 WR2(sc, DSP_CONTROL_STATUS, val); 355 } 356 357 return 1; 358 } 359 360 static void 361 bwdsp_late_attach(device_t dev) 362 { 363 struct bwdsp_softc * const sc = device_private(dev); 364 365 sc->sc_dai = bwai_dsp_init(&sc->sc_intr_lock); 366 if (sc->sc_dai == NULL) { 367 aprint_error_dev(dev, "can't find bwai device\n"); 368 return; 369 } 370 371 audio_attach_mi(&bwdsp_hw_if, sc, dev); 372 } 373 374 static int 375 bwdsp_match(device_t parent, cfdata_t cf, void *aux) 376 { 377 struct mainbus_attach_args * const maa = aux; 378 379 return strcmp(maa->maa_name, "bwdsp") == 0; 380 } 381 382 static void 383 bwdsp_attach(device_t parent, device_t self, void *aux) 384 { 385 struct bwdsp_softc * const sc = device_private(self); 386 struct mainbus_attach_args * const maa = aux; 387 bus_addr_t addr = maa->maa_addr; 388 bus_size_t size = 0x200; 389 uint16_t val; 390 391 sc->sc_dev = self; 392 sc->sc_bst = maa->maa_bst; 393 if (bus_space_map(sc->sc_bst, addr, size, 0, &sc->sc_bsh) != 0) { 394 aprint_error(": couldn't map registers\n"); 395 return; 396 } 397 sc->sc_dmat = maa->maa_dmat; 398 LIST_INIT(&sc->sc_dmalist); 399 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 400 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED); 401 402 aprint_naive("\n"); 403 aprint_normal(": DSP\n"); 404 405 sc->sc_format.mode = AUMODE_PLAY; 406 sc->sc_format.encoding = AUDIO_ENCODING_SLINEAR_BE; 407 sc->sc_format.validbits = 16; 408 sc->sc_format.precision = 16; 409 sc->sc_format.channels = 2; 410 sc->sc_format.channel_mask = AUFMT_STEREO; 411 sc->sc_format.frequency_type = 1; 412 sc->sc_format.frequency[0] = 48000; 413 414 val = RD2(sc, DSP_CONTROL_STATUS); 415 val |= DSP_CONTROL_STATUS_AIDINTMASK; 416 val |= DSP_CONTROL_STATUS_PIINT; 417 WR2(sc, DSP_CONTROL_STATUS, val); 418 419 intr_establish(maa->maa_irq, IST_LEVEL, IPL_AUDIO, bwdsp_intr, sc); 420 421 config_defer(self, bwdsp_late_attach); 422 } 423 424 CFATTACH_DECL_NEW(bwdsp, sizeof(struct bwdsp_softc), 425 bwdsp_match, bwdsp_attach, NULL, NULL); 426
Indexes created Sun Sep 28 16:09:52 GMT 2025