yds.c revision 1.9
1 /* $NetBSD: yds.c,v 1.9 2001/12/25 16:55:50 someya Exp $ */ 2 3 /* 4 * Copyright (c) 2000, 2001 Kazuki Sakamoto and Minoura Makoto. 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, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 /* 29 * Yamaha YMF724[B-F]/740[B-C]/744/754 30 * 31 * Documentation links: 32 * - ftp://ftp.alsa-project.org/pub/manuals/yamaha/ 33 * - ftp://ftp.alsa-project.org/pub/manuals/yamaha/pci/ 34 * 35 * TODO: 36 * - FM synth volume (difficult: mixed before ac97) 37 * - Digital in/out (SPDIF) support 38 * - Effect?? 39 */ 40 41 #include <sys/cdefs.h> 42 __KERNEL_RCSID(0, "$NetBSD: yds.c,v 1.9 2001/12/25 16:55:50 someya Exp $"); 43 44 #include "mpu.h" 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/kernel.h> 49 #include <sys/fcntl.h> 50 #include <sys/malloc.h> 51 #include <sys/device.h> 52 #include <sys/proc.h> 53 54 #include <dev/pci/pcidevs.h> 55 #include <dev/pci/pcireg.h> 56 #include <dev/pci/pcivar.h> 57 58 #include <sys/audioio.h> 59 #include <dev/audio_if.h> 60 #include <dev/mulaw.h> 61 #include <dev/auconv.h> 62 #include <dev/ic/ac97reg.h> 63 #include <dev/ic/ac97var.h> 64 #include <dev/ic/mpuvar.h> 65 66 #include <machine/bus.h> 67 #include <machine/intr.h> 68 69 #include <dev/microcode/yds/yds_hwmcode.h> 70 #include <dev/pci/ydsreg.h> 71 #include <dev/pci/ydsvar.h> 72 73 /* Debug */ 74 #undef YDS_USE_REC_SLOT 75 #define YDS_USE_P44 76 77 #ifdef AUDIO_DEBUG 78 # define DPRINTF(x) if (ydsdebug) printf x 79 # define DPRINTFN(n,x) if (ydsdebug>(n)) printf x 80 int ydsdebug = 0; 81 #else 82 # define DPRINTF(x) 83 # define DPRINTFN(n,x) 84 #endif 85 #ifdef YDS_USE_REC_SLOT 86 # define YDS_INPUT_SLOT 0 /* REC slot = ADC + loopbacks */ 87 #else 88 # define YDS_INPUT_SLOT 1 /* ADC slot */ 89 #endif 90 91 int yds_match __P((struct device *, struct cfdata *, void *)); 92 void yds_attach __P((struct device *, struct device *, void *)); 93 int yds_intr __P((void *)); 94 95 #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr) 96 #define KERNADDR(p) ((void *)((p)->addr)) 97 98 int yds_allocmem __P((struct yds_softc *, size_t, size_t, 99 struct yds_dma *)); 100 int yds_freemem __P((struct yds_softc *, struct yds_dma *)); 101 102 #ifndef AUDIO_DEBUG 103 #define YWRITE1(sc, r, x) bus_space_write_1((sc)->memt, (sc)->memh, (r), (x)) 104 #define YWRITE2(sc, r, x) bus_space_write_2((sc)->memt, (sc)->memh, (r), (x)) 105 #define YWRITE4(sc, r, x) bus_space_write_4((sc)->memt, (sc)->memh, (r), (x)) 106 #define YREAD1(sc, r) bus_space_read_1((sc)->memt, (sc)->memh, (r)) 107 #define YREAD2(sc, r) bus_space_read_2((sc)->memt, (sc)->memh, (r)) 108 #define YREAD4(sc, r) bus_space_read_4((sc)->memt, (sc)->memh, (r)) 109 #else 110 111 u_int16_t YREAD2(struct yds_softc *sc,bus_size_t r); 112 u_int32_t YREAD4(struct yds_softc *sc,bus_size_t r); 113 void YWRITE1(struct yds_softc *sc,bus_size_t r,u_int8_t x); 114 void YWRITE2(struct yds_softc *sc,bus_size_t r,u_int16_t x); 115 void YWRITE4(struct yds_softc *sc,bus_size_t r,u_int32_t x); 116 117 u_int16_t YREAD2(struct yds_softc *sc,bus_size_t r) 118 { 119 DPRINTFN(5, (" YREAD2(0x%lX)\n",(unsigned long)r)); 120 return bus_space_read_2(sc->memt,sc->memh,r); 121 } 122 u_int32_t YREAD4(struct yds_softc *sc,bus_size_t r) 123 { 124 DPRINTFN(5, (" YREAD4(0x%lX)\n",(unsigned long)r)); 125 return bus_space_read_4(sc->memt,sc->memh,r); 126 } 127 void YWRITE1(struct yds_softc *sc,bus_size_t r,u_int8_t x) 128 { 129 DPRINTFN(5, (" YWRITE1(0x%lX,0x%lX)\n",(unsigned long)r,(unsigned long)x)); 130 bus_space_write_1(sc->memt,sc->memh,r,x); 131 } 132 void YWRITE2(struct yds_softc *sc,bus_size_t r,u_int16_t x) 133 { 134 DPRINTFN(5, (" YWRITE2(0x%lX,0x%lX)\n",(unsigned long)r,(unsigned long)x)); 135 bus_space_write_2(sc->memt,sc->memh,r,x); 136 } 137 void YWRITE4(struct yds_softc *sc,bus_size_t r,u_int32_t x) 138 { 139 DPRINTFN(5, (" YWRITE4(0x%lX,0x%lX)\n",(unsigned long)r,(unsigned long)x)); 140 bus_space_write_4(sc->memt,sc->memh,r,x); 141 } 142 #endif 143 144 #define YWRITEREGION4(sc, r, x, c) \ 145 bus_space_write_region_4((sc)->memt, (sc)->memh, (r), (x), (c) / 4) 146 147 struct cfattach yds_ca = { 148 sizeof(struct yds_softc), yds_match, yds_attach 149 }; 150 151 int yds_open __P((void *, int)); 152 void yds_close __P((void *)); 153 int yds_query_encoding __P((void *, struct audio_encoding *)); 154 int yds_set_params __P((void *, int, int, 155 struct audio_params *, struct audio_params *)); 156 int yds_round_blocksize __P((void *, int)); 157 int yds_trigger_output __P((void *, void *, void *, int, void (*)(void *), 158 void *, struct audio_params *)); 159 int yds_trigger_input __P((void *, void *, void *, int, void (*)(void *), 160 void *, struct audio_params *)); 161 int yds_halt_output __P((void *)); 162 int yds_halt_input __P((void *)); 163 int yds_getdev __P((void *, struct audio_device *)); 164 int yds_mixer_set_port __P((void *, mixer_ctrl_t *)); 165 int yds_mixer_get_port __P((void *, mixer_ctrl_t *)); 166 void *yds_malloc __P((void *, int, size_t, int, int)); 167 void yds_free __P((void *, void *, int)); 168 size_t yds_round_buffersize __P((void *, int, size_t)); 169 paddr_t yds_mappage __P((void *, void *, off_t, int)); 170 int yds_get_props __P((void *)); 171 int yds_query_devinfo __P((void *addr, mixer_devinfo_t *dip)); 172 173 int yds_attach_codec __P((void *sc, struct ac97_codec_if *)); 174 int yds_read_codec __P((void *sc, u_int8_t a, u_int16_t *d)); 175 int yds_write_codec __P((void *sc, u_int8_t a, u_int16_t d)); 176 void yds_reset_codec __P((void *sc)); 177 int yds_get_portnum_by_name __P((struct yds_softc *, char *, char *, 178 char *)); 179 180 static u_int yds_get_dstype __P((int)); 181 static int yds_download_mcode __P((struct yds_softc *)); 182 static int yds_allocate_slots __P((struct yds_softc *)); 183 static void yds_configure_legacy __P((struct device *arg)); 184 static void yds_enable_dsp __P((struct yds_softc *)); 185 static int yds_disable_dsp __P((struct yds_softc *)); 186 static int yds_ready_codec __P((struct yds_codec_softc *)); 187 static int yds_halt __P((struct yds_softc *)); 188 static u_int32_t yds_get_lpfq __P((u_int)); 189 static u_int32_t yds_get_lpfk __P((u_int)); 190 static struct yds_dma *yds_find_dma __P((struct yds_softc *, void *)); 191 192 #ifdef AUDIO_DEBUG 193 static void yds_dump_play_slot __P((struct yds_softc *, int)); 194 #define YDS_DUMP_PLAY_SLOT(n,sc,bank) \ 195 if (ydsdebug > (n)) yds_dump_play_slot(sc, bank) 196 #else 197 #define YDS_DUMP_PLAY_SLOT(n,sc,bank) 198 #endif /* AUDIO_DEBUG */ 199 200 static struct audio_hw_if yds_hw_if = { 201 yds_open, 202 yds_close, 203 NULL, 204 yds_query_encoding, 205 yds_set_params, 206 yds_round_blocksize, 207 NULL, 208 NULL, 209 NULL, 210 NULL, 211 NULL, 212 yds_halt_output, 213 yds_halt_input, 214 NULL, 215 yds_getdev, 216 NULL, 217 yds_mixer_set_port, 218 yds_mixer_get_port, 219 yds_query_devinfo, 220 yds_malloc, 221 yds_free, 222 yds_round_buffersize, 223 yds_mappage, 224 yds_get_props, 225 yds_trigger_output, 226 yds_trigger_input, 227 NULL, 228 }; 229 230 struct audio_device yds_device = { 231 "Yamaha DS-1", 232 "", 233 "yds" 234 }; 235 236 const static struct { 237 u_int id; 238 u_int flags; 239 #define YDS_CAP_MCODE_1 0x0001 240 #define YDS_CAP_MCODE_1E 0x0002 241 #define YDS_CAP_LEGACY_SELECTABLE 0x0004 242 #define YDS_CAP_LEGACY_FLEXIBLE 0x0008 243 #define YDS_CAP_HAS_P44 0x0010 244 } yds_chip_capabliity_list[] = { 245 { PCI_PRODUCT_YAMAHA_YMF724, 246 YDS_CAP_MCODE_1|YDS_CAP_LEGACY_SELECTABLE }, 247 /* 740[C] has only 32 slots. But anyway we use only 2 */ 248 { PCI_PRODUCT_YAMAHA_YMF740, 249 YDS_CAP_MCODE_1|YDS_CAP_LEGACY_SELECTABLE }, /* XXX NOT TESTED */ 250 { PCI_PRODUCT_YAMAHA_YMF740C, 251 YDS_CAP_MCODE_1E|YDS_CAP_LEGACY_SELECTABLE }, 252 { PCI_PRODUCT_YAMAHA_YMF724F, 253 YDS_CAP_MCODE_1E|YDS_CAP_LEGACY_SELECTABLE }, 254 { PCI_PRODUCT_YAMAHA_YMF744B, 255 YDS_CAP_MCODE_1E|YDS_CAP_LEGACY_FLEXIBLE }, 256 { PCI_PRODUCT_YAMAHA_YMF754, 257 YDS_CAP_MCODE_1E|YDS_CAP_LEGACY_FLEXIBLE|YDS_CAP_HAS_P44 }, 258 { 0, 0 } 259 }; 260 #ifdef AUDIO_DEBUG 261 #define YDS_CAP_BITS "\020\005P44\004LEGFLEX\003LEGSEL\002MCODE1E\001MCODE1" 262 #endif 263 264 #ifdef AUDIO_DEBUG 265 static void 266 yds_dump_play_slot(sc, bank) 267 struct yds_softc *sc; 268 int bank; 269 { 270 int i, j; 271 u_int32_t *p; 272 u_int32_t num; 273 char *pa; 274 275 for (i = 0; i < N_PLAY_SLOTS; i++) { 276 printf("pbankp[%d] = %p,", i*2, sc->pbankp[i*2]); 277 printf("pbankp[%d] = %p\n", i*2+1, sc->pbankp[i*2+1]); 278 } 279 280 pa = (char *)DMAADDR(&sc->sc_ctrldata) + sc->pbankoff; 281 p = (u_int32_t *)sc->ptbl; 282 printf("ptbl + 0: %d\n", *p++); 283 for (i = 0; i < N_PLAY_SLOTS; i++) { 284 printf("ptbl + %d: 0x%x, should be %p\n", 285 i+1, *p, 286 pa + i * sizeof(struct play_slot_ctrl_bank) * 287 N_PLAY_SLOT_CTRL_BANK); 288 p++; 289 } 290 291 num = *(u_int32_t*)sc->ptbl; 292 printf("numofplay = %d\n", num); 293 294 for (i = 0; i < num; i++) { 295 p = (u_int32_t *)sc->pbankp[i*2]; 296 297 printf(" pbankp[%d], bank 0 : %p\n", i*2, p); 298 for (j = 0; 299 j < sizeof(struct play_slot_ctrl_bank) / sizeof(u_int32_t); 300 j++) { 301 printf(" 0x%02x: 0x%08x\n", 302 (unsigned)(j * sizeof(u_int32_t)), 303 (unsigned)*p++); 304 } 305 306 p = (u_int32_t *)sc->pbankp[i*2 + 1]; 307 printf(" pbankp[%d], bank 1 : %p\n", i*2 + 1, p); 308 for (j = 0; 309 j < sizeof(struct play_slot_ctrl_bank) / sizeof(u_int32_t); 310 j++) { 311 printf(" 0x%02x: 0x%08x\n", 312 (unsigned)(j * sizeof(u_int32_t)), 313 (unsigned)*p++); 314 } 315 } 316 } 317 #endif /* AUDIO_DEBUG */ 318 319 static u_int 320 yds_get_dstype(id) 321 int id; 322 { 323 int i; 324 325 for (i = 0; yds_chip_capabliity_list[i].id; i++) { 326 if (PCI_PRODUCT(id) == yds_chip_capabliity_list[i].id) 327 return yds_chip_capabliity_list[i].flags; 328 } 329 330 return -1; 331 } 332 333 static int 334 yds_download_mcode(sc) 335 struct yds_softc *sc; 336 { 337 u_int ctrl; 338 const u_int32_t *p; 339 size_t size; 340 int dstype; 341 342 static struct { 343 const u_int32_t *mcode; 344 size_t size; 345 } ctrls[] = { 346 {yds_ds1_ctrl_mcode, sizeof(yds_ds1_ctrl_mcode)}, 347 {yds_ds1e_ctrl_mcode, sizeof(yds_ds1e_ctrl_mcode)}, 348 }; 349 350 if (sc->sc_flags & YDS_CAP_MCODE_1) 351 dstype = YDS_DS_1; 352 else if (sc->sc_flags & YDS_CAP_MCODE_1E) 353 dstype = YDS_DS_1E; 354 else 355 return 1; /* unknown */ 356 357 if (yds_disable_dsp(sc)) 358 return 1; 359 360 /* Software reset */ 361 YWRITE4(sc, YDS_MODE, YDS_MODE_RESET); 362 YWRITE4(sc, YDS_MODE, 0); 363 364 YWRITE4(sc, YDS_MAPOF_REC, 0); 365 YWRITE4(sc, YDS_MAPOF_EFFECT, 0); 366 YWRITE4(sc, YDS_PLAY_CTRLBASE, 0); 367 YWRITE4(sc, YDS_REC_CTRLBASE, 0); 368 YWRITE4(sc, YDS_EFFECT_CTRLBASE, 0); 369 YWRITE4(sc, YDS_WORK_BASE, 0); 370 371 ctrl = YREAD2(sc, YDS_GLOBAL_CONTROL); 372 YWRITE2(sc, YDS_GLOBAL_CONTROL, ctrl & ~0x0007); 373 374 /* Download DSP microcode. */ 375 p = yds_dsp_mcode; 376 size = sizeof(yds_dsp_mcode); 377 YWRITEREGION4(sc, YDS_DSP_INSTRAM, p, size); 378 379 /* Download CONTROL microcode. */ 380 p = ctrls[dstype].mcode; 381 size = ctrls[dstype].size; 382 YWRITEREGION4(sc, YDS_CTRL_INSTRAM, p, size); 383 384 yds_enable_dsp(sc); 385 delay(10 * 1000); /* nessesary on my 724F (??) */ 386 387 return 0; 388 } 389 390 static int 391 yds_allocate_slots(sc) 392 struct yds_softc *sc; 393 { 394 size_t pcs, rcs, ecs, ws, memsize; 395 void *mp; 396 u_int32_t da; /* DMA address */ 397 char *va; /* KVA */ 398 off_t cb; 399 int i; 400 struct yds_dma *p; 401 402 /* Alloc DSP Control Data */ 403 pcs = YREAD4(sc, YDS_PLAY_CTRLSIZE) * sizeof(u_int32_t); 404 rcs = YREAD4(sc, YDS_REC_CTRLSIZE) * sizeof(u_int32_t); 405 ecs = YREAD4(sc, YDS_EFFECT_CTRLSIZE) * sizeof(u_int32_t); 406 ws = WORK_SIZE; 407 YWRITE4(sc, YDS_WORK_SIZE, ws / sizeof(u_int32_t)); 408 409 DPRINTF(("play control size : %d\n", (unsigned int)pcs)); 410 DPRINTF(("rec control size : %d\n", (unsigned int)rcs)); 411 DPRINTF(("eff control size : %d\n", (unsigned int)ecs)); 412 DPRINTF(("work size : %d\n", (unsigned int)ws)); 413 #ifdef DIAGNOSTIC 414 if (pcs != sizeof(struct play_slot_ctrl_bank)) { 415 printf("%s: invalid play slot ctrldata %d != %d\n", 416 sc->sc_dev.dv_xname, (unsigned int)pcs, 417 (unsigned int)sizeof(struct play_slot_ctrl_bank)); 418 if (rcs != sizeof(struct rec_slot_ctrl_bank)) 419 printf("%s: invalid rec slot ctrldata %d != %d\n", 420 sc->sc_dev.dv_xname, (unsigned int)rcs, 421 (unsigned int)sizeof(struct rec_slot_ctrl_bank)); 422 } 423 #endif 424 425 memsize = N_PLAY_SLOTS*N_PLAY_SLOT_CTRL_BANK*pcs + 426 N_REC_SLOT_CTRL*N_REC_SLOT_CTRL_BANK*rcs + ws; 427 memsize += (N_PLAY_SLOTS+1)*sizeof(u_int32_t); 428 429 p = &sc->sc_ctrldata; 430 i = yds_allocmem(sc, memsize, 16, p); 431 if (i) { 432 printf("%s: couldn't alloc/map DSP DMA buffer, reason %d\n", 433 sc->sc_dev.dv_xname, i); 434 free(p, M_DEVBUF); 435 return 1; 436 } 437 mp = KERNADDR(p); 438 da = DMAADDR(p); 439 440 DPRINTF(("mp:%p, DMA addr:%p\n", 441 mp, (void *)sc->sc_ctrldata.map->dm_segs[0].ds_addr)); 442 443 memset(mp, 0, memsize); 444 445 /* Work space */ 446 cb = 0; 447 va = (u_int8_t *)mp; 448 YWRITE4(sc, YDS_WORK_BASE, da + cb); 449 cb += ws; 450 451 /* Play control data table */ 452 sc->ptbl = (u_int32_t *)(va + cb); 453 sc->ptbloff = cb; 454 YWRITE4(sc, YDS_PLAY_CTRLBASE, da + cb); 455 cb += (N_PLAY_SLOT_CTRL + 1) * sizeof(u_int32_t); 456 457 /* Record slot control data */ 458 sc->rbank = (struct rec_slot_ctrl_bank *)(va + cb); 459 YWRITE4(sc, YDS_REC_CTRLBASE, da + cb); 460 sc->rbankoff = cb; 461 cb += N_REC_SLOT_CTRL * N_REC_SLOT_CTRL_BANK * rcs; 462 463 #if 0 464 /* Effect slot control data -- unused */ 465 YWRITE4(sc, YDS_EFFECT_CTRLBASE, da + cb); 466 cb += N_EFFECT_SLOT_CTRL * N_EFFECT_SLOT_CTRL_BANK * ecs; 467 #endif 468 469 /* Play slot control data */ 470 sc->pbankoff = cb; 471 for (i=0; i < N_PLAY_SLOT_CTRL; i++) { 472 sc->pbankp[i*2] = (struct play_slot_ctrl_bank *)(va + cb); 473 *(sc->ptbl + i+1) = da + cb; 474 cb += pcs; 475 476 sc->pbankp[i*2+1] = (struct play_slot_ctrl_bank *)(va + cb); 477 cb += pcs; 478 } 479 /* Sync play control data table */ 480 bus_dmamap_sync(sc->sc_dmatag, p->map, 481 sc->ptbloff, (N_PLAY_SLOT_CTRL+1) * sizeof(u_int32_t), 482 BUS_DMASYNC_PREWRITE); 483 484 return 0; 485 } 486 487 static void 488 yds_enable_dsp(sc) 489 struct yds_softc *sc; 490 { 491 YWRITE4(sc, YDS_CONFIG, YDS_DSP_SETUP); 492 } 493 494 static int 495 yds_disable_dsp(sc) 496 struct yds_softc *sc; 497 { 498 int to; 499 u_int32_t data; 500 501 data = YREAD4(sc, YDS_CONFIG); 502 if (data) 503 YWRITE4(sc, YDS_CONFIG, YDS_DSP_DISABLE); 504 505 for (to = 0; to < YDS_WORK_TIMEOUT; to++) { 506 if ((YREAD4(sc, YDS_STATUS) & YDS_STAT_WORK) == 0) 507 return 0; 508 delay(1); 509 } 510 511 return 1; 512 } 513 514 int 515 yds_match(parent, match, aux) 516 struct device *parent; 517 struct cfdata *match; 518 void *aux; 519 { 520 struct pci_attach_args *pa = (struct pci_attach_args *)aux; 521 522 switch (PCI_VENDOR(pa->pa_id)) { 523 case PCI_VENDOR_YAMAHA: 524 switch (PCI_PRODUCT(pa->pa_id)) { 525 case PCI_PRODUCT_YAMAHA_YMF724: 526 case PCI_PRODUCT_YAMAHA_YMF740: 527 case PCI_PRODUCT_YAMAHA_YMF740C: 528 case PCI_PRODUCT_YAMAHA_YMF724F: 529 case PCI_PRODUCT_YAMAHA_YMF744B: 530 case PCI_PRODUCT_YAMAHA_YMF754: 531 return (1); 532 } 533 break; 534 } 535 536 return (0); 537 } 538 539 /* 540 * This routine is called after all the ISA devices are configured, 541 * to avoid conflict. 542 */ 543 static void 544 yds_configure_legacy (arg) 545 struct device *arg; 546 #define FLEXIBLE (sc->sc_flags & YDS_CAP_LEGACY_FLEXIBLE) 547 #define SELECTABLE (sc->sc_flags & YDS_CAP_LEGACY_SELECTABLE) 548 { 549 struct yds_softc *sc = (struct yds_softc*) arg; 550 pcireg_t reg; 551 struct device *dev; 552 int i; 553 bus_addr_t opl_addrs[] = {0x388, 0x398, 0x3A0, 0x3A8}; 554 bus_addr_t mpu_addrs[] = {0x330, 0x300, 0x332, 0x334}; 555 556 if (!FLEXIBLE && !SELECTABLE) 557 return; 558 559 reg = pci_conf_read(sc->sc_pc, sc->sc_pcitag, YDS_PCI_LEGACY); 560 reg &= ~0x8133c03f; /* these bits are out of interest */ 561 reg |= ((YDS_PCI_EX_LEGACY_IMOD) | 562 (YDS_PCI_LEGACY_FMEN | 563 YDS_PCI_LEGACY_MEN /*| YDS_PCI_LEGACY_MIEN*/)); 564 if (FLEXIBLE) { 565 pci_conf_write(sc->sc_pc, sc->sc_pcitag, YDS_PCI_LEGACY, reg); 566 delay(100*1000); 567 } 568 569 /* Look for OPL */ 570 dev = 0; 571 for (i = 0; i < sizeof(opl_addrs) / sizeof(bus_addr_t); i++) { 572 if (SELECTABLE) { 573 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 574 YDS_PCI_LEGACY, reg | (i << (0+16))); 575 delay(100*1000); /* wait 100ms */ 576 } else 577 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 578 YDS_PCI_FM_BA, opl_addrs[i]); 579 if (bus_space_map(sc->sc_opl_iot, 580 opl_addrs[i], 4, 0, &sc->sc_opl_ioh) == 0) { 581 struct audio_attach_args aa; 582 583 aa.type = AUDIODEV_TYPE_OPL; 584 aa.hwif = aa.hdl = NULL; 585 dev = config_found(&sc->sc_dev, &aa, audioprint); 586 if (dev == 0) 587 bus_space_unmap(sc->sc_opl_iot, 588 sc->sc_opl_ioh, 4); 589 else { 590 if (SELECTABLE) 591 reg |= (i << (0+16)); 592 break; 593 } 594 } 595 } 596 if (dev == 0) { 597 reg &= ~YDS_PCI_LEGACY_FMEN; 598 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 599 YDS_PCI_LEGACY, reg); 600 } else { 601 /* Max. volume */ 602 YWRITE4(sc, YDS_LEGACY_OUT_VOLUME, 0x3fff3fff); 603 YWRITE4(sc, YDS_LEGACY_REC_VOLUME, 0x3fff3fff); 604 } 605 606 /* Look for MPU */ 607 dev = 0; 608 for (i = 0; i < sizeof(mpu_addrs) / sizeof(bus_addr_t); i++) { 609 if (SELECTABLE) 610 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 611 YDS_PCI_LEGACY, reg | (i << (4+16))); 612 else 613 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 614 YDS_PCI_MPU_BA, mpu_addrs[i]); 615 if (bus_space_map(sc->sc_mpu_iot, 616 mpu_addrs[i], 2, 0, &sc->sc_mpu_ioh) == 0) { 617 struct audio_attach_args aa; 618 619 aa.type = AUDIODEV_TYPE_MPU; 620 aa.hwif = aa.hdl = NULL; 621 dev = config_found(&sc->sc_dev, &aa, audioprint); 622 if (dev == 0) 623 bus_space_unmap(sc->sc_mpu_iot, 624 sc->sc_mpu_ioh, 2); 625 else { 626 if (SELECTABLE) 627 reg |= (i << (4+16)); 628 break; 629 } 630 } 631 } 632 if (dev == 0) { 633 reg &= ~(YDS_PCI_LEGACY_MEN | YDS_PCI_LEGACY_MIEN); 634 pci_conf_write(sc->sc_pc, sc->sc_pcitag, YDS_PCI_LEGACY, reg); 635 } 636 sc->sc_mpu = dev; 637 } 638 #undef FLEXIBLE 639 #undef SELECTABLE 640 641 void 642 yds_attach(parent, self, aux) 643 struct device *parent; 644 struct device *self; 645 void *aux; 646 { 647 struct yds_softc *sc = (struct yds_softc *)self; 648 struct pci_attach_args *pa = (struct pci_attach_args *)aux; 649 pci_chipset_tag_t pc = pa->pa_pc; 650 char const *intrstr; 651 pci_intr_handle_t ih; 652 pcireg_t reg; 653 struct yds_codec_softc *codec; 654 char devinfo[256]; 655 mixer_ctrl_t ctl; 656 int i, r, to; 657 int revision; 658 int ac97_id2; 659 660 pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo); 661 revision = PCI_REVISION(pa->pa_class); 662 printf(": %s (rev. 0x%02x)\n", devinfo, revision); 663 664 /* Map register to memory */ 665 if (pci_mapreg_map(pa, YDS_PCI_MBA, PCI_MAPREG_TYPE_MEM, 0, 666 &sc->memt, &sc->memh, NULL, NULL)) { 667 printf("%s: can't map memory space\n", sc->sc_dev.dv_xname); 668 return; 669 } 670 671 /* Map and establish the interrupt. */ 672 if (pci_intr_map(pa, &ih)) { 673 printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname); 674 return; 675 } 676 intrstr = pci_intr_string(pc, ih); 677 sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, yds_intr, sc); 678 if (sc->sc_ih == NULL) { 679 printf("%s: couldn't establish interrupt", sc->sc_dev.dv_xname); 680 if (intrstr != NULL) 681 printf(" at %s", intrstr); 682 printf("\n"); 683 return; 684 } 685 printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr); 686 687 sc->sc_dmatag = pa->pa_dmat; 688 sc->sc_pc = pc; 689 sc->sc_pcitag = pa->pa_tag; 690 sc->sc_id = pa->pa_id; 691 sc->sc_revision = revision; 692 sc->sc_flags = yds_get_dstype(sc->sc_id); 693 #ifdef AUDIO_DEBUG 694 if (ydsdebug) { 695 char bits[80]; 696 697 printf("%s: chip has %s\n", sc->sc_dev.dv_xname, 698 bitmask_snprintf(sc->sc_flags, YDS_CAP_BITS, bits, 699 sizeof(bits))); 700 } 701 #endif 702 703 /* Disable legacy mode */ 704 reg = pci_conf_read(pc, pa->pa_tag, YDS_PCI_LEGACY); 705 pci_conf_write(pc, pa->pa_tag, YDS_PCI_LEGACY, 706 reg & YDS_PCI_LEGACY_LAD); 707 708 /* Enable the device. */ 709 reg = pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 710 reg |= (PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MEM_ENABLE | 711 PCI_COMMAND_MASTER_ENABLE); 712 pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, reg); 713 reg = pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 714 715 /* Mute all volumes */ 716 for (i = 0x80; i < 0xc0; i += 2) 717 YWRITE2(sc, i, 0); 718 719 /* Download microcode */ 720 if (yds_download_mcode(sc)) { 721 printf("%s: download microcode failed\n", sc->sc_dev.dv_xname); 722 return; 723 } 724 /* Allocate DMA buffers */ 725 if (yds_allocate_slots(sc)) { 726 printf("%s: could not allocate slots\n", sc->sc_dev.dv_xname); 727 return; 728 } 729 730 /* Warm reset */ 731 reg = pci_conf_read(pc, pa->pa_tag, YDS_PCI_DSCTRL); 732 pci_conf_write(pc, pa->pa_tag, YDS_PCI_DSCTRL, reg | YDS_DSCTRL_WRST); 733 delay(50000); 734 735 /* 736 * Detect primary/secondary AC97 737 * YMF754 Hardware Specification Rev 1.01 page 24 738 */ 739 reg = pci_conf_read(pc, pa->pa_tag, YDS_PCI_DSCTRL); 740 pci_conf_write(pc, pa->pa_tag, YDS_PCI_DSCTRL, reg & ~YDS_DSCTRL_CRST); 741 delay(400000); /* Needed for 740C. */ 742 743 /* Primary */ 744 for (to = 0; to < AC97_TIMEOUT; to++) { 745 if ((YREAD2(sc, AC97_STAT_ADDR1) & AC97_BUSY) == 0) 746 break; 747 delay(1); 748 } 749 if (to == AC97_TIMEOUT) { 750 printf("%s: no AC97 avaliable\n", sc->sc_dev.dv_xname); 751 return; 752 } 753 754 /* Secondary */ 755 /* Secondary AC97 is used for 4ch audio. Currently unused. */ 756 ac97_id2 = -1; 757 if ((YREAD2(sc, YDS_ACTIVITY) & YDS_ACTIVITY_DOCKA) == 0) 758 goto detected; 759 #if 0 /* reset secondary... */ 760 YWRITE2(sc, YDS_GPIO_OCTRL, 761 YREAD2(sc, YDS_GPIO_OCTRL) & ~YDS_GPIO_GPO2); 762 YWRITE2(sc, YDS_GPIO_FUNCE, 763 (YREAD2(sc, YDS_GPIO_FUNCE)&(~YDS_GPIO_GPC2))|YDS_GPIO_GPE2); 764 #endif 765 for (to = 0; to < AC97_TIMEOUT; to++) { 766 if ((YREAD2(sc, AC97_STAT_ADDR2) & AC97_BUSY) == 0) 767 break; 768 delay(1); 769 } 770 if (to < AC97_TIMEOUT) { 771 /* detect id */ 772 for (ac97_id2 = 1; ac97_id2 < 4; ac97_id2++) { 773 YWRITE2(sc, AC97_CMD_ADDR, 774 AC97_CMD_READ | AC97_ID(ac97_id2) | 0x28); 775 776 for (to = 0; to < AC97_TIMEOUT; to++) { 777 if ((YREAD2(sc, AC97_STAT_ADDR2) & AC97_BUSY) 778 == 0) 779 goto detected; 780 delay(1); 781 } 782 } 783 if (ac97_id2 == 4) 784 ac97_id2 = -1; 785 detected: 786 ; 787 } 788 789 pci_conf_write(pc, pa->pa_tag, YDS_PCI_DSCTRL, reg | YDS_DSCTRL_CRST); 790 delay (20); 791 pci_conf_write(pc, pa->pa_tag, YDS_PCI_DSCTRL, reg & ~YDS_DSCTRL_CRST); 792 delay (400000); 793 for (to = 0; to < AC97_TIMEOUT; to++) { 794 if ((YREAD2(sc, AC97_STAT_ADDR1) & AC97_BUSY) == 0) 795 break; 796 delay(1); 797 } 798 799 /* 800 * Attach ac97 codec 801 */ 802 for (i = 0; i < 2; i++) { 803 static struct { 804 int data; 805 int addr; 806 } statregs[] = { 807 {AC97_STAT_DATA1, AC97_STAT_ADDR1}, 808 {AC97_STAT_DATA2, AC97_STAT_ADDR2}, 809 }; 810 811 if (i == 1 && ac97_id2 == -1) 812 break; /* secondary ac97 not available */ 813 814 codec = &sc->sc_codec[i]; 815 memcpy(&codec->sc_dev, &sc->sc_dev, sizeof(codec->sc_dev)); 816 codec->sc = sc; 817 codec->id = i == 1 ? ac97_id2 : 0; 818 codec->status_data = statregs[i].data; 819 codec->status_addr = statregs[i].addr; 820 codec->host_if.arg = codec; 821 codec->host_if.attach = yds_attach_codec; 822 codec->host_if.read = yds_read_codec; 823 codec->host_if.write = yds_write_codec; 824 codec->host_if.reset = yds_reset_codec; 825 826 if ((r = ac97_attach(&codec->host_if)) != 0) { 827 printf("%s: can't attach codec (error 0x%X)\n", 828 sc->sc_dev.dv_xname, r); 829 return; 830 } 831 } 832 833 /* Just enable the DAC and master volumes by default */ 834 ctl.type = AUDIO_MIXER_ENUM; 835 ctl.un.ord = 0; /* off */ 836 ctl.dev = yds_get_portnum_by_name(sc, AudioCoutputs, 837 AudioNmaster, AudioNmute); 838 yds_mixer_set_port(sc, &ctl); 839 ctl.dev = yds_get_portnum_by_name(sc, AudioCinputs, 840 AudioNdac, AudioNmute); 841 yds_mixer_set_port(sc, &ctl); 842 ctl.dev = yds_get_portnum_by_name(sc, AudioCinputs, 843 AudioNcd, AudioNmute); 844 yds_mixer_set_port(sc, &ctl); 845 ctl.dev = yds_get_portnum_by_name(sc, AudioCrecord, 846 AudioNvolume, AudioNmute); 847 yds_mixer_set_port(sc, &ctl); 848 849 ctl.dev = yds_get_portnum_by_name(sc, AudioCrecord, 850 AudioNsource, NULL); 851 ctl.type = AUDIO_MIXER_ENUM; 852 ctl.un.ord = 0; 853 yds_mixer_set_port(sc, &ctl); 854 855 /* Set a reasonable default volume */ 856 ctl.type = AUDIO_MIXER_VALUE; 857 ctl.un.value.num_channels = 2; 858 ctl.un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 859 ctl.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 127; 860 861 ctl.dev = sc->sc_codec[0].codec_if->vtbl->get_portnum_by_name( 862 sc->sc_codec[0].codec_if, AudioCoutputs, AudioNmaster, NULL); 863 yds_mixer_set_port(sc, &ctl); 864 865 audio_attach_mi(&yds_hw_if, sc, &sc->sc_dev); 866 867 sc->sc_legacy_iot = pa->pa_iot; 868 config_defer((struct device*) sc, yds_configure_legacy); 869 } 870 871 int 872 yds_attach_codec(sc_, codec_if) 873 void *sc_; 874 struct ac97_codec_if *codec_if; 875 { 876 struct yds_codec_softc *sc = sc_; 877 878 sc->codec_if = codec_if; 879 return 0; 880 } 881 882 static int 883 yds_ready_codec(sc) 884 struct yds_codec_softc *sc; 885 { 886 int to; 887 888 for (to = 0; to < AC97_TIMEOUT; to++) { 889 if ((YREAD2(sc->sc, sc->status_addr) & AC97_BUSY) == 0) 890 return 0; 891 delay(1); 892 } 893 894 return 1; 895 } 896 897 int 898 yds_read_codec(sc_, reg, data) 899 void *sc_; 900 u_int8_t reg; 901 u_int16_t *data; 902 { 903 struct yds_codec_softc *sc = sc_; 904 905 YWRITE2(sc->sc, AC97_CMD_ADDR, AC97_CMD_READ | AC97_ID(sc->id) | reg); 906 907 if (yds_ready_codec(sc)) { 908 printf("%s: yds_read_codec timeout\n", 909 sc->sc->sc_dev.dv_xname); 910 return EIO; 911 } 912 913 if (PCI_PRODUCT(sc->sc->sc_id) == PCI_PRODUCT_YAMAHA_YMF744B && 914 sc->sc->sc_revision < 2) { 915 int i; 916 for (i=0; i<600; i++) 917 YREAD2(sc->sc, sc->status_data); 918 } 919 920 *data = YREAD2(sc->sc, sc->status_data); 921 922 return 0; 923 } 924 925 int 926 yds_write_codec(sc_, reg, data) 927 void *sc_; 928 u_int8_t reg; 929 u_int16_t data; 930 { 931 struct yds_codec_softc *sc = sc_; 932 933 YWRITE2(sc->sc, AC97_CMD_ADDR, AC97_CMD_WRITE | AC97_ID(sc->id) | reg); 934 YWRITE2(sc->sc, AC97_CMD_DATA, data); 935 936 if (yds_ready_codec(sc)) { 937 printf("%s: yds_write_codec timeout\n", 938 sc->sc->sc_dev.dv_xname); 939 return EIO; 940 } 941 942 return 0; 943 } 944 945 /* 946 * XXX: Must handle the secondary differntly!! 947 */ 948 void 949 yds_reset_codec(sc_) 950 void *sc_; 951 { 952 struct yds_codec_softc *codec = sc_; 953 struct yds_softc *sc = codec->sc; 954 pcireg_t reg; 955 956 /* reset AC97 codec */ 957 reg = pci_conf_read(sc->sc_pc, sc->sc_pcitag, YDS_PCI_DSCTRL); 958 if (reg & 0x03) { 959 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 960 YDS_PCI_DSCTRL, reg & ~0x03); 961 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 962 YDS_PCI_DSCTRL, reg | 0x03); 963 pci_conf_write(sc->sc_pc, sc->sc_pcitag, 964 YDS_PCI_DSCTRL, reg & ~0x03); 965 delay(50000); 966 } 967 968 yds_ready_codec(sc_); 969 } 970 971 int 972 yds_intr(p) 973 void *p; 974 { 975 struct yds_softc *sc = p; 976 u_int status; 977 978 status = YREAD4(sc, YDS_STATUS); 979 DPRINTFN(1, ("yds_intr: status=%08x\n", status)); 980 if ((status & (YDS_STAT_INT|YDS_STAT_TINT)) == 0) { 981 #if NMPU > 0 982 if (sc->sc_mpu) 983 return mpu_intr(sc->sc_mpu); 984 #endif 985 return 0; 986 } 987 988 if (status & YDS_STAT_TINT) { 989 YWRITE4(sc, YDS_STATUS, YDS_STAT_TINT); 990 printf ("yds_intr: timeout!\n"); 991 } 992 993 if (status & YDS_STAT_INT) { 994 int nbank = (YREAD4(sc, YDS_CONTROL_SELECT) == 0); 995 996 /* Clear interrupt flag */ 997 YWRITE4(sc, YDS_STATUS, YDS_STAT_INT); 998 999 /* Buffer for the next frame is always ready. */ 1000 YWRITE4(sc, YDS_MODE, YREAD4(sc, YDS_MODE) | YDS_MODE_ACTV2); 1001 1002 if (sc->sc_play.intr) { 1003 u_int dma, cpu, blk, len; 1004 1005 /* Sync play slot control data */ 1006 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1007 sc->pbankoff, 1008 sizeof(struct play_slot_ctrl_bank)* 1009 (*sc->ptbl)* 1010 N_PLAY_SLOT_CTRL_BANK, 1011 BUS_DMASYNC_POSTWRITE| 1012 BUS_DMASYNC_POSTREAD); 1013 dma = sc->pbankp[nbank]->pgstart * sc->sc_play.factor; 1014 cpu = sc->sc_play.offset; 1015 blk = sc->sc_play.blksize; 1016 len = sc->sc_play.length; 1017 1018 if (((dma > cpu) && (dma - cpu > blk * 2)) || 1019 ((cpu > dma) && (dma + len - cpu > blk * 2))) { 1020 /* We can fill the next block */ 1021 /* Sync ring buffer for previous write */ 1022 bus_dmamap_sync(sc->sc_dmatag, 1023 sc->sc_play.dma->map, 1024 cpu, blk, 1025 BUS_DMASYNC_POSTWRITE); 1026 sc->sc_play.intr(sc->sc_play.intr_arg); 1027 sc->sc_play.offset += blk; 1028 if (sc->sc_play.offset >= len) { 1029 sc->sc_play.offset -= len; 1030 #ifdef DIAGNOSTIC 1031 if (sc->sc_play.offset != 0) 1032 printf ("Audio ringbuffer botch\n"); 1033 #endif 1034 } 1035 /* Sync ring buffer for next write */ 1036 bus_dmamap_sync(sc->sc_dmatag, 1037 sc->sc_play.dma->map, 1038 cpu, blk, 1039 BUS_DMASYNC_PREWRITE); 1040 } 1041 } 1042 if (sc->sc_rec.intr) { 1043 u_int dma, cpu, blk, len; 1044 1045 /* Sync rec slot control data */ 1046 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1047 sc->rbankoff, 1048 sizeof(struct rec_slot_ctrl_bank)* 1049 N_REC_SLOT_CTRL* 1050 N_REC_SLOT_CTRL_BANK, 1051 BUS_DMASYNC_POSTWRITE| 1052 BUS_DMASYNC_POSTREAD); 1053 dma = sc->rbank[YDS_INPUT_SLOT*2 + nbank].pgstartadr; 1054 cpu = sc->sc_rec.offset; 1055 blk = sc->sc_rec.blksize; 1056 len = sc->sc_rec.length; 1057 1058 if (((dma > cpu) && (dma - cpu > blk * 2)) || 1059 ((cpu > dma) && (dma + len - cpu > blk * 2))) { 1060 /* We can drain the current block */ 1061 /* Sync ring buffer first */ 1062 bus_dmamap_sync(sc->sc_dmatag, 1063 sc->sc_rec.dma->map, 1064 cpu, blk, 1065 BUS_DMASYNC_POSTREAD); 1066 sc->sc_rec.intr(sc->sc_rec.intr_arg); 1067 sc->sc_rec.offset += blk; 1068 if (sc->sc_rec.offset >= len) { 1069 sc->sc_rec.offset -= len; 1070 #ifdef DIAGNOSTIC 1071 if (sc->sc_rec.offset != 0) 1072 printf ("Audio ringbuffer botch\n"); 1073 #endif 1074 } 1075 /* Sync ring buffer for next read */ 1076 bus_dmamap_sync(sc->sc_dmatag, 1077 sc->sc_rec.dma->map, 1078 cpu, blk, 1079 BUS_DMASYNC_PREREAD); 1080 } 1081 } 1082 } 1083 1084 return 1; 1085 } 1086 1087 int 1088 yds_allocmem(sc, size, align, p) 1089 struct yds_softc *sc; 1090 size_t size; 1091 size_t align; 1092 struct yds_dma *p; 1093 { 1094 int error; 1095 1096 p->size = size; 1097 error = bus_dmamem_alloc(sc->sc_dmatag, p->size, align, 0, 1098 p->segs, sizeof(p->segs)/sizeof(p->segs[0]), 1099 &p->nsegs, BUS_DMA_NOWAIT); 1100 if (error) 1101 return (error); 1102 1103 error = bus_dmamem_map(sc->sc_dmatag, p->segs, p->nsegs, p->size, 1104 &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT); 1105 if (error) 1106 goto free; 1107 1108 error = bus_dmamap_create(sc->sc_dmatag, p->size, 1, p->size, 1109 0, BUS_DMA_NOWAIT, &p->map); 1110 if (error) 1111 goto unmap; 1112 1113 error = bus_dmamap_load(sc->sc_dmatag, p->map, p->addr, p->size, NULL, 1114 BUS_DMA_NOWAIT); 1115 if (error) 1116 goto destroy; 1117 return (0); 1118 1119 destroy: 1120 bus_dmamap_destroy(sc->sc_dmatag, p->map); 1121 unmap: 1122 bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size); 1123 free: 1124 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 1125 return (error); 1126 } 1127 1128 int 1129 yds_freemem(sc, p) 1130 struct yds_softc *sc; 1131 struct yds_dma *p; 1132 { 1133 bus_dmamap_unload(sc->sc_dmatag, p->map); 1134 bus_dmamap_destroy(sc->sc_dmatag, p->map); 1135 bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size); 1136 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 1137 return 0; 1138 } 1139 1140 int 1141 yds_open(addr, flags) 1142 void *addr; 1143 int flags; 1144 { 1145 struct yds_softc *sc = addr; 1146 int mode; 1147 1148 /* Select bank 0. */ 1149 YWRITE4(sc, YDS_CONTROL_SELECT, 0); 1150 1151 /* Start the DSP operation. */ 1152 mode = YREAD4(sc, YDS_MODE); 1153 mode |= YDS_MODE_ACTV; 1154 mode &= ~YDS_MODE_ACTV2; 1155 YWRITE4(sc, YDS_MODE, mode); 1156 1157 return 0; 1158 } 1159 1160 /* 1161 * Close function is called at splaudio(). 1162 */ 1163 void 1164 yds_close(addr) 1165 void *addr; 1166 { 1167 struct yds_softc *sc = addr; 1168 1169 yds_halt_output(sc); 1170 yds_halt_input(sc); 1171 yds_halt(sc); 1172 } 1173 1174 int 1175 yds_query_encoding(addr, fp) 1176 void *addr; 1177 struct audio_encoding *fp; 1178 { 1179 switch (fp->index) { 1180 case 0: 1181 strcpy(fp->name, AudioEulinear); 1182 fp->encoding = AUDIO_ENCODING_ULINEAR; 1183 fp->precision = 8; 1184 fp->flags = 0; 1185 return (0); 1186 case 1: 1187 strcpy(fp->name, AudioEmulaw); 1188 fp->encoding = AUDIO_ENCODING_ULAW; 1189 fp->precision = 8; 1190 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1191 return (0); 1192 case 2: 1193 strcpy(fp->name, AudioEalaw); 1194 fp->encoding = AUDIO_ENCODING_ALAW; 1195 fp->precision = 8; 1196 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1197 return (0); 1198 case 3: 1199 strcpy(fp->name, AudioEslinear); 1200 fp->encoding = AUDIO_ENCODING_SLINEAR; 1201 fp->precision = 8; 1202 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1203 return (0); 1204 case 4: 1205 strcpy(fp->name, AudioEslinear_le); 1206 fp->encoding = AUDIO_ENCODING_SLINEAR_LE; 1207 fp->precision = 16; 1208 fp->flags = 0; 1209 return (0); 1210 case 5: 1211 strcpy(fp->name, AudioEulinear_le); 1212 fp->encoding = AUDIO_ENCODING_ULINEAR_LE; 1213 fp->precision = 16; 1214 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1215 return (0); 1216 case 6: 1217 strcpy(fp->name, AudioEslinear_be); 1218 fp->encoding = AUDIO_ENCODING_SLINEAR_BE; 1219 fp->precision = 16; 1220 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1221 return (0); 1222 case 7: 1223 strcpy(fp->name, AudioEulinear_be); 1224 fp->encoding = AUDIO_ENCODING_ULINEAR_BE; 1225 fp->precision = 16; 1226 fp->flags = AUDIO_ENCODINGFLAG_EMULATED; 1227 return (0); 1228 default: 1229 return (EINVAL); 1230 } 1231 } 1232 1233 int 1234 yds_set_params(addr, setmode, usemode, play, rec) 1235 void *addr; 1236 int setmode, usemode; 1237 struct audio_params *play, *rec; 1238 { 1239 struct audio_params *p; 1240 int mode; 1241 1242 for (mode = AUMODE_RECORD; mode != -1; 1243 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) { 1244 if ((setmode & mode) == 0) 1245 continue; 1246 1247 p = mode == AUMODE_PLAY ? play : rec; 1248 1249 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 1250 (p->precision != 8 && p->precision != 16) || 1251 (p->channels != 1 && p->channels != 2)) 1252 return (EINVAL); 1253 1254 p->factor = 1; 1255 p->sw_code = 0; 1256 switch (p->encoding) { 1257 case AUDIO_ENCODING_SLINEAR_BE: 1258 if (p->precision == 16) 1259 p->sw_code = swap_bytes; 1260 else 1261 p->sw_code = change_sign8; 1262 break; 1263 case AUDIO_ENCODING_SLINEAR_LE: 1264 if (p->precision != 16) 1265 p->sw_code = change_sign8; 1266 break; 1267 case AUDIO_ENCODING_ULINEAR_BE: 1268 if (p->precision == 16) { 1269 if (mode == AUMODE_PLAY) 1270 p->sw_code = swap_bytes_change_sign16_le; 1271 else 1272 p->sw_code = change_sign16_swap_bytes_le; 1273 } 1274 break; 1275 case AUDIO_ENCODING_ULINEAR_LE: 1276 if (p->precision == 16) 1277 p->sw_code = change_sign16_le; 1278 break; 1279 case AUDIO_ENCODING_ULAW: 1280 if (mode == AUMODE_PLAY) { 1281 p->factor = 2; 1282 p->precision = 16; 1283 p->sw_code = mulaw_to_slinear16_le; 1284 } else 1285 p->sw_code = ulinear8_to_mulaw; 1286 break; 1287 case AUDIO_ENCODING_ALAW: 1288 if (mode == AUMODE_PLAY) { 1289 p->factor = 2; 1290 p->precision = 16; 1291 p->sw_code = alaw_to_slinear16_le; 1292 } else 1293 p->sw_code = ulinear8_to_alaw; 1294 break; 1295 default: 1296 return (EINVAL); 1297 } 1298 } 1299 1300 return 0; 1301 } 1302 1303 int 1304 yds_round_blocksize(addr, blk) 1305 void *addr; 1306 int blk; 1307 { 1308 /* 1309 * Block size must be bigger than a frame. 1310 * That is 1024bytes at most, i.e. for 48000Hz, 16bit, 2ch. 1311 */ 1312 if (blk < 1024) 1313 blk = 1024; 1314 1315 return blk & ~4; 1316 } 1317 1318 static u_int32_t 1319 yds_get_lpfq(sample_rate) 1320 u_int sample_rate; 1321 { 1322 int i; 1323 static struct lpfqt { 1324 u_int rate; 1325 u_int32_t lpfq; 1326 } lpfqt[] = { 1327 {8000, 0x32020000}, 1328 {11025, 0x31770000}, 1329 {16000, 0x31390000}, 1330 {22050, 0x31c90000}, 1331 {32000, 0x33d00000}, 1332 {48000, 0x40000000}, 1333 {0, 0} 1334 }; 1335 1336 if (sample_rate == 44100) /* for P44 slot? */ 1337 return 0x370A0000; 1338 1339 for (i = 0; lpfqt[i].rate != 0; i++) 1340 if (sample_rate <= lpfqt[i].rate) 1341 break; 1342 1343 return lpfqt[i].lpfq; 1344 } 1345 1346 static u_int32_t 1347 yds_get_lpfk(sample_rate) 1348 u_int sample_rate; 1349 { 1350 int i; 1351 static struct lpfkt { 1352 u_int rate; 1353 u_int32_t lpfk; 1354 } lpfkt[] = { 1355 {8000, 0x18b20000}, 1356 {11025, 0x20930000}, 1357 {16000, 0x2b9a0000}, 1358 {22050, 0x35a10000}, 1359 {32000, 0x3eaa0000}, 1360 {48000, 0x40000000}, 1361 {0, 0} 1362 }; 1363 1364 if (sample_rate == 44100) /* for P44 slot? */ 1365 return 0x46460000; 1366 1367 for (i = 0; lpfkt[i].rate != 0; i++) 1368 if (sample_rate <= lpfkt[i].rate) 1369 break; 1370 1371 return lpfkt[i].lpfk; 1372 } 1373 1374 int 1375 yds_trigger_output(addr, start, end, blksize, intr, arg, param) 1376 void *addr; 1377 void *start, *end; 1378 int blksize; 1379 void (*intr) __P((void *)); 1380 void *arg; 1381 struct audio_params *param; 1382 #define P44 (sc->sc_flags & YDS_CAP_HAS_P44) 1383 { 1384 struct yds_softc *sc = addr; 1385 struct yds_dma *p; 1386 struct play_slot_ctrl_bank *psb; 1387 const u_int gain = 0x40000000; 1388 bus_addr_t s; 1389 size_t l; 1390 int i; 1391 int p44, channels; 1392 1393 #ifdef DIAGNOSTIC 1394 if (sc->sc_play.intr) 1395 panic("yds_trigger_output: already running"); 1396 #endif 1397 1398 sc->sc_play.intr = intr; 1399 sc->sc_play.intr_arg = arg; 1400 sc->sc_play.offset = 0; 1401 sc->sc_play.blksize = blksize; 1402 1403 DPRINTFN(1, ("yds_trigger_output: sc=%p start=%p end=%p " 1404 "blksize=%d intr=%p(%p)\n", addr, start, end, blksize, intr, arg)); 1405 1406 p = yds_find_dma(sc, start); 1407 if (!p) { 1408 printf("yds_trigger_output: bad addr %p\n", start); 1409 return (EINVAL); 1410 } 1411 sc->sc_play.dma = p; 1412 1413 #ifdef YDS_USE_P44 1414 /* The document says the P44 SRC supports only stereo, 16bit PCM. */ 1415 if (P44) 1416 p44 = ((param->sample_rate == 44100) && 1417 (param->channels == 2) && 1418 (param->precision == 16)); 1419 else 1420 #endif 1421 p44 = 0; 1422 channels = p44 ? 1 : param->channels; 1423 1424 s = DMAADDR(p); 1425 l = ((char *)end - (char *)start); 1426 sc->sc_play.length = l; 1427 1428 *sc->ptbl = channels; /* Num of play */ 1429 1430 sc->sc_play.factor = 1; 1431 if (param->channels == 2) 1432 sc->sc_play.factor *= 2; 1433 if (param->precision != 8) 1434 sc->sc_play.factor *= 2; 1435 l /= sc->sc_play.factor; 1436 1437 psb = sc->pbankp[0]; 1438 memset(psb, 0, sizeof(*psb)); 1439 psb->format = ((channels == 2 ? PSLT_FORMAT_STEREO : 0) | 1440 (param->precision == 8 ? PSLT_FORMAT_8BIT : 0) | 1441 (p44 ? PSLT_FORMAT_SRC441 : 0)); 1442 psb->pgbase = s; 1443 psb->pgloopend = l; 1444 if (!p44) { 1445 psb->pgdeltaend = (param->sample_rate * 65536 / 48000) << 12; 1446 psb->lpfkend = yds_get_lpfk(param->sample_rate); 1447 psb->eggainend = gain; 1448 psb->lpfq = yds_get_lpfq(param->sample_rate); 1449 psb->pgdelta = psb->pgdeltaend; 1450 psb->lpfk = yds_get_lpfk(param->sample_rate); 1451 psb->eggain = gain; 1452 } 1453 1454 for (i = 0; i < channels; i++) { 1455 /* i == 0: left or mono, i == 1: right */ 1456 psb = sc->pbankp[i*2]; 1457 if (i) 1458 /* copy from left */ 1459 *psb = *(sc->pbankp[0]); 1460 if (channels == 2) { 1461 /* stereo */ 1462 if (i == 0) { 1463 psb->lchgain = psb->lchgainend = gain; 1464 } else { 1465 psb->lchgain = psb->lchgainend = 0; 1466 psb->rchgain = psb->rchgainend = gain; 1467 psb->format |= PSLT_FORMAT_RCH; 1468 } 1469 } else if (!p44) { 1470 /* mono */ 1471 psb->lchgain = psb->rchgain = gain; 1472 psb->lchgainend = psb->rchgainend = gain; 1473 } 1474 /* copy to the other bank */ 1475 *(sc->pbankp[i*2+1]) = *psb; 1476 } 1477 1478 YDS_DUMP_PLAY_SLOT(5, sc, 0); 1479 YDS_DUMP_PLAY_SLOT(5, sc, 1); 1480 1481 if (p44) 1482 YWRITE4(sc, YDS_P44_OUT_VOLUME, 0x3fff3fff); 1483 else 1484 YWRITE4(sc, YDS_DAC_OUT_VOLUME, 0x3fff3fff); 1485 1486 /* Now the play slot for the next frame is set up!! */ 1487 /* Sync play slot control data for both directions */ 1488 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1489 sc->ptbloff, 1490 sizeof(struct play_slot_ctrl_bank) * 1491 channels * N_PLAY_SLOT_CTRL_BANK, 1492 BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD); 1493 /* Sync ring buffer */ 1494 bus_dmamap_sync(sc->sc_dmatag, p->map, 0, blksize, 1495 BUS_DMASYNC_PREWRITE); 1496 /* HERE WE GO!! */ 1497 YWRITE4(sc, YDS_MODE, 1498 YREAD4(sc, YDS_MODE) | YDS_MODE_ACTV | YDS_MODE_ACTV2); 1499 1500 return 0; 1501 } 1502 #undef P44 1503 1504 int 1505 yds_trigger_input(addr, start, end, blksize, intr, arg, param) 1506 void *addr; 1507 void *start, *end; 1508 int blksize; 1509 void (*intr) __P((void *)); 1510 void *arg; 1511 struct audio_params *param; 1512 { 1513 struct yds_softc *sc = addr; 1514 struct yds_dma *p; 1515 u_int srate, format; 1516 struct rec_slot_ctrl_bank *rsb; 1517 bus_addr_t s; 1518 size_t l; 1519 1520 #ifdef DIAGNOSTIC 1521 if (sc->sc_rec.intr) 1522 panic("yds_trigger_input: already running"); 1523 #endif 1524 sc->sc_rec.intr = intr; 1525 sc->sc_rec.intr_arg = arg; 1526 sc->sc_rec.offset = 0; 1527 sc->sc_rec.blksize = blksize; 1528 1529 DPRINTFN(1, ("yds_trigger_input: " 1530 "sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n", 1531 addr, start, end, blksize, intr, arg)); 1532 DPRINTFN(1, (" parameters: rate=%lu, precision=%u, channels=%u\n", 1533 param->sample_rate, param->precision, param->channels)); 1534 1535 p = yds_find_dma(sc, start); 1536 if (!p) { 1537 printf("yds_trigger_input: bad addr %p\n", start); 1538 return (EINVAL); 1539 } 1540 sc->sc_rec.dma = p; 1541 1542 s = DMAADDR(p); 1543 l = ((char *)end - (char *)start); 1544 sc->sc_rec.length = l; 1545 1546 sc->sc_rec.factor = 1; 1547 if (param->channels == 2) 1548 sc->sc_rec.factor *= 2; 1549 if (param->precision != 8) 1550 sc->sc_rec.factor *= 2; 1551 1552 rsb = &sc->rbank[0]; 1553 memset(rsb, 0, sizeof(*rsb)); 1554 rsb->pgbase = s; 1555 rsb->pgloopendadr = l; 1556 /* Seems all 4 banks must be set up... */ 1557 sc->rbank[1] = *rsb; 1558 sc->rbank[2] = *rsb; 1559 sc->rbank[3] = *rsb; 1560 1561 YWRITE4(sc, YDS_ADC_IN_VOLUME, 0x3fff3fff); 1562 YWRITE4(sc, YDS_REC_IN_VOLUME, 0x3fff3fff); 1563 srate = 48000 * 4096 / param->sample_rate - 1; 1564 format = ((param->precision == 8 ? YDS_FORMAT_8BIT : 0) | 1565 (param->channels == 2 ? YDS_FORMAT_STEREO : 0)); 1566 DPRINTF(("srate=%d, format=%08x\n", srate, format)); 1567 #ifdef YDS_USE_REC_SLOT 1568 YWRITE4(sc, YDS_DAC_REC_VOLUME, 0x3fff3fff); 1569 YWRITE4(sc, YDS_P44_REC_VOLUME, 0x3fff3fff); 1570 YWRITE4(sc, YDS_MAPOF_REC, YDS_RECSLOT_VALID); 1571 YWRITE4(sc, YDS_REC_SAMPLE_RATE, srate); 1572 YWRITE4(sc, YDS_REC_FORMAT, format); 1573 #else 1574 YWRITE4(sc, YDS_MAPOF_REC, YDS_ADCSLOT_VALID); 1575 YWRITE4(sc, YDS_ADC_SAMPLE_RATE, srate); 1576 YWRITE4(sc, YDS_ADC_FORMAT, format); 1577 #endif 1578 /* Now the rec slot for the next frame is set up!! */ 1579 /* Sync record slot control data */ 1580 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1581 sc->rbankoff, 1582 sizeof(struct rec_slot_ctrl_bank)* 1583 N_REC_SLOT_CTRL* 1584 N_REC_SLOT_CTRL_BANK, 1585 BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD); 1586 /* Sync ring buffer */ 1587 bus_dmamap_sync(sc->sc_dmatag, p->map, 0, blksize, 1588 BUS_DMASYNC_PREREAD); 1589 /* HERE WE GO!! */ 1590 YWRITE4(sc, YDS_MODE, 1591 YREAD4(sc, YDS_MODE) | YDS_MODE_ACTV | YDS_MODE_ACTV2); 1592 1593 return 0; 1594 } 1595 1596 static int 1597 yds_halt(sc) 1598 struct yds_softc *sc; 1599 { 1600 u_int32_t mode; 1601 1602 /* Stop the DSP operation. */ 1603 mode = YREAD4(sc, YDS_MODE); 1604 YWRITE4(sc, YDS_MODE, mode & ~(YDS_MODE_ACTV|YDS_MODE_ACTV2)); 1605 1606 /* Paranoia... mute all */ 1607 YWRITE4(sc, YDS_P44_OUT_VOLUME, 0); 1608 YWRITE4(sc, YDS_DAC_OUT_VOLUME, 0); 1609 YWRITE4(sc, YDS_ADC_IN_VOLUME, 0); 1610 YWRITE4(sc, YDS_REC_IN_VOLUME, 0); 1611 YWRITE4(sc, YDS_DAC_REC_VOLUME, 0); 1612 YWRITE4(sc, YDS_P44_REC_VOLUME, 0); 1613 1614 return 0; 1615 } 1616 1617 int 1618 yds_halt_output(addr) 1619 void *addr; 1620 { 1621 struct yds_softc *sc = addr; 1622 1623 DPRINTF(("yds: yds_halt_output\n")); 1624 if (sc->sc_play.intr) { 1625 sc->sc_play.intr = 0; 1626 /* Sync play slot control data */ 1627 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1628 sc->pbankoff, 1629 sizeof(struct play_slot_ctrl_bank)* 1630 (*sc->ptbl)*N_PLAY_SLOT_CTRL_BANK, 1631 BUS_DMASYNC_POSTWRITE|BUS_DMASYNC_POSTREAD); 1632 /* Stop the play slot operation */ 1633 sc->pbankp[0]->status = 1634 sc->pbankp[1]->status = 1635 sc->pbankp[2]->status = 1636 sc->pbankp[3]->status = 1; 1637 /* Sync ring buffer */ 1638 bus_dmamap_sync(sc->sc_dmatag, sc->sc_play.dma->map, 1639 0, sc->sc_play.length, BUS_DMASYNC_POSTWRITE); 1640 } 1641 1642 return 0; 1643 } 1644 1645 int 1646 yds_halt_input(addr) 1647 void *addr; 1648 { 1649 struct yds_softc *sc = addr; 1650 1651 DPRINTF(("yds: yds_halt_input\n")); 1652 sc->sc_rec.intr = NULL; 1653 if (sc->sc_rec.intr) { 1654 /* Stop the rec slot operation */ 1655 YWRITE4(sc, YDS_MAPOF_REC, 0); 1656 sc->sc_rec.intr = 0; 1657 /* Sync rec slot control data */ 1658 bus_dmamap_sync(sc->sc_dmatag, sc->sc_ctrldata.map, 1659 sc->rbankoff, 1660 sizeof(struct rec_slot_ctrl_bank)* 1661 N_REC_SLOT_CTRL*N_REC_SLOT_CTRL_BANK, 1662 BUS_DMASYNC_POSTWRITE|BUS_DMASYNC_POSTREAD); 1663 /* Sync ring buffer */ 1664 bus_dmamap_sync(sc->sc_dmatag, sc->sc_rec.dma->map, 1665 0, sc->sc_rec.length, BUS_DMASYNC_POSTREAD); 1666 } 1667 1668 return 0; 1669 } 1670 1671 int 1672 yds_getdev(addr, retp) 1673 void *addr; 1674 struct audio_device *retp; 1675 { 1676 *retp = yds_device; 1677 1678 return 0; 1679 } 1680 1681 int 1682 yds_mixer_set_port(addr, cp) 1683 void *addr; 1684 mixer_ctrl_t *cp; 1685 { 1686 struct yds_softc *sc = addr; 1687 1688 return (sc->sc_codec[0].codec_if->vtbl->mixer_set_port( 1689 sc->sc_codec[0].codec_if, cp)); 1690 } 1691 1692 int 1693 yds_mixer_get_port(addr, cp) 1694 void *addr; 1695 mixer_ctrl_t *cp; 1696 { 1697 struct yds_softc *sc = addr; 1698 1699 return (sc->sc_codec[0].codec_if->vtbl->mixer_get_port( 1700 sc->sc_codec[0].codec_if, cp)); 1701 } 1702 1703 int 1704 yds_query_devinfo(addr, dip) 1705 void *addr; 1706 mixer_devinfo_t *dip; 1707 { 1708 struct yds_softc *sc = addr; 1709 1710 return (sc->sc_codec[0].codec_if->vtbl->query_devinfo( 1711 sc->sc_codec[0].codec_if, dip)); 1712 } 1713 1714 int 1715 yds_get_portnum_by_name(sc, class, device, qualifier) 1716 struct yds_softc *sc; 1717 char *class, *device, *qualifier; 1718 { 1719 return (sc->sc_codec[0].codec_if->vtbl->get_portnum_by_name( 1720 sc->sc_codec[0].codec_if, class, device, qualifier)); 1721 } 1722 1723 void * 1724 yds_malloc(addr, direction, size, pool, flags) 1725 void *addr; 1726 int direction; 1727 size_t size; 1728 int pool, flags; 1729 { 1730 struct yds_softc *sc = addr; 1731 struct yds_dma *p; 1732 int error; 1733 1734 p = malloc(sizeof(*p), pool, flags); 1735 if (!p) 1736 return (0); 1737 error = yds_allocmem(sc, size, 16, p); 1738 if (error) { 1739 free(p, pool); 1740 return (0); 1741 } 1742 p->next = sc->sc_dmas; 1743 sc->sc_dmas = p; 1744 return (KERNADDR(p)); 1745 } 1746 1747 void 1748 yds_free(addr, ptr, pool) 1749 void *addr; 1750 void *ptr; 1751 int pool; 1752 { 1753 struct yds_softc *sc = addr; 1754 struct yds_dma **pp, *p; 1755 1756 for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &p->next) { 1757 if (KERNADDR(p) == ptr) { 1758 yds_freemem(sc, p); 1759 *pp = p->next; 1760 free(p, pool); 1761 return; 1762 } 1763 } 1764 } 1765 1766 static struct yds_dma * 1767 yds_find_dma(sc, addr) 1768 struct yds_softc *sc; 1769 void *addr; 1770 { 1771 struct yds_dma *p; 1772 1773 for (p = sc->sc_dmas; p && KERNADDR(p) != addr; p = p->next) 1774 ; 1775 1776 return p; 1777 } 1778 1779 size_t 1780 yds_round_buffersize(addr, direction, size) 1781 void *addr; 1782 int direction; 1783 size_t size; 1784 { 1785 /* 1786 * Buffer size should be at least twice as bigger as a frame. 1787 */ 1788 if (size < 1024 * 3) 1789 size = 1024 * 3; 1790 return (size); 1791 } 1792 1793 paddr_t 1794 yds_mappage(addr, mem, off, prot) 1795 void *addr; 1796 void *mem; 1797 off_t off; 1798 int prot; 1799 { 1800 struct yds_softc *sc = addr; 1801 struct yds_dma *p; 1802 1803 if (off < 0) 1804 return (-1); 1805 p = yds_find_dma(sc, mem); 1806 if (!p) 1807 return (-1); 1808 return (bus_dmamem_mmap(sc->sc_dmatag, p->segs, p->nsegs, 1809 off, prot, BUS_DMA_WAITOK)); 1810 } 1811 1812 int 1813 yds_get_props(addr) 1814 void *addr; 1815 { 1816 return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | 1817 AUDIO_PROP_FULLDUPLEX); 1818 } 1819
Indexes created Fri Sep 26 08:10:20 GMT 2025