Lines Matching +full:pcm +full:- +full:clock +full:- +full:mode
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
5 * Copyright (c) 2003-2007 Yuriy Tsibizov <yuriy.tsibizov@gfk.ru>
46 #include <machine/clock.h> /* for DELAY */
52 #include <dev/sound/pcm/sound.h>
53 #include <dev/sound/pcm/ac97.h>
96 #define GPR(i) (sc->gpr_base+(i))
97 #define INP(i) (sc->input_base+(i))
98 #define OUTP(i) (sc->output_base+(i))
100 #define FX2(i) (sc->efxc_base+(i))
101 #define DSP_CONST(i) (sc->dsp_zero+(i))
160 /* Live! 5.1 Digital, non-standard 5.1 (center & sub) outputs */
314 device_t pcm[RT_COUNT];
337 unsigned int mode; /* analog / digital */
392 static void emumix_set_mode(struct emu_sc_info *sc, int mode);
393 static void emumix_set_spdif_mode(struct emu_sc_info *sc, int mode);
430 if (mtx_owned(&sc->rw)) { \
432 __LINE__ , device_get_nameunit(sc->dev)); \
433 printf("rw lock owned: %d\n", mtx_owned(&sc->rw)); \
435 ((&sc->rw)->mtx_lock & ~MTX_FLAGMASK), \
437 printf("rw lock: recursed %d\n", mtx_recursed(&sc->rw));\
438 db_show_mtx(&sc->rw); \
448 mtx_lock(&(sc->rw)); \
452 mtx_unlock(&(sc->rw)); \
502 /* 0x0051..0x0051 5.1 CA0100-IAF cards */
504 /* ES is CA0100-IDF chip that don't work in digital mode */
506 /* 0x0053..0x005C 5.1 CA0101-NAF cards */
510 /* 0x1002..0x1009 5.1 CA0102-IAT cards */
515 /* 0x2001..0x2003 7.1 CA0102-ICT cards */
523 /* (range unknown) 7.1 CA0102-xxx Audigy 4 cards */
529 /* We don't support CA0103-DAT (Audigy LS) cards */
530 /* There is NO CA0104-xxx cards */
531 /* There is NO CA0105-xxx cards */
532 /* We don't support CA0106-DAT (SB Live! 24 bit) cards */
533 /* There is NO CA0107-xxx cards */
535 /* 0x1000..0x1001 7.1 CA0108-IAT cards */
548 {0x1102, 0x0002, 0x1102, 0x4001, "EMUAPS", "E-mu APS", 0},
549 {0x1102, 0x0002, 0x1102, 0x4002, "EMUAPS", "E-mu APS", 0},
550 {0x1102, 0x0004, 0x1102, 0x4001, "EMU???", "E-mu 1212m [4001]", 0},
551 /* Similar-named ("Live!" or "Audigy") cards on different chipsets */
614 return (bus_space_read_1(sc->st, sc->sh, regno));
616 return (bus_space_read_2(sc->st, sc->sh, regno));
618 return (bus_space_read_4(sc->st, sc->sh, regno));
630 bus_space_write_1(sc->st, sc->sh, regno, data);
633 bus_space_write_2(sc->st, sc->sh, regno, data);
636 bus_space_write_4(sc->st, sc->sh, regno, data);
642 * via (channel, register) pair. Some registers are channel-specific,
650 ptr = ((reg << 16) & sc->address_mask) | (chn & EMU_PTR_CHNO_MASK);
665 mask = ((1 << size) - 1) << offset;
677 ptr = ((reg << 16) & sc->address_mask) | (chn & EMU_PTR_CHNO_MASK);
683 * give you side effect - it will read previous data from register
689 mask = ((1 << size) - 1) << offset;
699 * via (channel, register) pair. Some registers are channel-specific,
747 * Assume that it is never used to access EMU_PTR-based registers and can run unlocked.
779 if (sc->is_emu10k2 || sc->is_ca0102) {
788 device_printf(sc->dev, "Audigy IR MIDI events enabled.\n");
789 sc->enable_ir = 1;
791 if (sc->is_emu10k1) {
798 device_printf(sc->dev, "SB Live! IR MIDI events enabled.\n");
799 sc->enable_ir = 1;
804 * emu_timer_ - HW timer management
811 timer = -1;
813 mtx_lock(&sc->lock);
815 if (sc->timer[i] == 0) {
816 sc->timer[i] = -1; /* disable it */
818 mtx_unlock(&sc->lock);
821 mtx_unlock(&sc->lock);
823 return (-1);
832 return (-1);
835 RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
837 mtx_lock(&sc->lock);
838 sc->timer[timer] = delay;
840 if (sc->timerinterval > sc->timer[i])
841 sc->timerinterval = sc->timer[i];
844 emu_wr(sc, EMU_TIMER, sc->timerinterval & 0x03ff, 2);
845 mtx_unlock(&sc->lock);
858 return (-1);
860 RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
862 mtx_lock(&sc->lock);
864 if ((go == 1) && (sc->timer[timer] < 0))
865 sc->timer[timer] = -sc->timer[timer];
866 if ((go == 0) && (sc->timer[timer] > 0))
867 sc->timer[timer] = -sc->timer[timer];
871 if (sc->timerinterval > sc->timer[i])
872 sc->timerinterval = sc->timer[i];
873 if (sc->timer[i] > 0)
877 emu_wr(sc, EMU_TIMER, sc->timerinterval & 0x03ff, 2);
888 mtx_unlock(&sc->lock);
896 return (-1);
898 RANGE(timer, 0, EMU_MAX_IRQ_CONSUMERS-1);
902 mtx_lock(&sc->lock);
903 if (sc->timer[timer] != 0)
904 sc->timer[timer] = 0;
905 mtx_unlock(&sc->lock);
911 * emu_intr_ - HW interrupt handler management
919 mtx_lock(&sc->lock);
921 if (sc->ihandler[i].inte_mask == 0) {
922 sc->ihandler[i].inte_mask = inte_mask;
923 sc->ihandler[i].intr_mask = intr_mask;
924 sc->ihandler[i].softc = isc;
925 sc->ihandler[i].irq_func = func;
929 mtx_unlock(&sc->lock);
930 if (sc->dbg_level > 1)
931 device_printf(sc->dev, "ihandle %d registered\n", i);
935 mtx_unlock(&sc->lock);
936 if (sc->dbg_level > 1)
937 device_printf(sc->dev, "ihandle not registered\n");
939 return (-1);
948 mtx_lock(&sc->lock);
950 if (sc->ihandler[hnumber].inte_mask == 0) {
951 mtx_unlock(&sc->lock);
952 return (-1);
956 x &= ~sc->ihandler[hnumber].inte_mask;
958 sc->ihandler[hnumber].inte_mask = 0;
959 sc->ihandler[hnumber].intr_mask = 0;
960 sc->ihandler[hnumber].softc = NULL;
961 sc->ihandler[hnumber].irq_func = NULL;
965 if (sc->ihandler[i].inte_mask != 0)
966 x |= sc->ihandler[i].inte_mask;
970 mtx_unlock(&sc->lock);
988 if ((((sc->ihandler[i].intr_mask) & stat) != 0) &&
989 (((void *)sc->ihandler[i].irq_func) != NULL)) {
990 ack |= sc->ihandler[i].irq_func(sc->ihandler[i].softc,
991 (sc->ihandler[i].intr_mask) & stat);
994 if (sc->dbg_level > 1)
996 device_printf(sc->dev, "Unhandled interrupt: %08x\n", stat & (~ack));
999 if ((sc->is_ca0102) || (sc->is_ca0108))
1006 if (sc->dbg_level > 1)
1007 device_printf(sc->dev, "EMU_IPR2: %08x\n", stat);
1013 if (sc->is_ca0102)
1020 if (sc->dbg_level > 1)
1021 device_printf(sc->dev, "EMU_IPR3: %08x\n", stat);
1029 * Get data from private emu10kx structure for PCM buffer allocation.
1030 * Used by PCM code only.
1035 return (sc->mem.dmat);
1043 *phys = error ? 0 : (bus_addr_t) segs->ds_addr;
1047 (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
1060 if ((error = bus_dmamem_alloc(mem->dmat, &dmabuf, BUS_DMA_NOWAIT, map))) {
1061 if (mem->card->dbg_level > 2)
1062 device_printf(mem->card->dev, "emu_malloc: failed to alloc DMA map: %d\n", error);
1065 if ((error = bus_dmamap_load(mem->dmat, *map, dmabuf, sz, emu_setmap, addr, 0)) || !*addr) {
1066 if (mem->card->dbg_level > 2)
1067 device_printf(mem->card->dev, "emu_malloc: failed to load DMA memory: %d\n", error);
1068 bus_dmamem_free(mem->dmat, dmabuf, *map);
1077 bus_dmamap_unload(mem->dmat, map);
1078 bus_dmamem_free(mem->dmat, dmabuf, map);
1092 if (mem->card->dbg_level > 2)
1093 device_printf(mem->card->dev, "emu_memalloc: memory request tool large\n");
1102 if (mem->bmap[idx >> 3] & (1 << (idx & 7)))
1108 if (mem->card->dbg_level > 2)
1109 device_printf(mem->card->dev, "emu_memalloc: no free space in bitmap\n");
1114 if (mem->card->dbg_level > 2)
1115 device_printf(mem->card->dev, "emu_memalloc: buffer allocation failed\n");
1119 membuf = emu_malloc(mem, sz, &blk->buf_addr, &blk->buf_map);
1120 *addr = blk->buf_addr;
1122 if (mem->card->dbg_level > 2)
1123 device_printf(mem->card->dev, "emu_memalloc: can't setup HW memory\n");
1127 blk->buf = membuf;
1128 blk->pte_start = start;
1129 blk->pte_size = blksz;
1130 strncpy(blk->owner, owner, 15);
1131 blk->owner[15] = '\0';
1134 mem->bmap[idx >> 3] |= 1 << (idx & 7);
1135 tmp = (uint32_t) (blk->buf_addr + ofs);
1136 mem->ptb_pages[idx] = (tmp << 1) | idx;
1139 SLIST_INSERT_HEAD(&mem->blocks, blk, link);
1150 SLIST_FOREACH(i, &mem->blocks, link) {
1151 if (i->buf == membuf)
1156 SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
1157 emu_free(mem, membuf, blk->buf_map);
1158 tmp = (uint32_t) (mem->silent_page_addr) << 1;
1159 for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
1160 mem->bmap[idx >> 3] &= ~(1 << (idx & 7));
1161 mem->ptb_pages[idx] = tmp | idx;
1173 SLIST_FOREACH(i, &mem->blocks, link) {
1174 if (i->buf == membuf)
1178 return (-1);
1179 return (blk->pte_start);
1226 for (i = 31; i > 0; i--) {
1228 return (((uint32_t) (i - 15) << 20) +
1253 mtx_lock(&sc->lock);
1254 for (i = 0; i < NUM_G && sc->voice[i].busy; i++);
1256 v = &sc->voice[i];
1257 v->busy = 1;
1259 mtx_unlock(&sc->lock);
1267 mtx_lock(&sc->lock);
1269 if (v == &sc->voice[i] && sc->voice[i].busy) {
1270 v->busy = 0;
1273 * See -pcm.c emupchan_init for other side of
1276 if (v->slave != NULL)
1277 emu_memfree(&sc->mem, v->vbuf);
1280 mtx_unlock(&sc->lock);
1290 vbuf = emu_memalloc(&sc->mem, sz, &tmp_addr, "vinit");
1292 if(sc->dbg_level > 2)
1293 device_printf(sc->dev, "emu_memalloc returns NULL in enu_vinit\n");
1298 m->start = emu_memstart(&sc->mem, vbuf) * EMUPAGESIZE;
1299 if (m->start < 0) {
1300 if(sc->dbg_level > 2)
1301 device_printf(sc->dev, "emu_memstart returns (-1) in enu_vinit\n");
1302 emu_memfree(&sc->mem, vbuf);
1305 m->end = m->start + sz;
1306 m->speed = 0;
1307 m->b16 = 0;
1308 m->stereo = 0;
1309 m->running = 0;
1310 m->ismaster = 1;
1311 m->vol = 0xff;
1312 m->buf = tmp_addr;
1313 m->vbuf = vbuf;
1314 m->slave = s;
1316 s->start = m->start;
1317 s->end = m->end;
1318 s->speed = 0;
1319 s->b16 = 0;
1320 s->stereo = 0;
1321 s->running = 0;
1322 s->ismaster = 0;
1323 s->vol = m->vol;
1324 s->buf = m->buf;
1325 s->vbuf = NULL;
1326 s->slave = NULL;
1335 v->b16 = (fmt & AFMT_16BIT) ? 1 : 0;
1336 v->stereo = (AFMT_CHANNEL(fmt) > 1) ? 1 : 0;
1337 if (v->slave != NULL) {
1338 v->slave->b16 = v->b16;
1339 v->slave->stereo = v->stereo;
1343 v->speed = spd;
1344 if (v->slave != NULL)
1345 v->slave->speed = v->speed;
1355 v->routing[i] = rt->routing_left[i];
1356 v->amounts[i] = rt->amounts_left[i];
1358 if ((v->stereo) && (v->ismaster == 0))
1360 v->routing[i] = rt->routing_right[i];
1361 v->amounts[i] = rt->amounts_right[i];
1364 if ((v->stereo) && (v->slave != NULL))
1365 emu_vroute(sc, rt, v->slave);
1374 s = (v->stereo ? 1 : 0) + (v->b16 ? 1 : 0);
1376 v->sa = v->start >> s;
1377 v->ea = v->end >> s;
1379 if (v->stereo) {
1380 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF, EMU_CHAN_CPF_STEREO_MASK);
1382 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF, 0);
1384 val = v->stereo ? 28 : 30;
1385 val *= v->b16 ? 1 : 2;
1386 start = v->sa + val;
1388 if (sc->is_emu10k1) {
1389 emu_wrptr(sc, v->vnum, EMU_CHAN_FXRT, ((v->routing[3] << 12) |
1390 (v->routing[2] << 8) |
1391 (v->routing[1] << 4) |
1392 (v->routing[0] << 0)) << 16);
1394 emu_wrptr(sc, v->vnum, EMU_A_CHAN_FXRT1, (v->routing[3] << 24) |
1395 (v->routing[2] << 16) |
1396 (v->routing[1] << 8) |
1397 (v->routing[0] << 0));
1398 emu_wrptr(sc, v->vnum, EMU_A_CHAN_FXRT2, (v->routing[7] << 24) |
1399 (v->routing[6] << 16) |
1400 (v->routing[5] << 8) |
1401 (v->routing[4] << 0));
1402 emu_wrptr(sc, v->vnum, EMU_A_CHAN_SENDAMOUNTS, (v->amounts[7] << 24) |
1403 (v->amounts[6] << 26) |
1404 (v->amounts[5] << 8) |
1405 (v->amounts[4] << 0));
1407 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX, (v->amounts[0] << 8) | (v->amounts[1] << 0));
1408 emu_wrptr(sc, v->vnum, EMU_CHAN_DSL, v->ea | (v->amounts[3] << 24));
1409 emu_wrptr(sc, v->vnum, EMU_CHAN_PSST, v->sa | (v->amounts[2] << 24));
1411 emu_wrptr(sc, v->vnum, EMU_CHAN_CCCA, start | (v->b16 ? 0 : EMU_CHAN_CCCA_8BITSELECT));
1412 emu_wrptr(sc, v->vnum, EMU_CHAN_Z1, 0);
1413 emu_wrptr(sc, v->vnum, EMU_CHAN_Z2, 0);
1415 silent_page = ((uint32_t) (sc->mem.silent_page_addr) << 1) | EMU_CHAN_MAP_PTI_MASK;
1416 emu_wrptr(sc, v->vnum, EMU_CHAN_MAPA, silent_page);
1417 emu_wrptr(sc, v->vnum, EMU_CHAN_MAPB, silent_page);
1419 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, EMU_CHAN_CVCF_CURRFILTER_MASK);
1420 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, EMU_CHAN_VTFT_FILTERTARGET_MASK);
1421 emu_wrptr(sc, v->vnum, EMU_CHAN_ATKHLDM, 0);
1422 emu_wrptr(sc, v->vnum, EMU_CHAN_DCYSUSM, EMU_CHAN_DCYSUSM_DECAYTIME_MASK);
1423 emu_wrptr(sc, v->vnum, EMU_CHAN_LFOVAL1, 0x8000);
1424 emu_wrptr(sc, v->vnum, EMU_CHAN_LFOVAL2, 0x8000);
1425 emu_wrptr(sc, v->vnum, EMU_CHAN_FMMOD, 0);
1426 emu_wrptr(sc, v->vnum, EMU_CHAN_TREMFRQ, 0);
1427 emu_wrptr(sc, v->vnum, EMU_CHAN_FM2FRQ2, 0);
1428 emu_wrptr(sc, v->vnum, EMU_CHAN_ENVVAL, 0x8000);
1430 emu_wrptr(sc, v->vnum, EMU_CHAN_ATKHLDV, EMU_CHAN_ATKHLDV_HOLDTIME_MASK | EMU_CHAN_ATKHLDV_ATTACKTIME_MASK);
1431 emu_wrptr(sc, v->vnum, EMU_CHAN_ENVVOL, 0x8000);
1433 emu_wrptr(sc, v->vnum, EMU_CHAN_PEFE_FILTERAMOUNT, 0x7f);
1434 emu_wrptr(sc, v->vnum, EMU_CHAN_PEFE_PITCHAMOUNT, 0);
1435 if ((v->stereo) && (v->slave != NULL))
1436 emu_vwrite(sc, v->slave);
1460 cs = v->stereo ? 4 : 2;
1461 ccis = v->stereo ? 28 : 30;
1462 ccis *= v->b16 ? 1 : 2;
1463 sample = v->b16 ? 0x00000000 : 0x80808080;
1465 emu_wrptr(sc, v->vnum, EMU_CHAN_CD0 + i, sample);
1466 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_CACHEINVALIDSIZE, 0);
1467 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_READADDRESS, cra);
1468 emu_wrptr(sc, v->vnum, EMU_CHAN_CCR_CACHEINVALIDSIZE, ccis);
1470 emu_wrptr(sc, v->vnum, EMU_CHAN_IFATN, 0xff00);
1471 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, 0xffffffff);
1472 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, 0xffffffff);
1473 emu_wrptr(sc, v->vnum, EMU_CHAN_DCYSUSV, 0x00007f7f);
1474 emu_vstop(sc, v->vnum, 0);
1476 pitch_target = emu_rate_to_linearpitch(v->speed);
1477 initial_pitch = emu_rate_to_pitch(v->speed) >> 8;
1478 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX_PITCHTARGET, pitch_target);
1479 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF_PITCH, pitch_target);
1480 emu_wrptr(sc, v->vnum, EMU_CHAN_IP, initial_pitch);
1482 emu_wrptr(sc, v->vnum, EMU_CHAN_PTRX_PITCHTARGET, 0);
1483 emu_wrptr(sc, v->vnum, EMU_CHAN_CPF_PITCH, 0);
1484 emu_wrptr(sc, v->vnum, EMU_CHAN_IFATN, 0xffff);
1485 emu_wrptr(sc, v->vnum, EMU_CHAN_VTFT, 0x0000ffff);
1486 emu_wrptr(sc, v->vnum, EMU_CHAN_CVCF, 0x0000ffff);
1487 emu_wrptr(sc, v->vnum, EMU_CHAN_IP, 0);
1488 emu_vstop(sc, v->vnum, 1);
1490 if ((v->stereo) && (v->slave != NULL))
1491 emu_vtrigger(sc, v->slave, go);
1499 s = (v->b16 ? 1 : 0) + (v->stereo ? 1 : 0);
1500 ptr = (emu_rdptr(sc, v->vnum, EMU_CHAN_CCCA_CURRADDR) - (v->start >> s)) << s;
1508 emu_wrptr(sc, 0, sc->code_base + pc, data);
1514 if ((*pc) + 1 > sc->code_size) {
1515 device_printf(sc->dev, "DSP CODE OVERRUN: attept to write past code_size (pc=%d)\n", (*pc));
1518 emu_wrefx(sc, (*pc) * 2, (x << sc->high_operand_shift) | y);
1519 emu_wrefx(sc, (*pc) * 2 + 1, (op << sc->opcode_shift) | (z << sc->high_operand_shift) | w);
1537 if (err || req->newptr == NULL)
1552 volgpr = emu_rm_gpr_alloc(sc->rm, 1);
1556 * by AC97 emulation code or PCM mixer.
1561 * see freebsd-current mailing list, emu10kx driver
1562 * discussion around 2006-05-24.
1565 SYSCTL_ADD_PROC(sc->ctx,
1566 SYSCTL_CHILDREN(sc->root), OID_AUTO, sysctl_name,
1583 new_val = (sc->mode == MODE_DIGITAL) ? 1 : 0;
1586 if (err || req->newptr == NULL)
1606 SYSCTL_ADD_PROC(sc->ctx, SYSCTL_CHILDREN(sc->root), OID_AUTO,
1619 sc->cache_gpr[CACHE_IDX] = emu_rm_gpr_alloc(sc->rm, 1); \
1621 GPR(sc->cache_gpr[CACHE_IDX]), \
1630 sc->mixer_gpr[IN_GPR_IDX] = emu_addefxmixer(sc, TITLE, IN_GPR_IDX, DEF); \
1631 sc->mixer_volcache[IN_GPR_IDX] = DEF; \
1633 GPR(sc->cache_gpr[OUT_CACHE_IDX]), \
1634 GPR(sc->cache_gpr[OUT_CACHE_IDX]), \
1636 GPR(sc->mixer_gpr[IN_GPR_IDX]), \
1642 sc->mixer_gpr[OUT_GPR_IDX] = emu_addefxmixer(sc, TITLE, OUT_GPR_IDX, DEF); \
1643 sc->mixer_volcache[OUT_GPR_IDX] = DEF; \
1647 GPR(sc->cache_gpr[OUT_CACHE_IDX]), \
1648 GPR(sc->mixer_gpr[OUT_GPR_IDX]), \
1657 GPR(sc->cache_gpr[OUT_CACHE_IDX]), \
1658 GPR(sc->mixer_gpr[OUT_GPR_IDX]), \
1666 GPR(sc->mute_gpr[FLAG_GPR]), \
1694 if (sc->is_emu10k1) {
1702 for (i = 0; i < sc->code_size; i++) {
1703 if (sc->is_emu10k1) {
1712 sc->mute_gpr[i] = emu_rm_gpr_alloc(sc->rm, 1);
1713 emumix_set_gpr(sc, sc->mute_gpr[i], 1);
1732 if (sc->is_emu10k1) {
1758 if (sc->dbg_level > 0) {
1777 /* in5, on-card S/PDIF */
1789 if (sc->dbg_level > 0) {
1811 if (!(sc->mch_disabled)) {
1814 * emu_dspmixer_set() in -pcm.c
1825 if (sc->has_51) {
1831 /* XXX in digital mode (default) this should be muted because
1841 /* XXX in digital mode (default) this should be muted because
1854 if (sc->has_51) {
1858 GPR(sc->cache_gpr[C_CENTER]),
1859 GPR(sc->cache_gpr[C_CENTER]),
1861 GPR(sc->cache_gpr[C_FRONT_L]),
1864 GPR(sc->cache_gpr[C_CENTER]),
1865 GPR(sc->cache_gpr[C_CENTER]),
1867 GPR(sc->cache_gpr[C_FRONT_R]),
1871 /* XXX in digital mode (default) this should be muted because
1879 GPR(sc->cache_gpr[C_CENTER]),
1880 GPR(sc->cache_gpr[C_CENTER]),
1882 GPR(sc->cache_gpr[C_FRONT_L]),
1885 GPR(sc->cache_gpr[C_CENTER]),
1886 GPR(sc->cache_gpr[C_CENTER]),
1888 GPR(sc->cache_gpr[C_FRONT_R]),
1894 /* XXX in digital mode (default) this should be muted because
1901 if (sc->mch_rec) {
1915 * 0x00..0x1E - outputs
1916 * 0x20..0x3E - FX, inputs and sync stream
1920 for(i = (sc->has_51 ? 2 : 0); i < 2; i++)
1923 /* PCM Playback monitoring, offset 0x24..0x2A */
1932 sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
1933 emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
1935 EFX_COPY(FX2(15), GPR(sc->dummy_gpr));
1946 * emu_ac97_[read|write]_emulation in -pcm.c
1972 if (sc->dbg_level > 0) {
1986 /* in5, on-card S/PDIF */
1998 if (sc->dbg_level > 0) {
2020 if (!(sc->mch_disabled)) {
2023 * emu_dspmixer_set() in -pcm.c
2043 * XXX in digital mode (default) this should be muted
2054 * XXX in digital mode (default) this should be muted
2059 if (sc->has_71) {
2078 if (sc->has_51) {
2082 GPR(sc->cache_gpr[C_CENTER]),
2083 GPR(sc->cache_gpr[C_CENTER]),
2085 GPR(sc->cache_gpr[C_FRONT_L]),
2088 GPR(sc->cache_gpr[C_CENTER]),
2089 GPR(sc->cache_gpr[C_CENTER]),
2091 GPR(sc->cache_gpr[C_FRONT_R]),
2095 /* XXX in digital mode (default) this should be muted because
2103 GPR(sc->cache_gpr[C_SUB]),
2104 GPR(sc->cache_gpr[C_SUB]),
2106 GPR(sc->cache_gpr[C_FRONT_L]),
2109 GPR(sc->cache_gpr[C_SUB]),
2110 GPR(sc->cache_gpr[C_SUB]),
2112 GPR(sc->cache_gpr[C_FRONT_R]),
2118 /* XXX in digital mode (default) this should be muted because
2124 if (sc->mch_rec) {
2129 * 0x00..0x3E - outputs
2130 * 0x40..0x7E - FX, inputs
2140 /* PCM Playback monitoring, offsets 0x40..0x5E */
2150 sc->dummy_gpr = emu_rm_gpr_alloc(sc->rm, 1);
2151 emumix_set_gpr(sc, sc->dummy_gpr, 0xc0de0000);
2152 EFX_COPY(FX2(31), GPR(sc->dummy_gpr));
2157 sc->routing_code_end = pc;
2160 if (sc->is_emu10k1) {
2181 emu10kx_open(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2186 sc = i_dev->si_drv1;
2187 mtx_lock(&sc->emu10kx_lock);
2188 if (sc->emu10kx_isopen) {
2189 mtx_unlock(&sc->emu10kx_lock);
2192 sc->emu10kx_isopen = 1;
2193 mtx_unlock(&sc->emu10kx_lock);
2194 if (sbuf_new(&sc->emu10kx_sbuf, NULL, 4096, 0) == NULL) {
2198 sc->emu10kx_bufptr = 0;
2199 error = (emu10kx_prepare(sc, &sc->emu10kx_sbuf) > 0) ? 0 : ENOMEM;
2202 mtx_lock(&sc->emu10kx_lock);
2203 sc->emu10kx_isopen = 0;
2204 mtx_unlock(&sc->emu10kx_lock);
2210 emu10kx_close(struct cdev *i_dev, int flags __unused, int mode __unused, struct thread *td __unused)
2214 sc = i_dev->si_drv1;
2216 mtx_lock(&sc->emu10kx_lock);
2217 if (!(sc->emu10kx_isopen)) {
2218 mtx_unlock(&sc->emu10kx_lock);
2221 sbuf_delete(&sc->emu10kx_sbuf);
2222 sc->emu10kx_isopen = 0;
2223 mtx_unlock(&sc->emu10kx_lock);
2234 sc = i_dev->si_drv1;
2235 mtx_lock(&sc->emu10kx_lock);
2236 if (!(sc->emu10kx_isopen)) {
2237 mtx_unlock(&sc->emu10kx_lock);
2240 mtx_unlock(&sc->emu10kx_lock);
2242 l = min(buf->uio_resid, sbuf_len(&sc->emu10kx_sbuf) - sc->emu10kx_bufptr);
2243 err = (l > 0) ? uiomove(sbuf_data(&sc->emu10kx_sbuf) + sc->emu10kx_bufptr, l, buf) : 0;
2244 sc->emu10kx_bufptr += l;
2256 sbuf_printf(s, "DSP General Purpose Registers: %d used, %d total\n", sc->rm->num_used, sc->rm->num_gprs);
2257 sbuf_printf(s, "DSP Instruction Registers: %d used, %d total\n", sc->routing_code_end, sc->code_size);
2259 if (sc->has_ac97) {
2264 if (sc->has_51) {
2265 if (sc->has_71)
2270 if (sc->is_emu10k1)
2272 if (sc->is_emu10k2)
2274 if (sc->is_ca0102)
2276 if (sc->is_ca0108)
2279 if (sc->broken_digital)
2280 sbuf_printf(s, "Digital mode unsupported\n");
2283 if (sc->pcm[i] != NULL)
2284 if (device_is_attached(sc->pcm[i])) {
2285 sbuf_printf(s, "%s on %s\n", device_get_desc(sc->pcm[i]), device_get_nameunit(sc->pcm[i]));
2287 if (sc->midi[0] != NULL)
2288 if (device_is_attached(sc->midi[0])) {
2290 sbuf_printf(s, "\tOn-card connector on %s\n", device_get_nameunit(sc->midi[0]));
2292 if (sc->midi[1] != NULL)
2293 if (device_is_attached(sc->midi[1])) {
2294 sbuf_printf(s, "\tOn-Drive connector on %s\n", device_get_nameunit(sc->midi[1]));
2296 if (sc->midi[0] != NULL)
2297 if (device_is_attached(sc->midi[0])) {
2298 sbuf_printf(s, "\tIR receiver MIDI events %s\n", sc->enable_ir ? "enabled" : "disabled");
2300 sbuf_printf(s, "Card is in %s mode\n", (sc->mode == MODE_ANALOG) ? "analog" : "digital");
2312 mtx_init(&sc->emu10kx_lock, device_get_nameunit(sc->dev), "kxdevlock", 0);
2313 unit = device_get_unit(sc->dev);
2315 sc->cdev = make_dev(&emu10kx_cdevsw, unit, UID_ROOT, GID_WHEEL, 0640, "emu10kx%d", unit);
2316 if (sc->cdev != NULL) {
2317 sc->cdev->si_drv1 = sc;
2326 mtx_lock(&sc->emu10kx_lock);
2327 if (sc->emu10kx_isopen) {
2328 mtx_unlock(&sc->emu10kx_lock);
2331 if (sc->cdev)
2332 destroy_dev(sc->cdev);
2333 sc->cdev = NULL;
2335 mtx_destroy(&sc->emu10kx_lock);
2351 sc->rm = rm;
2352 rm->card = sc;
2353 maxcount = sc->num_gprs;
2354 rm->num_used = 0;
2355 mtx_init(&(rm->gpr_lock), device_get_nameunit(sc->dev), "gpr alloc", MTX_DEF);
2356 rm->num_gprs = (maxcount < EMU_MAX_GPR ? maxcount : EMU_MAX_GPR);
2357 for (i = 0; i < rm->num_gprs; i++)
2358 rm->allocmap[i] = 0;
2359 /* pre-allocate gpr[0] */
2360 rm->allocmap[0] = 1;
2361 rm->last_free_gpr = 1;
2371 if (sc->dbg_level > 1) {
2372 mtx_lock(&(sc->rm->gpr_lock));
2373 for (i = 1; i < sc->rm->last_free_gpr; i++)
2374 if (sc->rm->allocmap[i] > 0)
2375 device_printf(sc->dev, "rm: gpr %d not free before uninit\n", i);
2376 mtx_unlock(&(sc->rm->gpr_lock));
2379 mtx_destroy(&(sc->rm->gpr_lock));
2380 free(sc->rm, M_DEVBUF);
2390 allocated_gpr = rm->num_gprs;
2392 mtx_lock(&(rm->gpr_lock));
2393 if (rm->last_free_gpr + count <= rm->num_gprs) {
2394 allocated_gpr = rm->last_free_gpr;
2395 rm->last_free_gpr += count;
2396 rm->allocmap[allocated_gpr] = count;
2398 rm->allocmap[allocated_gpr + i] = -(count - i);
2402 allocated_gpr = rm->num_gprs;
2403 while (i < rm->last_free_gpr - count) {
2404 if (rm->allocmap[i] > 0) {
2405 i += rm->allocmap[i];
2409 if (rm->allocmap[i + j] != 0)
2410 allocated_gpr = rm->num_gprs;
2416 if (allocated_gpr + count < rm->last_free_gpr) {
2417 rm->allocmap[allocated_gpr] = count;
2419 rm->allocmap[allocated_gpr + i] = -(count - i);
2422 if (allocated_gpr == rm->num_gprs)
2423 allocated_gpr = (-1);
2425 rm->num_used += count;
2426 mtx_unlock(&(rm->gpr_lock));
2432 emumix_set_mode(struct emu_sc_info *sc, int mode)
2438 switch (mode) {
2450 if (sc->rev >= 6)
2453 if (sc->is_emu10k1)
2458 if (mode == MODE_DIGITAL) {
2459 if (sc->broken_digital) {
2460 device_printf(sc->dev, "Digital mode is reported as broken on this card.\n");
2466 if (mode == MODE_ANALOG)
2469 if (sc->is_emu10k2)
2472 if ((sc->is_ca0102) || (sc->is_ca0108))
2481 if (sc->is_ca0108)
2484 /* Mute analog center & subwoofer before mode change */
2485 if (mode == MODE_DIGITAL)
2486 emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 1);
2490 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2496 /* Unmute if we have changed mode to analog. */
2498 if (mode == MODE_ANALOG)
2499 emumix_set_gpr(sc, sc->mute_gpr[ANALOGMUTE], 0);
2501 sc->mode = mode;
2505 emumix_set_spdif_mode(struct emu_sc_info *sc, int mode)
2509 switch (mode) {
2513 device_printf(sc->dev, "AC3 mode does not work and disabled\n");
2524 mode = SPDIF_MODE_PCM;
2575 idx = (L2L_POINTS - 1) - log_t / (L2L_POINTS);
2592 if (sc->dbg_level > 1)
2594 device_printf(sc->dev, "Zero gpr write access\n");
2610 sc->mixer_volcache[mixer_idx] = volume;
2611 emumix_set_fxvol(sc, sc->mixer_gpr[mixer_idx], volume);
2619 return (sc->mixer_volcache[mixer_idx]);
2620 return (-1);
2672 if ((sc->is_ca0102) || (sc->is_ca0108))
2675 if (sc->is_ca0102)
2680 if (sc->has_51)
2682 if (sc->has_71)
2684 if (sc->is_emu10k2)
2688 if (sc->is_emu10k2) /* XXX for later cards? */
2692 if (bus_dma_tag_create( /* parent */ bus_get_dma_tag(sc->dev),
2694 /* lowaddr */ (1U << 31) - 1, /* can only access 0-2gb */
2699 &sc->mem.dmat) != 0) {
2700 device_printf(sc->dev, "unable to create dma tag\n");
2701 bus_dma_tag_destroy(sc->mem.dmat);
2705 sc->mem.card = sc;
2706 SLIST_INIT(&sc->mem.blocks);
2707 sc->mem.ptb_pages = emu_malloc(&sc->mem, EMU_MAXPAGES * sizeof(uint32_t), &sc->mem.ptb_pages_addr, &sc->mem.ptb_map);
2708 if (sc->mem.ptb_pages == NULL)
2711 sc->mem.silent_page = emu_malloc(&sc->mem, EMUPAGESIZE, &sc->mem.silent_page_addr, &sc->mem.silent_map);
2712 if (sc->mem.silent_page == NULL) {
2713 emu_free(&sc->mem, sc->mem.ptb_pages, sc->mem.ptb_map);
2717 bzero(sc->mem.silent_page, EMUPAGESIZE);
2718 tmp = (uint32_t) (sc->mem.silent_page_addr) << 1;
2720 sc->mem.ptb_pages[i] = tmp | i;
2726 emu_wrptr(sc, 0, EMU_PTB, (sc->mem.ptb_pages_addr));
2763 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2776 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2785 if ((sc->is_ca0102) || (sc->is_ca0108)) {
2795 if (sc->is_ca0102)
2808 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108))
2810 if (((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) && (sc->broken_digital)) {
2811 device_printf(sc->dev, "Audigy card initialized in analog mode.\n");
2818 device_printf(sc->dev, "Card Configuration ( 0x%08x )\n", tmp);
2819 device_printf(sc->dev, "Card Configuration ( & 0xff000000 ) : %s%s%s%s%s%s%s%s\n",
2828 device_printf(sc->dev, "Card Configuration ( & 0x00ff0000 ) : %s%s%s%s%s%s%s%s\n",
2837 device_printf(sc->dev, "Card Configuration ( & 0x0000ff00 ) : %s%s%s%s%s%s%s%s\n",
2846 device_printf(sc->dev, "Card Configuration ( & 0x000000ff ) : %s%s%s%s%s%s%s%s\n",
2856 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
2858 device_printf(sc->dev, "Audigy Card Configuration ( 0x%04x )\n", tmp);
2859 device_printf(sc->dev, "Audigy Card Configuration ( & 0xff00 )");
2869 device_printf(sc->dev, "Audigy Card Configuration ( & 0x00ff )");
2921 if (!SLIST_EMPTY(&sc->mem.blocks))
2922 device_printf(sc->dev, "warning: memblock list not empty\n");
2924 SLIST_FOREACH(blk, &sc->mem.blocks, link)
2926 device_printf(sc->dev, "lost %d for %s\n", blk->pte_size, blk->owner);
2928 emu_free(&sc->mem, sc->mem.ptb_pages, sc->mem.ptb_map);
2929 emu_free(&sc->mem, sc->mem.silent_page, sc->mem.silent_map);
2947 *result = func->func;
2950 if (func->varinfo == NULL)
2952 *result = ((struct emu_pcminfo *)func->varinfo)->route;
2955 *result = sc->is_emu10k1;
2958 *result = sc->mch_disabled;
2961 *result = sc->mch_rec;
3024 sc->ctx = device_get_sysctl_ctx(dev);
3025 if (sc->ctx == NULL)
3027 sc->root = device_get_sysctl_tree(dev);
3028 if (sc->root == NULL)
3031 if (resource_int_value("emu10kx", unit, "multichannel_disabled", &(sc->mch_disabled)))
3032 RANGE(sc->mch_disabled, 0, 1);
3035 OID_AUTO, "multichannel_disabled", CTLFLAG_RD, &(sc->mch_disabled), 0, "Multichannel playback setting");
3037 if (resource_int_value("emu10kx", unit, "multichannel_recording", &(sc->mch_rec)))
3038 RANGE(sc->mch_rec, 0, 1);
3041 OID_AUTO, "multichannel_recording", CTLFLAG_RD, &(sc->mch_rec), 0, "Multichannel recording setting");
3043 if (resource_int_value("emu10kx", unit, "debug", &(sc->dbg_level)))
3044 RANGE(sc->mch_rec, 0, 2);
3047 OID_AUTO, "debug", CTLFLAG_RW, &(sc->dbg_level), 0, "Debug level");
3050 mtx_init(&sc->lock, device_get_nameunit(dev), "bridge conf", MTX_DEF);
3051 mtx_init(&sc->rw, device_get_nameunit(dev), "exclusive io", MTX_DEF);
3052 sc->dev = dev;
3053 sc->type = pci_get_devid(dev);
3054 sc->rev = pci_get_revid(dev);
3055 sc->enable_ir = 0;
3056 sc->has_ac97 = 0;
3057 sc->has_51 = 0;
3058 sc->has_71 = 0;
3059 sc->broken_digital = 0;
3060 sc->is_emu10k1 = 0;
3061 sc->is_emu10k2 = 0;
3062 sc->is_ca0102 = 0;
3063 sc->is_ca0108 = 0;
3064 sc->is_cardbus = 0;
3068 sc->has_51 = 1;
3070 sc->has_51 = 1;
3071 sc->has_71 = 1;
3074 sc->is_emu10k1 = 1;
3076 sc->is_emu10k2 = 1;
3078 sc->is_ca0102 = 1;
3080 sc->is_ca0108 = 1;
3081 if ((sc->is_emu10k2) && (sc->rev == 4)) {
3082 sc->is_emu10k2 = 0;
3083 sc->is_ca0102 = 1; /* for unknown Audigy 2 cards */
3085 if ((sc->is_ca0102 == 1) || (sc->is_ca0108 == 1))
3087 sc->is_cardbus = 1;
3089 if ((sc->is_emu10k1 + sc->is_emu10k2 + sc->is_ca0102 + sc->is_ca0108) != 1) {
3090 device_printf(sc->dev, "Unable to detect HW chipset\n");
3094 sc->broken_digital = 1;
3096 sc->has_ac97 = 1;
3098 sc->opcode_shift = 0;
3099 if ((sc->is_emu10k2) || (sc->is_ca0102) || (sc->is_ca0108)) {
3100 sc->opcode_shift = 24;
3101 sc->high_operand_shift = 12;
3104 /* sc->fx_base = 0x0 */
3105 sc->input_base = 0x40;
3106 /* sc->p16vinput_base = 0x50; */
3107 sc->output_base = 0x60;
3108 sc->efxc_base = 0x80;
3109 /* sc->output32h_base = 0xa0; */
3110 /* sc->output32l_base = 0xb0; */
3111 sc->dsp_zero = 0xc0;
3113 /* sc->tram_base = 0x200 */
3114 /* sc->tram_addr_base = 0x300 */
3115 sc->gpr_base = EMU_A_FXGPREGBASE;
3116 sc->num_gprs = 0x200;
3117 sc->code_base = EMU_A_MICROCODEBASE;
3118 sc->code_size = 0x800 / 2; /* 0x600-0xdff, 2048 words,
3121 sc->mchannel_fx = 8;
3122 sc->num_fxbuses = 16;
3123 sc->num_inputs = 8;
3124 sc->num_outputs = 16;
3125 sc->address_mask = EMU_A_PTR_ADDR_MASK;
3127 if (sc->is_emu10k1) {
3128 sc->has_51 = 0; /* We don't support 5.1 sound on SB Live! 5.1 */
3129 sc->opcode_shift = 20;
3130 sc->high_operand_shift = 10;
3131 sc->code_base = EMU_MICROCODEBASE;
3132 sc->code_size = 0x400 / 2; /* 0x400-0x7ff, 1024 words,
3134 sc->gpr_base = EMU_FXGPREGBASE;
3135 sc->num_gprs = 0x100;
3136 sc->input_base = 0x10;
3137 sc->output_base = 0x20;
3143 sc->efxc_base = 0x30;
3144 sc->dsp_zero = 0x40;
3145 sc->mchannel_fx = 0;
3146 sc->num_fxbuses = 8;
3147 sc->num_inputs = 8;
3148 sc->num_outputs = 16;
3149 sc->address_mask = EMU_PTR_ADDR_MASK;
3151 if (sc->opcode_shift == 0)
3157 sc->reg = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &i, RF_ACTIVE);
3158 if (sc->reg == NULL) {
3162 sc->st = rman_get_bustag(sc->reg);
3163 sc->sh = rman_get_bushandle(sc->reg);
3166 sc->timer[i] = 0; /* disable it */
3169 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &i, RF_ACTIVE | RF_SHAREABLE);
3170 if ((sc->irq == NULL) || bus_setup_intr(dev, sc->irq, INTR_MPSAFE | INTR_TYPE_AV,
3172 emu_intr, sc, &sc->ih)) {
3180 if (sc->is_cardbus)
3193 snprintf(status, 255, "rev %d at io 0x%jx irq %jd", sc->rev, rman_get_start(sc->reg), rman_get_start(sc->irq));
3197 sc->voice[i].vnum = i;
3198 sc->voice[i].slave = NULL;
3199 sc->voice[i].busy = 0;
3200 sc->voice[i].ismaster = 0;
3201 sc->voice[i].running = 0;
3202 sc->voice[i].b16 = 0;
3203 sc->voice[i].stereo = 0;
3204 sc->voice[i].speed = 0;
3205 sc->voice[i].start = 0;
3206 sc->voice[i].end = 0;
3209 /* PCM Audio */
3211 sc->pcm[i] = NULL;
3216 pcminfo->card = sc;
3217 pcminfo->route = RT_FRONT;
3219 func->func = SCF_PCM;
3220 func->varinfo = pcminfo;
3221 sc->pcm[RT_FRONT] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3222 device_set_ivars(sc->pcm[RT_FRONT], func);
3224 if (!(sc->mch_disabled)) {
3228 pcminfo->card = sc;
3229 pcminfo->route = RT_REAR;
3231 func->func = SCF_PCM;
3232 func->varinfo = pcminfo;
3233 sc->pcm[RT_REAR] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3234 device_set_ivars(sc->pcm[RT_REAR], func);
3235 if (sc->has_51) {
3239 pcminfo->card = sc;
3240 pcminfo->route = RT_CENTER;
3242 func->func = SCF_PCM;
3243 func->varinfo = pcminfo;
3244 sc->pcm[RT_CENTER] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3245 device_set_ivars(sc->pcm[RT_CENTER], func);
3249 pcminfo->card = sc;
3250 pcminfo->route = RT_SUB;
3252 func->func = SCF_PCM;
3253 func->varinfo = pcminfo;
3254 sc->pcm[RT_SUB] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3255 device_set_ivars(sc->pcm[RT_SUB], func);
3257 if (sc->has_71) {
3261 pcminfo->card = sc;
3262 pcminfo->route = RT_SIDE;
3264 func->func = SCF_PCM;
3265 func->varinfo = pcminfo;
3266 sc->pcm[RT_SIDE] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3267 device_set_ivars(sc->pcm[RT_SIDE], func);
3271 if (sc->mch_rec) {
3274 pcminfo->card = sc;
3275 pcminfo->route = RT_MCHRECORD;
3277 func->func = SCF_PCM;
3278 func->varinfo = pcminfo;
3279 sc->pcm[RT_MCHRECORD] = device_add_child(dev, "pcm", DEVICE_UNIT_ANY);
3280 device_set_ivars(sc->pcm[RT_MCHRECORD], func);
3284 sc->midi[i] = NULL;
3289 if ((sc->is_emu10k1) || (sc->is_emu10k2) || (sc->is_ca0102)) {
3292 midiinfo->card = sc;
3293 if (sc->is_emu10k2 || (sc->is_ca0102)) {
3294 midiinfo->port = EMU_A_MUDATA1;
3295 midiinfo->portnr = 1;
3297 if (sc->is_emu10k1) {
3298 midiinfo->port = MUDATA;
3299 midiinfo->portnr = 1;
3301 func->func = SCF_MIDI;
3302 func->varinfo = midiinfo;
3303 sc->midi[0] = device_add_child(dev, "midi", DEVICE_UNIT_ANY);
3304 device_set_ivars(sc->midi[0], func);
3307 if (sc->is_emu10k2 || (sc->is_ca0102)) {
3310 midiinfo->card = sc;
3312 midiinfo->port = EMU_A_MUDATA2;
3313 midiinfo->portnr = 2;
3315 func->func = SCF_MIDI;
3316 func->varinfo = midiinfo;
3317 sc->midi[1] = device_add_child(dev, "midi", DEVICE_UNIT_ANY);
3318 device_set_ivars(sc->midi[1], func);
3326 if (sc->cdev)
3328 if (sc->rm != NULL)
3330 if (sc->reg)
3331 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3332 if (sc->ih)
3333 bus_teardown_intr(dev, sc->irq, sc->ih);
3334 if (sc->irq)
3335 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3336 mtx_destroy(&sc->rw);
3337 mtx_destroy(&sc->lock);
3348 free(func->varinfo, M_DEVBUF);
3373 if (sc->mem.dmat)
3374 bus_dma_tag_destroy(sc->mem.dmat);
3376 if (sc->reg)
3377 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->reg);
3378 bus_teardown_intr(dev, sc->irq, sc->ih);
3379 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
3380 mtx_destroy(&sc->rw);
3381 mtx_destroy(&sc->lock);
3420 /* XXX Should we check state of pcm & midi subdevices here? */