Annotation of sys/dev/isa/gus.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: gus.c,v 1.29 2006/03/04 12:42:23 miod Exp $ */
! 2: /* $NetBSD: gus.c,v 1.51 1998/01/25 23:48:06 mycroft Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1996 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Ken Hornstein and John Kohl.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: /*
! 41: *
! 42: * TODO:
! 43: * . figure out why mixer activity while sound is playing causes problems
! 44: * (phantom interrupts?)
! 45: * . figure out a better deinterleave strategy that avoids sucking up
! 46: * CPU, memory and cache bandwidth. (Maybe a special encoding?
! 47: * Maybe use the double-speed sampling/hardware deinterleave trick
! 48: * from the GUS SDK?) A 486/33 isn't quite fast enough to keep
! 49: * up with 44.1kHz 16-bit stereo output without some drop-outs.
! 50: * . use CS4231 for 16-bit sampling, for a-law and mu-law playback.
! 51: * . actually test full-duplex sampling(recording) and playback.
! 52: */
! 53:
! 54: /*
! 55: * Gravis UltraSound driver
! 56: *
! 57: * For more detailed information, see the GUS developers' kit
! 58: * available on the net at:
! 59: *
! 60: * http://www.gravis.com/Public/sdk/GUSDK222.ZIP
! 61: *
! 62: * See ultrawrd.doc inside--it's MS Word (ick), but it's the bible
! 63: *
! 64: */
! 65:
! 66: /*
! 67: * The GUS Max has a slightly strange set of connections between the CS4231
! 68: * and the GF1 and the DMA interconnects. It's set up so that the CS4231 can
! 69: * be playing while the GF1 is loading patches from the system.
! 70: *
! 71: * Here's a recreation of the DMA interconnect diagram:
! 72: *
! 73: * GF1
! 74: * +---------+ digital
! 75: * | | record ASIC
! 76: * | |--------------+
! 77: * | | | +--------+
! 78: * | | play (dram) | +----+ | |
! 79: * | |--------------(------|-\ | | +-+ |
! 80: * +---------+ | | >-|----|---|C|--|------ dma chan 1
! 81: * | +---|-/ | | +-+ |
! 82: * | | +----+ | | |
! 83: * | | +----+ | | |
! 84: * +---------+ +-+ +--(---|-\ | | | |
! 85: * | | play |8| | | >-|----|----+---|------ dma chan 2
! 86: * | ---C----|--------|/|------(---|-/ | | |
! 87: * | ^ |record |1| | +----+ | |
! 88: * | | | /----|6|------+ +--------+
! 89: * | ---+----|--/ +-+
! 90: * +---------+
! 91: * CS4231 8-to-16 bit bus conversion, if needed
! 92: *
! 93: *
! 94: * "C" is an optional combiner.
! 95: *
! 96: */
! 97:
! 98: #include <sys/param.h>
! 99: #include <sys/systm.h>
! 100: #include <sys/errno.h>
! 101: #include <sys/ioctl.h>
! 102: #include <sys/syslog.h>
! 103: #include <sys/device.h>
! 104: #include <sys/proc.h>
! 105: #include <sys/buf.h>
! 106: #include <sys/fcntl.h>
! 107: #include <sys/malloc.h>
! 108: #include <sys/kernel.h>
! 109: #include <sys/timeout.h>
! 110:
! 111: #include <machine/cpu.h>
! 112: #include <machine/intr.h>
! 113: #include <machine/bus.h>
! 114: #include <machine/cpufunc.h>
! 115: #include <sys/audioio.h>
! 116: #include <dev/audio_if.h>
! 117: #include <dev/mulaw.h>
! 118: #include <dev/auconv.h>
! 119:
! 120: #include <dev/isa/isavar.h>
! 121: #include <dev/isa/isadmavar.h>
! 122:
! 123: #include <dev/ic/ics2101reg.h>
! 124: #include <dev/ic/cs4231reg.h>
! 125: #include <dev/ic/ad1848reg.h>
! 126: #include <dev/isa/ics2101var.h>
! 127: #include <dev/isa/ad1848var.h>
! 128: #include <dev/isa/cs4231var.h>
! 129: #include "gusreg.h"
! 130: #include "gusvar.h"
! 131:
! 132: #ifdef AUDIO_DEBUG
! 133: #define GUSPLAYDEBUG /*XXX*/
! 134: #define DPRINTF(x) if (gusdebug) printf x
! 135: #define DMAPRINTF(x) if (gusdmadebug) printf x
! 136: int gusdebug = 0;
! 137: int gusdmadebug = 0;
! 138: #else
! 139: #define DPRINTF(x)
! 140: #define DMAPRINTF(x)
! 141: #endif
! 142: int gus_dostereo = 1;
! 143:
! 144: #define NDMARECS 2048
! 145: #ifdef GUSPLAYDEBUG
! 146: int gusstats = 0;
! 147:
! 148: struct dma_record dmarecords[NDMARECS];
! 149:
! 150: int dmarecord_index = 0;
! 151: #endif
! 152:
! 153: struct cfdriver gus_cd = {
! 154: NULL, "gus", DV_DULL
! 155: };
! 156:
! 157: /*
! 158: * A mapping from IRQ/DRQ values to the values used in the GUS's internal
! 159: * registers. A zero means that the referenced IRQ/DRQ is invalid
! 160: */
! 161: const int gus_irq_map[] = {
! 162: IRQUNK, IRQUNK, 1, 3, IRQUNK, 2, IRQUNK, 4, IRQUNK, 1, IRQUNK, 5, 6,
! 163: IRQUNK, IRQUNK, 7
! 164: };
! 165: const int gus_drq_map[] = {
! 166: DRQUNK, 1, DRQUNK, 2, DRQUNK, 3, 4, 5
! 167: };
! 168:
! 169: /*
! 170: * A list of valid base addresses for the GUS
! 171: */
! 172:
! 173: const int gus_base_addrs[] = {
! 174: 0x210, 0x220, 0x230, 0x240, 0x250, 0x260
! 175: };
! 176: const int gus_addrs = sizeof(gus_base_addrs) / sizeof(gus_base_addrs[0]);
! 177:
! 178: /*
! 179: * Maximum frequency values of the GUS based on the number of currently active
! 180: * voices. Since the GUS samples a voice every 1.6 us, the maximum frequency
! 181: * is dependent on the number of active voices. Yes, it is pretty weird.
! 182: */
! 183:
! 184: static const int gus_max_frequency[] = {
! 185: 44100, /* 14 voices */
! 186: 41160, /* 15 voices */
! 187: 38587, /* 16 voices */
! 188: 36317, /* 17 voices */
! 189: 34300, /* 18 voices */
! 190: 32494, /* 19 voices */
! 191: 30870, /* 20 voices */
! 192: 29400, /* 21 voices */
! 193: 28063, /* 22 voices */
! 194: 26843, /* 23 voices */
! 195: 25725, /* 24 voices */
! 196: 24696, /* 25 voices */
! 197: 23746, /* 26 voices */
! 198: 22866, /* 27 voices */
! 199: 22050, /* 28 voices */
! 200: 21289, /* 29 voices */
! 201: 20580, /* 30 voices */
! 202: 19916, /* 31 voices */
! 203: 19293 /* 32 voices */
! 204: };
! 205: /*
! 206: * A mapping of linear volume levels to the logarithmic volume values used
! 207: * by the GF1 chip on the GUS. From GUS SDK vol1.c.
! 208: */
! 209:
! 210: static const unsigned short gus_log_volumes[512] = {
! 211: 0x0000,
! 212: 0x0700, 0x07ff, 0x0880, 0x08ff, 0x0940, 0x0980, 0x09c0, 0x09ff, 0x0a20,
! 213: 0x0a40, 0x0a60, 0x0a80, 0x0aa0, 0x0ac0, 0x0ae0, 0x0aff, 0x0b10, 0x0b20,
! 214: 0x0b30, 0x0b40, 0x0b50, 0x0b60, 0x0b70, 0x0b80, 0x0b90, 0x0ba0, 0x0bb0,
! 215: 0x0bc0, 0x0bd0, 0x0be0, 0x0bf0, 0x0bff, 0x0c08, 0x0c10, 0x0c18, 0x0c20,
! 216: 0x0c28, 0x0c30, 0x0c38, 0x0c40, 0x0c48, 0x0c50, 0x0c58, 0x0c60, 0x0c68,
! 217: 0x0c70, 0x0c78, 0x0c80, 0x0c88, 0x0c90, 0x0c98, 0x0ca0, 0x0ca8, 0x0cb0,
! 218: 0x0cb8, 0x0cc0, 0x0cc8, 0x0cd0, 0x0cd8, 0x0ce0, 0x0ce8, 0x0cf0, 0x0cf8,
! 219: 0x0cff, 0x0d04, 0x0d08, 0x0d0c, 0x0d10, 0x0d14, 0x0d18, 0x0d1c, 0x0d20,
! 220: 0x0d24, 0x0d28, 0x0d2c, 0x0d30, 0x0d34, 0x0d38, 0x0d3c, 0x0d40, 0x0d44,
! 221: 0x0d48, 0x0d4c, 0x0d50, 0x0d54, 0x0d58, 0x0d5c, 0x0d60, 0x0d64, 0x0d68,
! 222: 0x0d6c, 0x0d70, 0x0d74, 0x0d78, 0x0d7c, 0x0d80, 0x0d84, 0x0d88, 0x0d8c,
! 223: 0x0d90, 0x0d94, 0x0d98, 0x0d9c, 0x0da0, 0x0da4, 0x0da8, 0x0dac, 0x0db0,
! 224: 0x0db4, 0x0db8, 0x0dbc, 0x0dc0, 0x0dc4, 0x0dc8, 0x0dcc, 0x0dd0, 0x0dd4,
! 225: 0x0dd8, 0x0ddc, 0x0de0, 0x0de4, 0x0de8, 0x0dec, 0x0df0, 0x0df4, 0x0df8,
! 226: 0x0dfc, 0x0dff, 0x0e02, 0x0e04, 0x0e06, 0x0e08, 0x0e0a, 0x0e0c, 0x0e0e,
! 227: 0x0e10, 0x0e12, 0x0e14, 0x0e16, 0x0e18, 0x0e1a, 0x0e1c, 0x0e1e, 0x0e20,
! 228: 0x0e22, 0x0e24, 0x0e26, 0x0e28, 0x0e2a, 0x0e2c, 0x0e2e, 0x0e30, 0x0e32,
! 229: 0x0e34, 0x0e36, 0x0e38, 0x0e3a, 0x0e3c, 0x0e3e, 0x0e40, 0x0e42, 0x0e44,
! 230: 0x0e46, 0x0e48, 0x0e4a, 0x0e4c, 0x0e4e, 0x0e50, 0x0e52, 0x0e54, 0x0e56,
! 231: 0x0e58, 0x0e5a, 0x0e5c, 0x0e5e, 0x0e60, 0x0e62, 0x0e64, 0x0e66, 0x0e68,
! 232: 0x0e6a, 0x0e6c, 0x0e6e, 0x0e70, 0x0e72, 0x0e74, 0x0e76, 0x0e78, 0x0e7a,
! 233: 0x0e7c, 0x0e7e, 0x0e80, 0x0e82, 0x0e84, 0x0e86, 0x0e88, 0x0e8a, 0x0e8c,
! 234: 0x0e8e, 0x0e90, 0x0e92, 0x0e94, 0x0e96, 0x0e98, 0x0e9a, 0x0e9c, 0x0e9e,
! 235: 0x0ea0, 0x0ea2, 0x0ea4, 0x0ea6, 0x0ea8, 0x0eaa, 0x0eac, 0x0eae, 0x0eb0,
! 236: 0x0eb2, 0x0eb4, 0x0eb6, 0x0eb8, 0x0eba, 0x0ebc, 0x0ebe, 0x0ec0, 0x0ec2,
! 237: 0x0ec4, 0x0ec6, 0x0ec8, 0x0eca, 0x0ecc, 0x0ece, 0x0ed0, 0x0ed2, 0x0ed4,
! 238: 0x0ed6, 0x0ed8, 0x0eda, 0x0edc, 0x0ede, 0x0ee0, 0x0ee2, 0x0ee4, 0x0ee6,
! 239: 0x0ee8, 0x0eea, 0x0eec, 0x0eee, 0x0ef0, 0x0ef2, 0x0ef4, 0x0ef6, 0x0ef8,
! 240: 0x0efa, 0x0efc, 0x0efe, 0x0eff, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05,
! 241: 0x0f06, 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
! 242: 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16, 0x0f17,
! 243: 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e, 0x0f1f, 0x0f20,
! 244: 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26, 0x0f27, 0x0f28, 0x0f29,
! 245: 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e, 0x0f2f, 0x0f30, 0x0f31, 0x0f32,
! 246: 0x0f33, 0x0f34, 0x0f35, 0x0f36, 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b,
! 247: 0x0f3c, 0x0f3d, 0x0f3e, 0x0f3f, 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44,
! 248: 0x0f45, 0x0f46, 0x0f47, 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d,
! 249: 0x0f4e, 0x0f4f, 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56,
! 250: 0x0f57, 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
! 251: 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67, 0x0f68,
! 252: 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f, 0x0f70, 0x0f71,
! 253: 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77, 0x0f78, 0x0f79, 0x0f7a,
! 254: 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f, 0x0f80, 0x0f81, 0x0f82, 0x0f83,
! 255: 0x0f84, 0x0f85, 0x0f86, 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c,
! 256: 0x0f8d, 0x0f8e, 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95,
! 257: 0x0f96, 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
! 258: 0x0f9f, 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
! 259: 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf, 0x0fb0,
! 260: 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7, 0x0fb8, 0x0fb9,
! 261: 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf, 0x0fc0, 0x0fc1, 0x0fc2,
! 262: 0x0fc3, 0x0fc4, 0x0fc5, 0x0fc6, 0x0fc7, 0x0fc8, 0x0fc9, 0x0fca, 0x0fcb,
! 263: 0x0fcc, 0x0fcd, 0x0fce, 0x0fcf, 0x0fd0, 0x0fd1, 0x0fd2, 0x0fd3, 0x0fd4,
! 264: 0x0fd5, 0x0fd6, 0x0fd7, 0x0fd8, 0x0fd9, 0x0fda, 0x0fdb, 0x0fdc, 0x0fdd,
! 265: 0x0fde, 0x0fdf, 0x0fe0, 0x0fe1, 0x0fe2, 0x0fe3, 0x0fe4, 0x0fe5, 0x0fe6,
! 266: 0x0fe7, 0x0fe8, 0x0fe9, 0x0fea, 0x0feb, 0x0fec, 0x0fed, 0x0fee, 0x0fef,
! 267: 0x0ff0, 0x0ff1, 0x0ff2, 0x0ff3, 0x0ff4, 0x0ff5, 0x0ff6, 0x0ff7, 0x0ff8,
! 268: 0x0ff9, 0x0ffa, 0x0ffb, 0x0ffc, 0x0ffd, 0x0ffe, 0x0fff};
! 269:
! 270: /*
! 271: * Interface to higher level audio driver
! 272: */
! 273: struct audio_hw_if gus_hw_if = {
! 274: gusopen,
! 275: gusclose,
! 276: NULL, /* drain */
! 277:
! 278: gus_query_encoding,
! 279:
! 280: gus_set_params,
! 281:
! 282: gus_round_blocksize,
! 283:
! 284: gus_commit_settings,
! 285:
! 286: NULL,
! 287: NULL,
! 288:
! 289: gus_dma_output,
! 290: gus_dma_input,
! 291: gus_halt_out_dma,
! 292: gus_halt_in_dma,
! 293: gus_speaker_ctl,
! 294:
! 295: gus_getdev,
! 296: NULL,
! 297: gus_mixer_set_port,
! 298: gus_mixer_get_port,
! 299: gus_mixer_query_devinfo,
! 300: ad1848_malloc,
! 301: ad1848_free,
! 302: ad1848_round,
! 303: ad1848_mappage,
! 304: gus_get_props,
! 305:
! 306: NULL,
! 307: NULL
! 308: };
! 309:
! 310: static struct audio_hw_if gusmax_hw_if = {
! 311: gusmaxopen,
! 312: gusmax_close,
! 313: NULL, /* drain */
! 314:
! 315: gus_query_encoding, /* query encoding */
! 316:
! 317: gusmax_set_params,
! 318:
! 319: gusmax_round_blocksize,
! 320:
! 321: gusmax_commit_settings,
! 322:
! 323: NULL,
! 324: NULL,
! 325:
! 326: gusmax_dma_output,
! 327: gusmax_dma_input,
! 328: gusmax_halt_out_dma,
! 329: gusmax_halt_in_dma,
! 330:
! 331: gusmax_speaker_ctl,
! 332:
! 333: gus_getdev,
! 334: NULL,
! 335: gusmax_mixer_set_port,
! 336: gusmax_mixer_get_port,
! 337: gusmax_mixer_query_devinfo,
! 338: ad1848_malloc,
! 339: ad1848_free,
! 340: ad1848_round,
! 341: ad1848_mappage,
! 342: gusmax_get_props,
! 343: };
! 344:
! 345: /*
! 346: * Some info about the current audio device
! 347: */
! 348: struct audio_device gus_device = {
! 349: "UltraSound",
! 350: "",
! 351: "gus",
! 352: };
! 353:
! 354:
! 355: int
! 356: gusopen(addr, flags)
! 357: void *addr;
! 358: int flags;
! 359: {
! 360: struct gus_softc *sc = addr;
! 361:
! 362: DPRINTF(("gusopen() called\n"));
! 363:
! 364: if (sc->sc_flags & GUS_OPEN)
! 365: return EBUSY;
! 366:
! 367: /*
! 368: * Some initialization
! 369: */
! 370:
! 371: sc->sc_flags |= GUS_OPEN;
! 372: sc->sc_dmabuf = 0;
! 373: sc->sc_playbuf = -1;
! 374: sc->sc_bufcnt = 0;
! 375: sc->sc_voc[GUS_VOICE_LEFT].start_addr = GUS_MEM_OFFSET - 1;
! 376: sc->sc_voc[GUS_VOICE_LEFT].current_addr = GUS_MEM_OFFSET;
! 377:
! 378: if (HAS_CODEC(sc)) {
! 379: ad1848_open(&sc->sc_codec, flags);
! 380: sc->sc_codec.mute[AD1848_AUX1_CHANNEL] = 0;
! 381: ad1848_mute_channel(&sc->sc_codec, AD1848_AUX1_CHANNEL, 0); /* turn on DAC output */
! 382: if (flags & FREAD) {
! 383: sc->sc_codec.mute[AD1848_MONO_CHANNEL] = 0;
! 384: ad1848_mute_channel(&sc->sc_codec, AD1848_MONO_CHANNEL, 0);
! 385: }
! 386: } else if (flags & FREAD) {
! 387: /* enable/unmute the microphone */
! 388: if (HAS_MIXER(sc)) {
! 389: gusics_mic_mute(&sc->sc_mixer, 0);
! 390: } else
! 391: gus_mic_ctl(sc, SPKR_ON);
! 392: }
! 393: if (sc->sc_nbufs == 0)
! 394: gus_round_blocksize(sc, GUS_BUFFER_MULTIPLE); /* default blksiz */
! 395: return 0;
! 396: }
! 397:
! 398: int
! 399: gusmaxopen(addr, flags)
! 400: void *addr;
! 401: int flags;
! 402: {
! 403: struct ad1848_softc *ac = addr;
! 404: return gusopen(ac->parent, flags);
! 405: }
! 406:
! 407: void
! 408: gus_deinterleave(sc, buf, size)
! 409: struct gus_softc *sc;
! 410: void *buf;
! 411: int size;
! 412: {
! 413: /* deinterleave the stereo data. We can use sc->sc_deintr_buf
! 414: for scratch space. */
! 415: int i;
! 416:
! 417: if (size > sc->sc_blocksize) {
! 418: printf("gus: deinterleave %d > %d\n", size, sc->sc_blocksize);
! 419: return;
! 420: } else if (size < sc->sc_blocksize) {
! 421: DPRINTF(("gus: deinterleave %d < %d\n", size, sc->sc_blocksize));
! 422: }
! 423:
! 424: /*
! 425: * size is in bytes.
! 426: */
! 427: if (sc->sc_precision == 16) {
! 428: u_short *dei = sc->sc_deintr_buf;
! 429: u_short *sbuf = buf;
! 430: size >>= 1; /* bytecnt to shortcnt */
! 431: /* copy 2nd of each pair of samples to the staging area, while
! 432: compacting the 1st of each pair into the original area. */
! 433: for (i = 0; i < size/2-1; i++) {
! 434: dei[i] = sbuf[i*2+1];
! 435: sbuf[i+1] = sbuf[i*2+2];
! 436: }
! 437: /*
! 438: * this has copied one less sample than half of the
! 439: * buffer. The first sample of the 1st stream was
! 440: * already in place and didn't need copying.
! 441: * Therefore, we've moved all of the 1st stream's
! 442: * samples into place. We have one sample from 2nd
! 443: * stream in the last slot of original area, not
! 444: * copied to the staging area (But we don't need to!).
! 445: * Copy the remainder of the original stream into place.
! 446: */
! 447: bcopy(dei, &sbuf[size/2], i * sizeof(short));
! 448: } else {
! 449: u_char *dei = sc->sc_deintr_buf;
! 450: u_char *sbuf = buf;
! 451: for (i = 0; i < size/2-1; i++) {
! 452: dei[i] = sbuf[i*2+1];
! 453: sbuf[i+1] = sbuf[i*2+2];
! 454: }
! 455: bcopy(dei, &sbuf[size/2], i);
! 456: }
! 457: }
! 458:
! 459: /*
! 460: * Actually output a buffer to the DSP chip
! 461: */
! 462:
! 463: int
! 464: gusmax_dma_output(addr, buf, size, intr, arg)
! 465: void * addr;
! 466: void *buf;
! 467: int size;
! 468: void (*intr)(void *);
! 469: void *arg;
! 470: {
! 471: struct ad1848_softc *ac = addr;
! 472: return gus_dma_output(ac->parent, buf, size, intr, arg);
! 473: }
! 474:
! 475: /*
! 476: * called at splgus() from interrupt handler.
! 477: */
! 478: void
! 479: stereo_dmaintr(arg)
! 480: void *arg;
! 481: {
! 482: struct gus_softc *sc = arg;
! 483: struct stereo_dma_intr *sa = &sc->sc_stereo;
! 484:
! 485: DMAPRINTF(("stereo_dmaintr"));
! 486:
! 487: /*
! 488: * Put other half in its place, then call the real interrupt routine :)
! 489: */
! 490:
! 491: sc->sc_dmaoutintr = sa->intr;
! 492: sc->sc_outarg = sa->arg;
! 493:
! 494: #ifdef GUSPLAYDEBUG
! 495: if (gusstats) {
! 496: microtime(&dmarecords[dmarecord_index].tv);
! 497: dmarecords[dmarecord_index].gusaddr = sa->dmabuf;
! 498: dmarecords[dmarecord_index].bsdaddr = sa->buffer;
! 499: dmarecords[dmarecord_index].count = sa->size;
! 500: dmarecords[dmarecord_index].channel = 1;
! 501: dmarecords[dmarecord_index++].direction = 1;
! 502: dmarecord_index = dmarecord_index % NDMARECS;
! 503: }
! 504: #endif
! 505:
! 506: gusdmaout(sc, sa->flags, sa->dmabuf, (caddr_t) sa->buffer, sa->size);
! 507:
! 508: sa->flags = 0;
! 509: sa->dmabuf = 0;
! 510: sa->buffer = 0;
! 511: sa->size = 0;
! 512: sa->intr = 0;
! 513: sa->arg = 0;
! 514: }
! 515:
! 516: /*
! 517: * Start up DMA output to the card.
! 518: * Called at splgus/splaudio already, either from intr handler or from
! 519: * generic audio code.
! 520: */
! 521: int
! 522: gus_dma_output(addr, buf, size, intr, arg)
! 523: void * addr;
! 524: void *buf;
! 525: int size;
! 526: void (*intr)(void *);
! 527: void *arg;
! 528: {
! 529: struct gus_softc *sc = addr;
! 530: u_char *buffer = buf;
! 531: u_long boarddma;
! 532: int flags;
! 533:
! 534: DMAPRINTF(("gus_dma_output %d @ %p\n", size, buf));
! 535:
! 536: if (size != sc->sc_blocksize) {
! 537: DPRINTF(("gus_dma_output reqsize %d not sc_blocksize %d\n",
! 538: size, sc->sc_blocksize));
! 539: return EINVAL;
! 540: }
! 541:
! 542: flags = GUSMASK_DMA_WRITE;
! 543: if (sc->sc_precision == 16)
! 544: flags |= GUSMASK_DMA_DATA_SIZE;
! 545: if (sc->sc_encoding == AUDIO_ENCODING_ULAW ||
! 546: sc->sc_encoding == AUDIO_ENCODING_ALAW ||
! 547: sc->sc_encoding == AUDIO_ENCODING_ULINEAR_BE ||
! 548: sc->sc_encoding == AUDIO_ENCODING_ULINEAR_LE)
! 549: flags |= GUSMASK_DMA_INVBIT;
! 550:
! 551: if (sc->sc_channels == 2) {
! 552: if (sc->sc_precision == 16) {
! 553: if (size & 3) {
! 554: DPRINTF(("gus_dma_output: unpaired 16bit samples"));
! 555: size &= 3;
! 556: }
! 557: } else if (size & 1) {
! 558: DPRINTF(("gus_dma_output: unpaired samples"));
! 559: size &= 1;
! 560: }
! 561: if (size == 0)
! 562: return 0;
! 563:
! 564: gus_deinterleave(sc, (void *)buffer, size);
! 565:
! 566: size >>= 1;
! 567:
! 568: boarddma = size * sc->sc_dmabuf + GUS_MEM_OFFSET;
! 569:
! 570: sc->sc_stereo.intr = intr;
! 571: sc->sc_stereo.arg = arg;
! 572: sc->sc_stereo.size = size;
! 573: sc->sc_stereo.dmabuf = boarddma + GUS_LEFT_RIGHT_OFFSET;
! 574: sc->sc_stereo.buffer = buffer + size;
! 575: sc->sc_stereo.flags = flags;
! 576: if (gus_dostereo) {
! 577: intr = stereo_dmaintr;
! 578: arg = sc;
! 579: }
! 580: } else
! 581: boarddma = size * sc->sc_dmabuf + GUS_MEM_OFFSET;
! 582:
! 583:
! 584: sc->sc_flags |= GUS_LOCKED;
! 585: sc->sc_dmaoutintr = intr;
! 586: sc->sc_outarg = arg;
! 587:
! 588: #ifdef GUSPLAYDEBUG
! 589: if (gusstats) {
! 590: microtime(&dmarecords[dmarecord_index].tv);
! 591: dmarecords[dmarecord_index].gusaddr = boarddma;
! 592: dmarecords[dmarecord_index].bsdaddr = buffer;
! 593: dmarecords[dmarecord_index].count = size;
! 594: dmarecords[dmarecord_index].channel = 0;
! 595: dmarecords[dmarecord_index++].direction = 1;
! 596: dmarecord_index = dmarecord_index % NDMARECS;
! 597: }
! 598: #endif
! 599:
! 600: gusdmaout(sc, flags, boarddma, (caddr_t) buffer, size);
! 601:
! 602: return 0;
! 603: }
! 604:
! 605: void
! 606: gusmax_close(addr)
! 607: void *addr;
! 608: {
! 609: struct ad1848_softc *ac = addr;
! 610: struct gus_softc *sc = ac->parent;
! 611: #if 0
! 612: ac->mute[AD1848_AUX1_CHANNEL] = MUTE_ALL;
! 613: ad1848_mute_channel(ac, MUTE_ALL); /* turn off DAC output */
! 614: #endif
! 615: ad1848_close(ac);
! 616: gusclose(sc);
! 617: }
! 618:
! 619: /*
! 620: * Close out device stuff. Called at splgus() from generic audio layer.
! 621: */
! 622: void
! 623: gusclose(addr)
! 624: void *addr;
! 625: {
! 626: struct gus_softc *sc = addr;
! 627:
! 628: DPRINTF(("gus_close: sc=%p\n", sc));
! 629:
! 630:
! 631: /* if (sc->sc_flags & GUS_DMAOUT_ACTIVE) */ {
! 632: gus_halt_out_dma(sc);
! 633: }
! 634: /* if (sc->sc_flags & GUS_DMAIN_ACTIVE) */ {
! 635: gus_halt_in_dma(sc);
! 636: }
! 637: sc->sc_flags &= ~(GUS_OPEN|GUS_LOCKED|GUS_DMAOUT_ACTIVE|GUS_DMAIN_ACTIVE);
! 638:
! 639: if (sc->sc_deintr_buf) {
! 640: free(sc->sc_deintr_buf, M_DEVBUF);
! 641: sc->sc_deintr_buf = NULL;
! 642: }
! 643: /* turn off speaker, etc. */
! 644:
! 645: /* make sure the voices shut up: */
! 646: gus_stop_voice(sc, GUS_VOICE_LEFT, 1);
! 647: gus_stop_voice(sc, GUS_VOICE_RIGHT, 0);
! 648: }
! 649:
! 650: /*
! 651: * Service interrupts. Farm them off to helper routines if we are using the
! 652: * GUS for simple playback/record
! 653: */
! 654:
! 655: #ifdef AUDIO_DEBUG
! 656: int gusintrcnt;
! 657: int gusdmaintrcnt;
! 658: int gusvocintrcnt;
! 659: #endif
! 660:
! 661: int
! 662: gusintr(arg)
! 663: void *arg;
! 664: {
! 665: struct gus_softc *sc = arg;
! 666: bus_space_tag_t iot = sc->sc_iot;
! 667: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 668: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 669: unsigned char intr;
! 670:
! 671: int retval = 0;
! 672:
! 673: DPRINTF(("gusintr\n"));
! 674: #ifdef AUDIO_DEBUG
! 675: gusintrcnt++;
! 676: #endif
! 677: if (HAS_CODEC(sc))
! 678: retval = ad1848_intr(&sc->sc_codec);
! 679: if ((intr = bus_space_read_1(iot, ioh1, GUS_IRQ_STATUS)) & GUSMASK_IRQ_DMATC) {
! 680: DMAPRINTF(("gusintr dma flags=%x\n", sc->sc_flags));
! 681: #ifdef AUDIO_DEBUG
! 682: gusdmaintrcnt++;
! 683: #endif
! 684: retval += gus_dmaout_intr(sc);
! 685: if (sc->sc_flags & GUS_DMAIN_ACTIVE) {
! 686: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 687: intr = bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 688: if (intr & GUSMASK_SAMPLE_DMATC) {
! 689: retval += gus_dmain_intr(sc);
! 690: }
! 691: }
! 692: }
! 693: if (intr & (GUSMASK_IRQ_VOICE | GUSMASK_IRQ_VOLUME)) {
! 694: DMAPRINTF(("gusintr voice flags=%x\n", sc->sc_flags));
! 695: #ifdef AUDIO_DEBUG
! 696: gusvocintrcnt++;
! 697: #endif
! 698: retval += gus_voice_intr(sc);
! 699: }
! 700: if (retval)
! 701: return 1;
! 702: return retval;
! 703: }
! 704:
! 705: int gus_bufcnt[GUS_MEM_FOR_BUFFERS / GUS_BUFFER_MULTIPLE];
! 706: int gus_restart; /* how many restarts? */
! 707: int gus_stops; /* how many times did voice stop? */
! 708: int gus_falsestops; /* stopped but not done? */
! 709: int gus_continues;
! 710:
! 711: struct playcont {
! 712: struct timeval tv;
! 713: u_int playbuf;
! 714: u_int dmabuf;
! 715: u_char bufcnt;
! 716: u_char vaction;
! 717: u_char voccntl;
! 718: u_char volcntl;
! 719: u_long curaddr;
! 720: u_long endaddr;
! 721: } playstats[NDMARECS];
! 722:
! 723: int playcntr;
! 724:
! 725: void
! 726: gus_dmaout_timeout(arg)
! 727: void *arg;
! 728: {
! 729: struct gus_softc *sc = arg;
! 730: bus_space_tag_t iot = sc->sc_iot;
! 731: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 732: int s;
! 733:
! 734: printf("%s: dmaout timeout\n", sc->sc_dev.dv_xname);
! 735: /*
! 736: * Stop any DMA.
! 737: */
! 738:
! 739: s = splgus();
! 740: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 741: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0);
! 742:
! 743: #if 0
! 744: /* XXX we will dmadone below? */
! 745: isa_dmaabort(sc->sc_dev.dv_parent, sc->sc_drq);
! 746: #endif
! 747:
! 748: gus_dmaout_dointr(sc);
! 749: splx(s);
! 750: }
! 751:
! 752:
! 753: /*
! 754: * Service DMA interrupts. This routine will only get called if we're doing
! 755: * a DMA transfer for playback/record requests from the audio layer.
! 756: */
! 757:
! 758: int
! 759: gus_dmaout_intr(sc)
! 760: struct gus_softc *sc;
! 761: {
! 762: bus_space_tag_t iot = sc->sc_iot;
! 763: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 764:
! 765: /*
! 766: * If we got a DMA transfer complete from the GUS DRAM, then deal
! 767: * with it.
! 768: */
! 769:
! 770: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 771: if (bus_space_read_1(iot, ioh2, GUS_DATA_HIGH) & GUSMASK_DMA_IRQPEND) {
! 772: timeout_del(&sc->sc_dma_tmo);
! 773: gus_dmaout_dointr(sc);
! 774: return 1;
! 775: }
! 776: return 0;
! 777: }
! 778:
! 779: void
! 780: gus_dmaout_dointr(sc)
! 781: struct gus_softc *sc;
! 782: {
! 783: bus_space_tag_t iot = sc->sc_iot;
! 784: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 785:
! 786: /* sc->sc_dmaoutcnt - 1 because DMA controller counts from zero?. */
! 787: isa_dmadone(sc->sc_dev.dv_parent, sc->sc_drq);
! 788: sc->sc_flags &= ~GUS_DMAOUT_ACTIVE; /* pending DMA is done */
! 789: DMAPRINTF(("gus_dmaout_dointr %d @ %p\n", sc->sc_dmaoutcnt,
! 790: sc->sc_dmaoutaddr));
! 791:
! 792: /*
! 793: * to prevent clicking, we need to copy last sample
! 794: * from last buffer to scratch area just before beginning of
! 795: * buffer. However, if we're doing formats that are converted by
! 796: * the card during the DMA process, we need to pick up the converted
! 797: * byte rather than the one we have in memory.
! 798: */
! 799: if (sc->sc_dmabuf == sc->sc_nbufs - 1) {
! 800: int i;
! 801: switch (sc->sc_encoding) {
! 802: case AUDIO_ENCODING_SLINEAR_LE:
! 803: case AUDIO_ENCODING_SLINEAR_BE:
! 804: if (sc->sc_precision == 8)
! 805: goto byte;
! 806: /* we have the native format */
! 807: for (i = 1; i <= 2; i++)
! 808: guspoke(iot, ioh2, sc->sc_gusaddr -
! 809: (sc->sc_nbufs - 1) * sc->sc_chanblocksize - i,
! 810: sc->sc_dmaoutaddr[sc->sc_dmaoutcnt-i]);
! 811: break;
! 812: case AUDIO_ENCODING_ULINEAR_LE:
! 813: case AUDIO_ENCODING_ULINEAR_BE:
! 814: guspoke(iot, ioh2, sc->sc_gusaddr -
! 815: (sc->sc_nbufs - 1) * sc->sc_chanblocksize - 2,
! 816: guspeek(iot, ioh2,
! 817: sc->sc_gusaddr + sc->sc_chanblocksize - 2));
! 818: case AUDIO_ENCODING_ALAW:
! 819: case AUDIO_ENCODING_ULAW:
! 820: byte:
! 821: /* we need to fetch the translated byte, then stuff it. */
! 822: guspoke(iot, ioh2, sc->sc_gusaddr -
! 823: (sc->sc_nbufs - 1) * sc->sc_chanblocksize - 1,
! 824: guspeek(iot, ioh2,
! 825: sc->sc_gusaddr + sc->sc_chanblocksize - 1));
! 826: break;
! 827: }
! 828: }
! 829: /*
! 830: * If this is the first half of stereo, "ignore" this one
! 831: * and copy out the second half.
! 832: */
! 833: if (sc->sc_dmaoutintr == stereo_dmaintr) {
! 834: (*sc->sc_dmaoutintr)(sc->sc_outarg);
! 835: return;
! 836: }
! 837: /*
! 838: * If the voice is stopped, then start it. Reset the loop
! 839: * and roll bits. Call the audio layer routine, since if
! 840: * we're starting a stopped voice, that means that the next
! 841: * buffer can be filled
! 842: */
! 843:
! 844: sc->sc_flags &= ~GUS_LOCKED;
! 845: if (sc->sc_voc[GUS_VOICE_LEFT].voccntl &
! 846: GUSMASK_VOICE_STOPPED) {
! 847: if (sc->sc_flags & GUS_PLAYING) {
! 848: printf("%s: playing yet stopped?\n", sc->sc_dev.dv_xname);
! 849: }
! 850: sc->sc_bufcnt++; /* another yet to be played */
! 851: gus_start_playing(sc, sc->sc_dmabuf);
! 852: gus_restart++;
! 853: } else {
! 854: /*
! 855: * set the sound action based on which buffer we
! 856: * just transferred. If we just transferred buffer 0
! 857: * we want the sound to loop when it gets to the nth
! 858: * buffer; if we just transferred
! 859: * any other buffer, we want the sound to roll over
! 860: * at least one more time. The voice interrupt
! 861: * handlers will take care of accounting &
! 862: * setting control bits if it's not caught up to us
! 863: * yet.
! 864: */
! 865: if (++sc->sc_bufcnt == 2) {
! 866: /*
! 867: * XXX
! 868: * If we're too slow in reaction here,
! 869: * the voice could be just approaching the
! 870: * end of its run. It should be set to stop,
! 871: * so these adjustments might not DTRT.
! 872: */
! 873: if (sc->sc_dmabuf == 0 &&
! 874: sc->sc_playbuf == sc->sc_nbufs - 1) {
! 875: /* player is just at the last buf, we're at the
! 876: first. Turn on looping, turn off rolling. */
! 877: sc->sc_voc[GUS_VOICE_LEFT].voccntl |= GUSMASK_LOOP_ENABLE;
! 878: sc->sc_voc[GUS_VOICE_LEFT].volcntl &= ~GUSMASK_VOICE_ROLL;
! 879: playstats[playcntr].vaction = 3;
! 880: } else {
! 881: /* player is at previous buf:
! 882: turn on rolling, turn off looping */
! 883: sc->sc_voc[GUS_VOICE_LEFT].voccntl &= ~GUSMASK_LOOP_ENABLE;
! 884: sc->sc_voc[GUS_VOICE_LEFT].volcntl |= GUSMASK_VOICE_ROLL;
! 885: playstats[playcntr].vaction = 4;
! 886: }
! 887: #ifdef GUSPLAYDEBUG
! 888: if (gusstats) {
! 889: microtime(&playstats[playcntr].tv);
! 890: playstats[playcntr].endaddr = sc->sc_voc[GUS_VOICE_LEFT].end_addr;
! 891: playstats[playcntr].voccntl = sc->sc_voc[GUS_VOICE_LEFT].voccntl;
! 892: playstats[playcntr].volcntl = sc->sc_voc[GUS_VOICE_LEFT].volcntl;
! 893: playstats[playcntr].playbuf = sc->sc_playbuf;
! 894: playstats[playcntr].dmabuf = sc->sc_dmabuf;
! 895: playstats[playcntr].bufcnt = sc->sc_bufcnt;
! 896: playstats[playcntr++].curaddr = gus_get_curaddr(sc, GUS_VOICE_LEFT);
! 897: playcntr = playcntr % NDMARECS;
! 898: }
! 899: #endif
! 900: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, GUS_VOICE_LEFT);
! 901: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 902: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_LEFT].voccntl);
! 903: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 904: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_LEFT].volcntl);
! 905: }
! 906: }
! 907: gus_bufcnt[sc->sc_bufcnt-1]++;
! 908: /*
! 909: * flip to the next DMA buffer
! 910: */
! 911:
! 912: sc->sc_dmabuf = ++sc->sc_dmabuf % sc->sc_nbufs;
! 913: /*
! 914: * See comments below about DMA admission control strategy.
! 915: * We can call the upper level here if we have an
! 916: * idle buffer (not currently playing) to DMA into.
! 917: */
! 918: if (sc->sc_dmaoutintr && sc->sc_bufcnt < sc->sc_nbufs) {
! 919: /* clean out to prevent double calls */
! 920: void (*pfunc)(void *) = sc->sc_dmaoutintr;
! 921: void *arg = sc->sc_outarg;
! 922:
! 923: sc->sc_outarg = 0;
! 924: sc->sc_dmaoutintr = 0;
! 925: (*pfunc)(arg);
! 926: }
! 927: }
! 928:
! 929: /*
! 930: * Service voice interrupts
! 931: */
! 932:
! 933: int
! 934: gus_voice_intr(sc)
! 935: struct gus_softc *sc;
! 936: {
! 937: bus_space_tag_t iot = sc->sc_iot;
! 938: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 939: int ignore = 0, voice, rval = 0;
! 940: unsigned char intr, status;
! 941:
! 942: /*
! 943: * The point of this may not be obvious at first. A voice can
! 944: * interrupt more than once; according to the GUS SDK we are supposed
! 945: * to ignore multiple interrupts for the same voice.
! 946: */
! 947:
! 948: while(1) {
! 949: SELECT_GUS_REG(iot, ioh2, GUSREG_IRQ_STATUS);
! 950: intr = bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 951:
! 952: if ((intr & (GUSMASK_WIRQ_VOLUME | GUSMASK_WIRQ_VOICE))
! 953: == (GUSMASK_WIRQ_VOLUME | GUSMASK_WIRQ_VOICE))
! 954: /*
! 955: * No more interrupts, time to return
! 956: */
! 957: return rval;
! 958:
! 959: if ((intr & GUSMASK_WIRQ_VOICE) == 0) {
! 960:
! 961: /*
! 962: * We've got a voice interrupt. Ignore previous
! 963: * interrupts by the same voice.
! 964: */
! 965:
! 966: rval = 1;
! 967: voice = intr & GUSMASK_WIRQ_VOICEMASK;
! 968:
! 969: if ((1 << voice) & ignore)
! 970: break;
! 971:
! 972: ignore |= 1 << voice;
! 973:
! 974: /*
! 975: * If the voice is stopped, then force it to stop
! 976: * (this stops it from continuously generating IRQs)
! 977: */
! 978:
! 979: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL+0x80);
! 980: status = bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 981: if (status & GUSMASK_VOICE_STOPPED) {
! 982: if (voice != GUS_VOICE_LEFT) {
! 983: DMAPRINTF(("%s: spurious voice %d stop?\n",
! 984: sc->sc_dev.dv_xname, voice));
! 985: gus_stop_voice(sc, voice, 0);
! 986: continue;
! 987: }
! 988: gus_stop_voice(sc, voice, 1);
! 989: /* also kill right voice */
! 990: gus_stop_voice(sc, GUS_VOICE_RIGHT, 0);
! 991: sc->sc_bufcnt--; /* it finished a buffer */
! 992: if (sc->sc_bufcnt > 0) {
! 993: /*
! 994: * probably a race to get here: the voice
! 995: * stopped while the DMA code was just trying to
! 996: * get the next buffer in place.
! 997: * Start the voice again.
! 998: */
! 999: printf("%s: stopped voice not drained? (%x)\n",
! 1000: sc->sc_dev.dv_xname, sc->sc_bufcnt);
! 1001: gus_falsestops++;
! 1002:
! 1003: sc->sc_playbuf = ++sc->sc_playbuf % sc->sc_nbufs;
! 1004: gus_start_playing(sc, sc->sc_playbuf);
! 1005: } else if (sc->sc_bufcnt < 0) {
! 1006: #ifdef DDB
! 1007: printf("%s: negative bufcnt in stopped voice\n",
! 1008: sc->sc_dev.dv_xname);
! 1009: Debugger();
! 1010: #else
! 1011: panic("%s: negative bufcnt in stopped voice",
! 1012: sc->sc_dev.dv_xname);
! 1013: #endif
! 1014: } else {
! 1015: sc->sc_playbuf = -1; /* none are active */
! 1016: gus_stops++;
! 1017: }
! 1018: /* fall through to callback and admit another
! 1019: buffer.... */
! 1020: } else if (sc->sc_bufcnt != 0) {
! 1021: /*
! 1022: * This should always be taken if the voice
! 1023: * is not stopped.
! 1024: */
! 1025: gus_continues++;
! 1026: if (gus_continue_playing(sc, voice)) {
! 1027: /*
! 1028: * we shouldn't have continued--active DMA
! 1029: * is in the way in the ring, for
! 1030: * some as-yet undebugged reason.
! 1031: */
! 1032: gus_stop_voice(sc, GUS_VOICE_LEFT, 1);
! 1033: /* also kill right voice */
! 1034: gus_stop_voice(sc, GUS_VOICE_RIGHT, 0);
! 1035: sc->sc_playbuf = -1;
! 1036: gus_stops++;
! 1037: }
! 1038: }
! 1039: /*
! 1040: * call the upper level to send on down another
! 1041: * block. We do admission rate control as follows:
! 1042: *
! 1043: * When starting up output (in the first N
! 1044: * blocks), call the upper layer after the DMA is
! 1045: * complete (see above in gus_dmaout_intr()).
! 1046: *
! 1047: * When output is already in progress and we have
! 1048: * no more GUS buffers to use for DMA, the DMA
! 1049: * output routines do not call the upper layer.
! 1050: * Instead, we call the DMA completion routine
! 1051: * here, after the voice interrupts indicating
! 1052: * that it's finished with a buffer.
! 1053: *
! 1054: * However, don't call anything here if the DMA
! 1055: * output flag is set, (which shouldn't happen)
! 1056: * because we'll squish somebody else's DMA if
! 1057: * that's the case. When DMA is done, it will
! 1058: * call back if there is a spare buffer.
! 1059: */
! 1060: if (sc->sc_dmaoutintr && !(sc->sc_flags & GUS_LOCKED)) {
! 1061: if (sc->sc_dmaoutintr == stereo_dmaintr)
! 1062: printf("gusdmaout botch?\n");
! 1063: else {
! 1064: /* clean out to avoid double calls */
! 1065: void (*pfunc)(void *) = sc->sc_dmaoutintr;
! 1066: void *arg = sc->sc_outarg;
! 1067:
! 1068: sc->sc_outarg = 0;
! 1069: sc->sc_dmaoutintr = 0;
! 1070: (*pfunc)(arg);
! 1071: }
! 1072: }
! 1073: }
! 1074:
! 1075: /*
! 1076: * Ignore other interrupts for now
! 1077: */
! 1078: }
! 1079: return 0;
! 1080: }
! 1081:
! 1082: void
! 1083: gus_start_playing(sc, bufno)
! 1084: struct gus_softc *sc;
! 1085: int bufno;
! 1086: {
! 1087: bus_space_tag_t iot = sc->sc_iot;
! 1088: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1089: /*
! 1090: * Start the voices playing, with buffer BUFNO.
! 1091: */
! 1092:
! 1093: /*
! 1094: * Loop or roll if we have buffers ready.
! 1095: */
! 1096:
! 1097: if (sc->sc_bufcnt == 1) {
! 1098: sc->sc_voc[GUS_VOICE_LEFT].voccntl &= ~(GUSMASK_LOOP_ENABLE);
! 1099: sc->sc_voc[GUS_VOICE_LEFT].volcntl &= ~(GUSMASK_VOICE_ROLL);
! 1100: } else {
! 1101: if (bufno == sc->sc_nbufs - 1) {
! 1102: sc->sc_voc[GUS_VOICE_LEFT].voccntl |= GUSMASK_LOOP_ENABLE;
! 1103: sc->sc_voc[GUS_VOICE_LEFT].volcntl &= ~(GUSMASK_VOICE_ROLL);
! 1104: } else {
! 1105: sc->sc_voc[GUS_VOICE_LEFT].voccntl &= ~GUSMASK_LOOP_ENABLE;
! 1106: sc->sc_voc[GUS_VOICE_LEFT].volcntl |= GUSMASK_VOICE_ROLL;
! 1107: }
! 1108: }
! 1109:
! 1110: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, GUS_VOICE_LEFT);
! 1111:
! 1112: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1113: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_LEFT].voccntl);
! 1114:
! 1115: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 1116: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_LEFT].volcntl);
! 1117:
! 1118: sc->sc_voc[GUS_VOICE_LEFT].current_addr =
! 1119: GUS_MEM_OFFSET + sc->sc_chanblocksize * bufno;
! 1120: sc->sc_voc[GUS_VOICE_LEFT].end_addr =
! 1121: sc->sc_voc[GUS_VOICE_LEFT].current_addr + sc->sc_chanblocksize - 1;
! 1122: sc->sc_voc[GUS_VOICE_RIGHT].current_addr =
! 1123: sc->sc_voc[GUS_VOICE_LEFT].current_addr +
! 1124: (gus_dostereo && sc->sc_channels == 2 ? GUS_LEFT_RIGHT_OFFSET : 0);
! 1125: /*
! 1126: * set up right channel to just loop forever, no interrupts,
! 1127: * starting at the buffer we just filled. We'll feed it data
! 1128: * at the same time as left channel.
! 1129: */
! 1130: sc->sc_voc[GUS_VOICE_RIGHT].voccntl |= GUSMASK_LOOP_ENABLE;
! 1131: sc->sc_voc[GUS_VOICE_RIGHT].volcntl &= ~(GUSMASK_VOICE_ROLL);
! 1132:
! 1133: #ifdef GUSPLAYDEBUG
! 1134: if (gusstats) {
! 1135: microtime(&playstats[playcntr].tv);
! 1136: playstats[playcntr].curaddr = sc->sc_voc[GUS_VOICE_LEFT].current_addr;
! 1137:
! 1138: playstats[playcntr].voccntl = sc->sc_voc[GUS_VOICE_LEFT].voccntl;
! 1139: playstats[playcntr].volcntl = sc->sc_voc[GUS_VOICE_LEFT].volcntl;
! 1140: playstats[playcntr].endaddr = sc->sc_voc[GUS_VOICE_LEFT].end_addr;
! 1141: playstats[playcntr].playbuf = bufno;
! 1142: playstats[playcntr].dmabuf = sc->sc_dmabuf;
! 1143: playstats[playcntr].bufcnt = sc->sc_bufcnt;
! 1144: playstats[playcntr++].vaction = 5;
! 1145: playcntr = playcntr % NDMARECS;
! 1146: }
! 1147: #endif
! 1148:
! 1149: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, GUS_VOICE_RIGHT);
! 1150: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1151: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_RIGHT].voccntl);
! 1152: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 1153: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[GUS_VOICE_RIGHT].volcntl);
! 1154:
! 1155: gus_start_voice(sc, GUS_VOICE_RIGHT, 0);
! 1156: gus_start_voice(sc, GUS_VOICE_LEFT, 1);
! 1157: if (sc->sc_playbuf == -1)
! 1158: /* mark start of playing */
! 1159: sc->sc_playbuf = bufno;
! 1160: }
! 1161:
! 1162: int
! 1163: gus_continue_playing(sc, voice)
! 1164: struct gus_softc *sc;
! 1165: int voice;
! 1166: {
! 1167: bus_space_tag_t iot = sc->sc_iot;
! 1168: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1169:
! 1170: /*
! 1171: * stop this voice from interrupting while we work.
! 1172: */
! 1173:
! 1174: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1175: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl & ~(GUSMASK_VOICE_IRQ));
! 1176:
! 1177: /*
! 1178: * update playbuf to point to the buffer the hardware just started
! 1179: * playing
! 1180: */
! 1181: sc->sc_playbuf = ++sc->sc_playbuf % sc->sc_nbufs;
! 1182:
! 1183: /*
! 1184: * account for buffer just finished
! 1185: */
! 1186: if (--sc->sc_bufcnt == 0) {
! 1187: DPRINTF(("gus: bufcnt 0 on continuing voice?\n"));
! 1188: }
! 1189: if (sc->sc_playbuf == sc->sc_dmabuf && (sc->sc_flags & GUS_LOCKED)) {
! 1190: printf("%s: continue into active dmabuf?\n", sc->sc_dev.dv_xname);
! 1191: return 1;
! 1192: }
! 1193:
! 1194: /*
! 1195: * Select the end of the buffer based on the currently active
! 1196: * buffer, [plus extra contiguous buffers (if ready)].
! 1197: */
! 1198:
! 1199: /*
! 1200: * set endpoint at end of buffer we just started playing.
! 1201: *
! 1202: * The total gets -1 because end addrs are one less than you might
! 1203: * think (the end_addr is the address of the last sample to play)
! 1204: */
! 1205: gus_set_endaddr(sc, voice, GUS_MEM_OFFSET +
! 1206: sc->sc_chanblocksize * (sc->sc_playbuf + 1) - 1);
! 1207:
! 1208: if (sc->sc_bufcnt < 2) {
! 1209: /*
! 1210: * Clear out the loop and roll flags, and rotate the currently
! 1211: * playing buffer. That way, if we don't manage to get more
! 1212: * data before this buffer finishes, we'll just stop.
! 1213: */
! 1214: sc->sc_voc[voice].voccntl &= ~GUSMASK_LOOP_ENABLE;
! 1215: sc->sc_voc[voice].volcntl &= ~GUSMASK_VOICE_ROLL;
! 1216: playstats[playcntr].vaction = 0;
! 1217: } else {
! 1218: /*
! 1219: * We have some buffers to play. set LOOP if we're on the
! 1220: * last buffer in the ring, otherwise set ROLL.
! 1221: */
! 1222: if (sc->sc_playbuf == sc->sc_nbufs - 1) {
! 1223: sc->sc_voc[voice].voccntl |= GUSMASK_LOOP_ENABLE;
! 1224: sc->sc_voc[voice].volcntl &= ~GUSMASK_VOICE_ROLL;
! 1225: playstats[playcntr].vaction = 1;
! 1226: } else {
! 1227: sc->sc_voc[voice].voccntl &= ~GUSMASK_LOOP_ENABLE;
! 1228: sc->sc_voc[voice].volcntl |= GUSMASK_VOICE_ROLL;
! 1229: playstats[playcntr].vaction = 2;
! 1230: }
! 1231: }
! 1232: #ifdef GUSPLAYDEBUG
! 1233: if (gusstats) {
! 1234: microtime(&playstats[playcntr].tv);
! 1235: playstats[playcntr].curaddr = gus_get_curaddr(sc, voice);
! 1236:
! 1237: playstats[playcntr].voccntl = sc->sc_voc[voice].voccntl;
! 1238: playstats[playcntr].volcntl = sc->sc_voc[voice].volcntl;
! 1239: playstats[playcntr].endaddr = sc->sc_voc[voice].end_addr;
! 1240: playstats[playcntr].playbuf = sc->sc_playbuf;
! 1241: playstats[playcntr].dmabuf = sc->sc_dmabuf;
! 1242: playstats[playcntr++].bufcnt = sc->sc_bufcnt;
! 1243: playcntr = playcntr % NDMARECS;
! 1244: }
! 1245: #endif
! 1246:
! 1247: /*
! 1248: * (re-)set voice parameters. This will reenable interrupts from this
! 1249: * voice.
! 1250: */
! 1251:
! 1252: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1253: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl);
! 1254: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 1255: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].volcntl);
! 1256: return 0;
! 1257: }
! 1258:
! 1259: /*
! 1260: * Send/receive data into GUS's DRAM using DMA. Called at splgus()
! 1261: */
! 1262:
! 1263: void
! 1264: gusdmaout(sc, flags, gusaddr, buffaddr, length)
! 1265: struct gus_softc *sc;
! 1266: int flags, length;
! 1267: u_long gusaddr;
! 1268: caddr_t buffaddr;
! 1269: {
! 1270: unsigned char c = (unsigned char) flags;
! 1271: bus_space_tag_t iot = sc->sc_iot;
! 1272: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1273:
! 1274: DMAPRINTF(("gusdmaout flags=%x scflags=%x\n", flags, sc->sc_flags));
! 1275:
! 1276: sc->sc_gusaddr = gusaddr;
! 1277:
! 1278: /*
! 1279: * If we're using a 16 bit DMA channel, we have to jump through some
! 1280: * extra hoops; this includes translating the DRAM address a bit
! 1281: */
! 1282:
! 1283: if (sc->sc_drq >= 4) {
! 1284: c |= GUSMASK_DMA_WIDTH;
! 1285: gusaddr = convert_to_16bit(gusaddr);
! 1286: }
! 1287:
! 1288: /*
! 1289: * Add flag bits that we always set - fast DMA, enable IRQ
! 1290: */
! 1291:
! 1292: c |= GUSMASK_DMA_ENABLE | GUSMASK_DMA_R0 | GUSMASK_DMA_IRQ;
! 1293:
! 1294: /*
! 1295: * Make sure the GUS _isn't_ setup for DMA
! 1296: */
! 1297:
! 1298: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 1299: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0);
! 1300:
! 1301: /*
! 1302: * Tell the PC DMA controller to start doing DMA
! 1303: */
! 1304:
! 1305: sc->sc_dmaoutaddr = (u_char *) buffaddr;
! 1306: sc->sc_dmaoutcnt = length;
! 1307: isa_dmastart(sc->sc_dev.dv_parent, sc->sc_drq, buffaddr, length,
! 1308: NULL, DMAMODE_WRITE, BUS_DMA_NOWAIT);
! 1309:
! 1310: /*
! 1311: * Set up DMA address - use the upper 16 bits ONLY
! 1312: */
! 1313:
! 1314: sc->sc_flags |= GUS_DMAOUT_ACTIVE;
! 1315:
! 1316: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_START);
! 1317: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, (int) (gusaddr >> 4));
! 1318:
! 1319: /*
! 1320: * Tell the GUS to start doing DMA
! 1321: */
! 1322:
! 1323: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 1324: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, c);
! 1325:
! 1326: /*
! 1327: * XXX If we don't finish in one second, give up...
! 1328: */
! 1329: timeout_add(&sc->sc_dma_tmo, hz);
! 1330: }
! 1331:
! 1332: /*
! 1333: * Start a voice playing on the GUS. Called from interrupt handler at
! 1334: * splgus().
! 1335: */
! 1336:
! 1337: void
! 1338: gus_start_voice(sc, voice, intrs)
! 1339: struct gus_softc *sc;
! 1340: int voice;
! 1341: int intrs;
! 1342: {
! 1343: bus_space_tag_t iot = sc->sc_iot;
! 1344: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1345: u_long start;
! 1346: u_long current;
! 1347: u_long end;
! 1348:
! 1349: /*
! 1350: * Pick all the values for the voice out of the gus_voice struct
! 1351: * and use those to program the voice
! 1352: */
! 1353:
! 1354: start = sc->sc_voc[voice].start_addr;
! 1355: current = sc->sc_voc[voice].current_addr;
! 1356: end = sc->sc_voc[voice].end_addr;
! 1357:
! 1358: /*
! 1359: * If we're using 16 bit data, mangle the addresses a bit
! 1360: */
! 1361:
! 1362: if (sc->sc_voc[voice].voccntl & GUSMASK_DATA_SIZE16) {
! 1363: /* -1 on start so that we get onto sample boundary--other
! 1364: code always sets it for 1-byte rollover protection */
! 1365: start = convert_to_16bit(start-1);
! 1366: current = convert_to_16bit(current);
! 1367: end = convert_to_16bit(end);
! 1368: }
! 1369:
! 1370: /*
! 1371: * Select the voice we want to use, and program the data addresses
! 1372: */
! 1373:
! 1374: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1375:
! 1376: SELECT_GUS_REG(iot, ioh2, GUSREG_START_ADDR_HIGH);
! 1377: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_HIGH(start));
! 1378: SELECT_GUS_REG(iot, ioh2, GUSREG_START_ADDR_LOW);
! 1379: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_LOW(start));
! 1380:
! 1381: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_HIGH);
! 1382: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_HIGH(current));
! 1383: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_LOW);
! 1384: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_LOW(current));
! 1385:
! 1386: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_HIGH);
! 1387: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_HIGH(end));
! 1388: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_LOW);
! 1389: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_LOW(end));
! 1390:
! 1391: /*
! 1392: * (maybe) enable interrupts, disable voice stopping
! 1393: */
! 1394:
! 1395: if (intrs) {
! 1396: sc->sc_flags |= GUS_PLAYING; /* playing is about to start */
! 1397: sc->sc_voc[voice].voccntl |= GUSMASK_VOICE_IRQ;
! 1398: DMAPRINTF(("gus voice playing=%x\n", sc->sc_flags));
! 1399: } else
! 1400: sc->sc_voc[voice].voccntl &= ~GUSMASK_VOICE_IRQ;
! 1401: sc->sc_voc[voice].voccntl &= ~(GUSMASK_VOICE_STOPPED |
! 1402: GUSMASK_STOP_VOICE);
! 1403:
! 1404: /*
! 1405: * Tell the GUS about it. Note that we're doing volume ramping here
! 1406: * from 0 up to the set volume to help reduce clicks.
! 1407: */
! 1408:
! 1409: SELECT_GUS_REG(iot, ioh2, GUSREG_START_VOLUME);
! 1410: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 1411: SELECT_GUS_REG(iot, ioh2, GUSREG_END_VOLUME);
! 1412: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].current_volume >> 4);
! 1413: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_VOLUME);
! 1414: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x00);
! 1415: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_RATE);
! 1416: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 63);
! 1417:
! 1418: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1419: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl);
! 1420: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 1421: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 1422: delay(50);
! 1423: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1424: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl);
! 1425: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 1426: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 1427:
! 1428: }
! 1429:
! 1430: /*
! 1431: * Stop a given voice. called at splgus()
! 1432: */
! 1433:
! 1434: void
! 1435: gus_stop_voice(sc, voice, intrs_too)
! 1436: struct gus_softc *sc;
! 1437: int voice;
! 1438: int intrs_too;
! 1439: {
! 1440: bus_space_tag_t iot = sc->sc_iot;
! 1441: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1442:
! 1443: sc->sc_voc[voice].voccntl |= GUSMASK_VOICE_STOPPED |
! 1444: GUSMASK_STOP_VOICE;
! 1445: if (intrs_too) {
! 1446: sc->sc_voc[voice].voccntl &= ~(GUSMASK_VOICE_IRQ);
! 1447: /* no more DMA to do */
! 1448: sc->sc_flags &= ~GUS_PLAYING;
! 1449: }
! 1450: DMAPRINTF(("gusintr voice notplaying=%x\n", sc->sc_flags));
! 1451:
! 1452: guspoke(iot, ioh2, 0L, 0);
! 1453:
! 1454: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1455:
! 1456: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_VOLUME);
! 1457: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 1458: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1459: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl);
! 1460: delay(100);
! 1461: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_VOLUME);
! 1462: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 1463: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 1464: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[voice].voccntl);
! 1465:
! 1466: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_HIGH);
! 1467: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 1468: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_LOW);
! 1469: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 1470:
! 1471: }
! 1472:
! 1473:
! 1474: /*
! 1475: * Set the volume of a given voice. Called at splgus().
! 1476: */
! 1477: void
! 1478: gus_set_volume(sc, voice, volume)
! 1479: struct gus_softc *sc;
! 1480: int voice, volume;
! 1481: {
! 1482: bus_space_tag_t iot = sc->sc_iot;
! 1483: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1484: unsigned int gusvol;
! 1485:
! 1486: gusvol = gus_log_volumes[volume < 512 ? volume : 511];
! 1487:
! 1488: sc->sc_voc[voice].current_volume = gusvol;
! 1489:
! 1490: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1491:
! 1492: SELECT_GUS_REG(iot, ioh2, GUSREG_START_VOLUME);
! 1493: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, (unsigned char) (gusvol >> 4));
! 1494:
! 1495: SELECT_GUS_REG(iot, ioh2, GUSREG_END_VOLUME);
! 1496: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, (unsigned char) (gusvol >> 4));
! 1497:
! 1498: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_VOLUME);
! 1499: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, gusvol << 4);
! 1500: delay(500);
! 1501: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, gusvol << 4);
! 1502:
! 1503: }
! 1504:
! 1505: /*
! 1506: * Interface to the audio layer.
! 1507: */
! 1508:
! 1509: int
! 1510: gusmax_set_params(addr, setmode, usemode, p, r)
! 1511: void *addr;
! 1512: int setmode, usemode;
! 1513: struct audio_params *p, *r;
! 1514: {
! 1515: struct ad1848_softc *ac = addr;
! 1516: struct gus_softc *sc = ac->parent;
! 1517: int error;
! 1518:
! 1519: error = ad1848_set_params(ac, setmode, usemode, p, r);
! 1520: if (error)
! 1521: return error;
! 1522: error = gus_set_params(sc, setmode, usemode, p, r);
! 1523: return error;
! 1524: }
! 1525:
! 1526: int
! 1527: gus_set_params(addr, setmode, usemode, p, r)
! 1528: void *addr;
! 1529: int setmode, usemode;
! 1530: struct audio_params *p, *r;
! 1531: {
! 1532: struct gus_softc *sc = addr;
! 1533: int s;
! 1534:
! 1535: switch (p->encoding) {
! 1536: case AUDIO_ENCODING_ULAW:
! 1537: case AUDIO_ENCODING_ALAW:
! 1538: case AUDIO_ENCODING_SLINEAR_LE:
! 1539: case AUDIO_ENCODING_ULINEAR_LE:
! 1540: case AUDIO_ENCODING_SLINEAR_BE:
! 1541: case AUDIO_ENCODING_ULINEAR_BE:
! 1542: break;
! 1543: default:
! 1544: return (EINVAL);
! 1545: }
! 1546:
! 1547: s = splaudio();
! 1548:
! 1549: if (p->precision == 8) {
! 1550: sc->sc_voc[GUS_VOICE_LEFT].voccntl &= ~GUSMASK_DATA_SIZE16;
! 1551: sc->sc_voc[GUS_VOICE_RIGHT].voccntl &= ~GUSMASK_DATA_SIZE16;
! 1552: } else {
! 1553: sc->sc_voc[GUS_VOICE_LEFT].voccntl |= GUSMASK_DATA_SIZE16;
! 1554: sc->sc_voc[GUS_VOICE_RIGHT].voccntl |= GUSMASK_DATA_SIZE16;
! 1555: }
! 1556:
! 1557: sc->sc_encoding = p->encoding;
! 1558: sc->sc_precision = p->precision;
! 1559: sc->sc_channels = p->channels;
! 1560:
! 1561: splx(s);
! 1562:
! 1563: if (p->sample_rate > gus_max_frequency[sc->sc_voices - GUS_MIN_VOICES])
! 1564: p->sample_rate = gus_max_frequency[sc->sc_voices - GUS_MIN_VOICES];
! 1565: if (setmode & AUMODE_RECORD)
! 1566: sc->sc_irate = p->sample_rate;
! 1567: if (setmode & AUMODE_PLAY)
! 1568: sc->sc_orate = p->sample_rate;
! 1569:
! 1570: switch (p->encoding) {
! 1571: case AUDIO_ENCODING_ULAW:
! 1572: p->sw_code = mulaw_to_ulinear8;
! 1573: r->sw_code = ulinear8_to_mulaw;
! 1574: break;
! 1575: case AUDIO_ENCODING_ALAW:
! 1576: p->sw_code = alaw_to_ulinear8;
! 1577: r->sw_code = ulinear8_to_alaw;
! 1578: break;
! 1579: case AUDIO_ENCODING_ULINEAR_BE:
! 1580: case AUDIO_ENCODING_SLINEAR_BE:
! 1581: r->sw_code = p->sw_code = swap_bytes;
! 1582: break;
! 1583: }
! 1584:
! 1585: return 0;
! 1586: }
! 1587:
! 1588: /*
! 1589: * Interface to the audio layer - set the blocksize to the correct number
! 1590: * of units
! 1591: */
! 1592:
! 1593: int
! 1594: gusmax_round_blocksize(addr, blocksize)
! 1595: void * addr;
! 1596: int blocksize;
! 1597: {
! 1598: struct ad1848_softc *ac = addr;
! 1599: struct gus_softc *sc = ac->parent;
! 1600:
! 1601: /* blocksize = ad1848_round_blocksize(ac, blocksize);*/
! 1602: return gus_round_blocksize(sc, blocksize);
! 1603: }
! 1604:
! 1605: int
! 1606: gus_round_blocksize(addr, blocksize)
! 1607: void * addr;
! 1608: int blocksize;
! 1609: {
! 1610: struct gus_softc *sc = addr;
! 1611:
! 1612: DPRINTF(("gus_round_blocksize called\n"));
! 1613:
! 1614: if ((sc->sc_encoding == AUDIO_ENCODING_ULAW ||
! 1615: sc->sc_encoding == AUDIO_ENCODING_ALAW) && blocksize > 32768)
! 1616: blocksize = 32768;
! 1617: else if (blocksize > 65536)
! 1618: blocksize = 65536;
! 1619:
! 1620: if ((blocksize % GUS_BUFFER_MULTIPLE) != 0)
! 1621: blocksize = (blocksize / GUS_BUFFER_MULTIPLE + 1) *
! 1622: GUS_BUFFER_MULTIPLE;
! 1623:
! 1624: /* set up temporary buffer to hold the deinterleave, if necessary
! 1625: for stereo output */
! 1626: if (sc->sc_deintr_buf) {
! 1627: free(sc->sc_deintr_buf, M_DEVBUF);
! 1628: sc->sc_deintr_buf = NULL;
! 1629: }
! 1630: sc->sc_deintr_buf = malloc(blocksize/2, M_DEVBUF, M_WAITOK);
! 1631:
! 1632: sc->sc_blocksize = blocksize;
! 1633: /* multi-buffering not quite working yet. */
! 1634: sc->sc_nbufs = /*GUS_MEM_FOR_BUFFERS / blocksize*/ 2;
! 1635:
! 1636: gus_set_chan_addrs(sc);
! 1637:
! 1638: return blocksize;
! 1639: }
! 1640:
! 1641: int
! 1642: gus_get_out_gain(addr)
! 1643: caddr_t addr;
! 1644: {
! 1645: struct gus_softc *sc = (struct gus_softc *) addr;
! 1646:
! 1647: DPRINTF(("gus_get_out_gain called\n"));
! 1648: return sc->sc_ogain / 2;
! 1649: }
! 1650:
! 1651: inline void gus_set_voices(sc, voices)
! 1652: struct gus_softc *sc;
! 1653: int voices;
! 1654: {
! 1655: bus_space_tag_t iot = sc->sc_iot;
! 1656: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1657: /*
! 1658: * Select the active number of voices
! 1659: */
! 1660:
! 1661: SELECT_GUS_REG(iot, ioh2, GUSREG_ACTIVE_VOICES);
! 1662: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, (voices-1) | 0xc0);
! 1663:
! 1664: sc->sc_voices = voices;
! 1665: }
! 1666:
! 1667: /*
! 1668: * Actually set the settings of various values on the card
! 1669: */
! 1670:
! 1671: int
! 1672: gusmax_commit_settings(addr)
! 1673: void * addr;
! 1674: {
! 1675: struct ad1848_softc *ac = addr;
! 1676: struct gus_softc *sc = ac->parent;
! 1677: int error;
! 1678:
! 1679: error = ad1848_commit_settings(ac);
! 1680: if (error)
! 1681: return error;
! 1682: return gus_commit_settings(sc);
! 1683: }
! 1684:
! 1685: /*
! 1686: * Commit the settings. Called at normal IPL.
! 1687: */
! 1688: int
! 1689: gus_commit_settings(addr)
! 1690: void * addr;
! 1691: {
! 1692: struct gus_softc *sc = addr;
! 1693: int s;
! 1694:
! 1695: DPRINTF(("gus_commit_settings called (gain = %d)\n",sc->sc_ogain));
! 1696:
! 1697:
! 1698: s = splgus();
! 1699:
! 1700: gus_set_recrate(sc, sc->sc_irate);
! 1701: gus_set_volume(sc, GUS_VOICE_LEFT, sc->sc_ogain);
! 1702: gus_set_volume(sc, GUS_VOICE_RIGHT, sc->sc_ogain);
! 1703: gus_set_samprate(sc, GUS_VOICE_LEFT, sc->sc_orate);
! 1704: gus_set_samprate(sc, GUS_VOICE_RIGHT, sc->sc_orate);
! 1705: splx(s);
! 1706: gus_set_chan_addrs(sc);
! 1707:
! 1708: return 0;
! 1709: }
! 1710:
! 1711: void
! 1712: gus_set_chan_addrs(sc)
! 1713: struct gus_softc *sc;
! 1714: {
! 1715: /*
! 1716: * We use sc_nbufs * blocksize bytes of storage in the on-board GUS
! 1717: * ram.
! 1718: * For mono, each of the sc_nbufs buffers is DMA'd to in one chunk,
! 1719: * and both left & right channels play the same buffer.
! 1720: *
! 1721: * For stereo, each channel gets a contiguous half of the memory,
! 1722: * and each has sc_nbufs buffers of size blocksize/2.
! 1723: * Stereo data are deinterleaved in main memory before the DMA out
! 1724: * routines are called to queue the output.
! 1725: *
! 1726: * The blocksize per channel is kept in sc_chanblocksize.
! 1727: */
! 1728: if (sc->sc_channels == 2)
! 1729: sc->sc_chanblocksize = sc->sc_blocksize/2;
! 1730: else
! 1731: sc->sc_chanblocksize = sc->sc_blocksize;
! 1732:
! 1733: sc->sc_voc[GUS_VOICE_LEFT].start_addr = GUS_MEM_OFFSET - 1;
! 1734: sc->sc_voc[GUS_VOICE_RIGHT].start_addr =
! 1735: (gus_dostereo && sc->sc_channels == 2 ? GUS_LEFT_RIGHT_OFFSET : 0)
! 1736: + GUS_MEM_OFFSET - 1;
! 1737: sc->sc_voc[GUS_VOICE_RIGHT].current_addr =
! 1738: sc->sc_voc[GUS_VOICE_RIGHT].start_addr + 1;
! 1739: sc->sc_voc[GUS_VOICE_RIGHT].end_addr =
! 1740: sc->sc_voc[GUS_VOICE_RIGHT].start_addr +
! 1741: sc->sc_nbufs * sc->sc_chanblocksize;
! 1742:
! 1743: }
! 1744:
! 1745: /*
! 1746: * Set the sample rate of the given voice. Called at splgus().
! 1747: */
! 1748:
! 1749: void
! 1750: gus_set_samprate(sc, voice, freq)
! 1751: struct gus_softc *sc;
! 1752: int voice, freq;
! 1753: {
! 1754: bus_space_tag_t iot = sc->sc_iot;
! 1755: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1756: unsigned int fc;
! 1757: u_long temp, f = (u_long) freq;
! 1758:
! 1759: /*
! 1760: * calculate fc based on the number of active voices;
! 1761: * we need to use longs to preserve enough bits
! 1762: */
! 1763:
! 1764: temp = (u_long) gus_max_frequency[sc->sc_voices-GUS_MIN_VOICES];
! 1765:
! 1766: fc = (unsigned int)(((f << 9L) + (temp >> 1L)) / temp);
! 1767:
! 1768: fc <<= 1;
! 1769:
! 1770:
! 1771: /*
! 1772: * Program the voice frequency, and set it in the voice data record
! 1773: */
! 1774:
! 1775: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1776: SELECT_GUS_REG(iot, ioh2, GUSREG_FREQ_CONTROL);
! 1777: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, fc);
! 1778:
! 1779: sc->sc_voc[voice].rate = freq;
! 1780:
! 1781: }
! 1782:
! 1783: /*
! 1784: * Set the sample rate of the recording frequency. Formula is from the GUS
! 1785: * SDK. Called at splgus().
! 1786: */
! 1787:
! 1788: void
! 1789: gus_set_recrate(sc, rate)
! 1790: struct gus_softc *sc;
! 1791: u_long rate;
! 1792: {
! 1793: bus_space_tag_t iot = sc->sc_iot;
! 1794: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1795: u_char realrate;
! 1796: DPRINTF(("gus_set_recrate %lu\n", rate));
! 1797:
! 1798: #if 0
! 1799: realrate = 9878400/(16*(rate+2)); /* formula from GUS docs */
! 1800: #endif
! 1801: realrate = (9878400 >> 4)/rate - 2; /* formula from code, sigh. */
! 1802:
! 1803: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_FREQ);
! 1804: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, realrate);
! 1805: }
! 1806:
! 1807: /*
! 1808: * Interface to the audio layer - turn the output on or off. Note that some
! 1809: * of these bits are flipped in the register
! 1810: */
! 1811:
! 1812: int
! 1813: gusmax_speaker_ctl(addr, newstate)
! 1814: void * addr;
! 1815: int newstate;
! 1816: {
! 1817: struct ad1848_softc *sc = addr;
! 1818: return gus_speaker_ctl(sc->parent, newstate);
! 1819: }
! 1820:
! 1821: int
! 1822: gus_speaker_ctl(addr, newstate)
! 1823: void * addr;
! 1824: int newstate;
! 1825: {
! 1826: struct gus_softc *sc = (struct gus_softc *) addr;
! 1827: bus_space_tag_t iot = sc->sc_iot;
! 1828: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 1829:
! 1830: /* Line out bit is flipped: 0 enables, 1 disables */
! 1831: if ((newstate == SPKR_ON) &&
! 1832: (sc->sc_mixcontrol & GUSMASK_LINE_OUT)) {
! 1833: sc->sc_mixcontrol &= ~GUSMASK_LINE_OUT;
! 1834: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1835: }
! 1836: if ((newstate == SPKR_OFF) &&
! 1837: (sc->sc_mixcontrol & GUSMASK_LINE_OUT) == 0) {
! 1838: sc->sc_mixcontrol |= GUSMASK_LINE_OUT;
! 1839: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1840: }
! 1841:
! 1842: return 0;
! 1843: }
! 1844:
! 1845: int
! 1846: gus_linein_ctl(addr, newstate)
! 1847: void * addr;
! 1848: int newstate;
! 1849: {
! 1850: struct gus_softc *sc = (struct gus_softc *) addr;
! 1851: bus_space_tag_t iot = sc->sc_iot;
! 1852: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 1853:
! 1854: /* Line in bit is flipped: 0 enables, 1 disables */
! 1855: if ((newstate == SPKR_ON) &&
! 1856: (sc->sc_mixcontrol & GUSMASK_LINE_IN)) {
! 1857: sc->sc_mixcontrol &= ~GUSMASK_LINE_IN;
! 1858: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1859: }
! 1860: if ((newstate == SPKR_OFF) &&
! 1861: (sc->sc_mixcontrol & GUSMASK_LINE_IN) == 0) {
! 1862: sc->sc_mixcontrol |= GUSMASK_LINE_IN;
! 1863: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1864: }
! 1865:
! 1866: return 0;
! 1867: }
! 1868:
! 1869: int
! 1870: gus_mic_ctl(addr, newstate)
! 1871: void * addr;
! 1872: int newstate;
! 1873: {
! 1874: struct gus_softc *sc = (struct gus_softc *) addr;
! 1875: bus_space_tag_t iot = sc->sc_iot;
! 1876: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 1877:
! 1878: /* Mic bit is normal: 1 enables, 0 disables */
! 1879: if ((newstate == SPKR_ON) &&
! 1880: (sc->sc_mixcontrol & GUSMASK_MIC_IN) == 0) {
! 1881: sc->sc_mixcontrol |= GUSMASK_MIC_IN;
! 1882: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1883: }
! 1884: if ((newstate == SPKR_OFF) &&
! 1885: (sc->sc_mixcontrol & GUSMASK_MIC_IN)) {
! 1886: sc->sc_mixcontrol &= ~GUSMASK_MIC_IN;
! 1887: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 1888: }
! 1889:
! 1890: return 0;
! 1891: }
! 1892:
! 1893: /*
! 1894: * Set the end address of a give voice. Called at splgus()
! 1895: */
! 1896:
! 1897: void
! 1898: gus_set_endaddr(sc, voice, addr)
! 1899: struct gus_softc *sc;
! 1900: int voice;
! 1901: u_long addr;
! 1902: {
! 1903: bus_space_tag_t iot = sc->sc_iot;
! 1904: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1905:
! 1906: sc->sc_voc[voice].end_addr = addr;
! 1907:
! 1908: if (sc->sc_voc[voice].voccntl & GUSMASK_DATA_SIZE16)
! 1909: addr = convert_to_16bit(addr);
! 1910:
! 1911: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_HIGH);
! 1912: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_HIGH(addr));
! 1913: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_LOW);
! 1914: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_LOW(addr));
! 1915:
! 1916: }
! 1917:
! 1918: #ifdef GUSPLAYDEBUG
! 1919: /*
! 1920: * Set current address. called at splgus()
! 1921: */
! 1922: void
! 1923: gus_set_curaddr(sc, voice, addr)
! 1924: struct gus_softc *sc;
! 1925: int voice;
! 1926: u_long addr;
! 1927: {
! 1928: bus_space_tag_t iot = sc->sc_iot;
! 1929: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1930:
! 1931: sc->sc_voc[voice].current_addr = addr;
! 1932:
! 1933: if (sc->sc_voc[voice].voccntl & GUSMASK_DATA_SIZE16)
! 1934: addr = convert_to_16bit(addr);
! 1935:
! 1936: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1937:
! 1938: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_HIGH);
! 1939: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_HIGH(addr));
! 1940: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_LOW);
! 1941: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, ADDR_LOW(addr));
! 1942:
! 1943: }
! 1944:
! 1945: /*
! 1946: * Get current GUS playback address. Called at splgus().
! 1947: */
! 1948: u_long
! 1949: gus_get_curaddr(sc, voice)
! 1950: struct gus_softc *sc;
! 1951: int voice;
! 1952: {
! 1953: bus_space_tag_t iot = sc->sc_iot;
! 1954: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 1955: u_long addr;
! 1956:
! 1957: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) voice);
! 1958: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_HIGH|GUSREG_READ);
! 1959: addr = (bus_space_read_2(iot, ioh2, GUS_DATA_LOW) & 0x1fff) << 7;
! 1960: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_LOW|GUSREG_READ);
! 1961: addr |= (bus_space_read_2(iot, ioh2, GUS_DATA_LOW) >> 9L) & 0x7f;
! 1962:
! 1963: if (sc->sc_voc[voice].voccntl & GUSMASK_DATA_SIZE16)
! 1964: addr = (addr & 0xc0000) | ((addr & 0x1ffff) << 1); /* undo 16-bit change */
! 1965: DPRINTF(("gus voice %d curaddr %ld end_addr %ld\n",
! 1966: voice, addr, sc->sc_voc[voice].end_addr));
! 1967: /* XXX sanity check the address? */
! 1968:
! 1969: return(addr);
! 1970: }
! 1971: #endif
! 1972:
! 1973: /*
! 1974: * Convert an address value to a "16 bit" value - why this is necessary I
! 1975: * have NO idea
! 1976: */
! 1977:
! 1978: u_long
! 1979: convert_to_16bit(address)
! 1980: u_long address;
! 1981: {
! 1982: u_long old_address;
! 1983:
! 1984: old_address = address;
! 1985: address >>= 1;
! 1986: address &= 0x0001ffffL;
! 1987: address |= (old_address & 0x000c0000L);
! 1988:
! 1989: return (address);
! 1990: }
! 1991:
! 1992: /*
! 1993: * Write a value into the GUS's DRAM
! 1994: */
! 1995:
! 1996: void
! 1997: guspoke(iot, ioh2, address, value)
! 1998: bus_space_tag_t iot;
! 1999: bus_space_handle_t ioh2;
! 2000: long address;
! 2001: unsigned char value;
! 2002: {
! 2003:
! 2004: /*
! 2005: * Select the DRAM address
! 2006: */
! 2007:
! 2008: SELECT_GUS_REG(iot, ioh2, GUSREG_DRAM_ADDR_LOW);
! 2009: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, (unsigned int) (address & 0xffff));
! 2010: SELECT_GUS_REG(iot, ioh2, GUSREG_DRAM_ADDR_HIGH);
! 2011: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, (unsigned char) ((address >> 16) & 0xff));
! 2012:
! 2013: /*
! 2014: * Actually write the data
! 2015: */
! 2016:
! 2017: bus_space_write_1(iot, ioh2, GUS_DRAM_DATA, value);
! 2018: }
! 2019:
! 2020: /*
! 2021: * Read a value from the GUS's DRAM
! 2022: */
! 2023:
! 2024: unsigned char
! 2025: guspeek(iot, ioh2, address)
! 2026: bus_space_tag_t iot;
! 2027: bus_space_handle_t ioh2;
! 2028: u_long address;
! 2029: {
! 2030:
! 2031: /*
! 2032: * Select the DRAM address
! 2033: */
! 2034:
! 2035: SELECT_GUS_REG(iot, ioh2, GUSREG_DRAM_ADDR_LOW);
! 2036: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, (unsigned int) (address & 0xffff));
! 2037: SELECT_GUS_REG(iot, ioh2, GUSREG_DRAM_ADDR_HIGH);
! 2038: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, (unsigned char) ((address >> 16) & 0xff));
! 2039:
! 2040: /*
! 2041: * Read in the data from the board
! 2042: */
! 2043:
! 2044: return (unsigned char) bus_space_read_1(iot, ioh2, GUS_DRAM_DATA);
! 2045: }
! 2046:
! 2047: /*
! 2048: * Reset the Gravis UltraSound card, completely
! 2049: */
! 2050:
! 2051: void
! 2052: gusreset(sc, voices)
! 2053: struct gus_softc *sc;
! 2054: int voices;
! 2055: {
! 2056: bus_space_tag_t iot = sc->sc_iot;
! 2057: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 2058: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 2059: bus_space_handle_t ioh4 = sc->sc_ioh4;
! 2060: int i,s;
! 2061:
! 2062: s = splgus();
! 2063:
! 2064: /*
! 2065: * Reset the GF1 chip
! 2066: */
! 2067:
! 2068: SELECT_GUS_REG(iot, ioh2, GUSREG_RESET);
! 2069: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 2070:
! 2071: delay(500);
! 2072:
! 2073: /*
! 2074: * Release reset
! 2075: */
! 2076:
! 2077: SELECT_GUS_REG(iot, ioh2, GUSREG_RESET);
! 2078: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, GUSMASK_MASTER_RESET);
! 2079:
! 2080: delay(500);
! 2081:
! 2082: /*
! 2083: * Reset MIDI port as well
! 2084: */
! 2085:
! 2086: bus_space_write_1(iot, ioh4, GUS_MIDI_CONTROL, MIDI_RESET);
! 2087:
! 2088: delay(500);
! 2089:
! 2090: bus_space_write_1(iot, ioh4, GUS_MIDI_CONTROL, 0x00);
! 2091:
! 2092: /*
! 2093: * Clear interrupts
! 2094: */
! 2095:
! 2096: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 2097: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 2098: SELECT_GUS_REG(iot, ioh2, GUSREG_TIMER_CONTROL);
! 2099: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 2100: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 2101: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 2102:
! 2103: gus_set_voices(sc, voices);
! 2104:
! 2105: bus_space_read_1(iot, ioh1, GUS_IRQ_STATUS);
! 2106: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 2107: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2108: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 2109: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2110: SELECT_GUS_REG(iot, ioh2, GUSREG_IRQ_STATUS);
! 2111: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2112:
! 2113: /*
! 2114: * Reset voice specific information
! 2115: */
! 2116:
! 2117: for(i = 0; i < voices; i++) {
! 2118: bus_space_write_1(iot, ioh2, GUS_VOICE_SELECT, (unsigned char) i);
! 2119:
! 2120: SELECT_GUS_REG(iot, ioh2, GUSREG_VOICE_CNTL);
! 2121:
! 2122: sc->sc_voc[i].voccntl = GUSMASK_VOICE_STOPPED |
! 2123: GUSMASK_STOP_VOICE;
! 2124:
! 2125: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[i].voccntl);
! 2126:
! 2127: sc->sc_voc[i].volcntl = GUSMASK_VOLUME_STOPPED |
! 2128: GUSMASK_STOP_VOLUME;
! 2129:
! 2130: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_CONTROL);
! 2131: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, sc->sc_voc[i].volcntl);
! 2132:
! 2133: delay(100);
! 2134:
! 2135: gus_set_samprate(sc, i, 8000);
! 2136: SELECT_GUS_REG(iot, ioh2, GUSREG_START_ADDR_HIGH);
! 2137: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2138: SELECT_GUS_REG(iot, ioh2, GUSREG_START_ADDR_LOW);
! 2139: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2140: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_HIGH);
! 2141: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2142: SELECT_GUS_REG(iot, ioh2, GUSREG_END_ADDR_LOW);
! 2143: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2144: SELECT_GUS_REG(iot, ioh2, GUSREG_VOLUME_RATE);
! 2145: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x01);
! 2146: SELECT_GUS_REG(iot, ioh2, GUSREG_START_VOLUME);
! 2147: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x10);
! 2148: SELECT_GUS_REG(iot, ioh2, GUSREG_END_VOLUME);
! 2149: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0xe0);
! 2150: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_VOLUME);
! 2151: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2152:
! 2153: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_HIGH);
! 2154: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2155: SELECT_GUS_REG(iot, ioh2, GUSREG_CUR_ADDR_LOW);
! 2156: bus_space_write_2(iot, ioh2, GUS_DATA_LOW, 0x0000);
! 2157: SELECT_GUS_REG(iot, ioh2, GUSREG_PAN_POS);
! 2158: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x07);
! 2159: }
! 2160:
! 2161: /*
! 2162: * Clear out any pending IRQs
! 2163: */
! 2164:
! 2165: bus_space_read_1(iot, ioh1, GUS_IRQ_STATUS);
! 2166: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 2167: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2168: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 2169: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2170: SELECT_GUS_REG(iot, ioh2, GUSREG_IRQ_STATUS);
! 2171: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH);
! 2172:
! 2173: SELECT_GUS_REG(iot, ioh2, GUSREG_RESET);
! 2174: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, GUSMASK_MASTER_RESET | GUSMASK_DAC_ENABLE |
! 2175: GUSMASK_IRQ_ENABLE);
! 2176:
! 2177: splx(s);
! 2178: }
! 2179:
! 2180:
! 2181: int
! 2182: gus_init_cs4231(sc)
! 2183: struct gus_softc *sc;
! 2184: {
! 2185: bus_space_tag_t iot = sc->sc_iot;
! 2186: bus_space_handle_t ioh1 = sc->sc_ioh1;
! 2187: int port = sc->sc_iobase;
! 2188: u_char ctrl;
! 2189:
! 2190: ctrl = (port & 0xf0) >> 4; /* set port address middle nibble */
! 2191: /*
! 2192: * The codec is a bit weird--swapped dma channels.
! 2193: */
! 2194: ctrl |= GUS_MAX_CODEC_ENABLE;
! 2195: if (sc->sc_drq >= 4)
! 2196: ctrl |= GUS_MAX_RECCHAN16;
! 2197: if (sc->sc_recdrq >= 4)
! 2198: ctrl |= GUS_MAX_PLAYCHAN16;
! 2199:
! 2200: bus_space_write_1(iot, ioh1, GUS_MAX_CTRL, ctrl);
! 2201:
! 2202: sc->sc_codec.sc_iot = sc->sc_iot;
! 2203: sc->sc_codec.sc_iobase = port+GUS_MAX_CODEC_BASE;
! 2204:
! 2205: if (ad1848_mapprobe(&sc->sc_codec, sc->sc_codec.sc_iobase) == 0) {
! 2206: sc->sc_flags &= ~GUS_CODEC_INSTALLED;
! 2207: return (0);
! 2208: } else {
! 2209: struct ad1848_volume vol = {AUDIO_MAX_GAIN, AUDIO_MAX_GAIN};
! 2210: sc->sc_flags |= GUS_CODEC_INSTALLED;
! 2211: sc->sc_codec.parent = sc;
! 2212: sc->sc_codec.sc_drq = sc->sc_recdrq;
! 2213: sc->sc_codec.sc_recdrq = sc->sc_drq;
! 2214: gus_hw_if = gusmax_hw_if;
! 2215: /* enable line in and mic in the GUS mixer; the codec chip
! 2216: will do the real mixing for them. */
! 2217: sc->sc_mixcontrol &= ~GUSMASK_LINE_IN; /* 0 enables. */
! 2218: sc->sc_mixcontrol |= GUSMASK_MIC_IN; /* 1 enables. */
! 2219: bus_space_write_1(iot, ioh1, GUS_MIX_CONTROL, sc->sc_mixcontrol);
! 2220:
! 2221: ad1848_attach(&sc->sc_codec);
! 2222: /* turn on pre-MUX microphone gain. */
! 2223: ad1848_set_mic_gain(&sc->sc_codec, &vol);
! 2224:
! 2225: return (1);
! 2226: }
! 2227: }
! 2228:
! 2229:
! 2230: /*
! 2231: * Return info about the audio device, for the AUDIO_GETINFO ioctl
! 2232: */
! 2233:
! 2234: int
! 2235: gus_getdev(addr, dev)
! 2236: void * addr;
! 2237: struct audio_device *dev;
! 2238: {
! 2239: *dev = gus_device;
! 2240: return 0;
! 2241: }
! 2242:
! 2243: /*
! 2244: * stubs (XXX)
! 2245: */
! 2246:
! 2247: int
! 2248: gus_set_in_gain(addr, gain, balance)
! 2249: caddr_t addr;
! 2250: u_int gain;
! 2251: u_char balance;
! 2252: {
! 2253: DPRINTF(("gus_set_in_gain called\n"));
! 2254: return 0;
! 2255: }
! 2256:
! 2257: int
! 2258: gus_get_in_gain(addr)
! 2259: caddr_t addr;
! 2260: {
! 2261: DPRINTF(("gus_get_in_gain called\n"));
! 2262: return 0;
! 2263: }
! 2264:
! 2265: int
! 2266: gusmax_dma_input(addr, buf, size, callback, arg)
! 2267: void * addr;
! 2268: void *buf;
! 2269: int size;
! 2270: void (*callback)(void *);
! 2271: void *arg;
! 2272: {
! 2273: struct ad1848_softc *sc = addr;
! 2274: return gus_dma_input(sc->parent, buf, size, callback, arg);
! 2275: }
! 2276:
! 2277: /*
! 2278: * Start sampling the input source into the requested DMA buffer.
! 2279: * Called at splgus(), either from top-half or from interrupt handler.
! 2280: */
! 2281: int
! 2282: gus_dma_input(addr, buf, size, callback, arg)
! 2283: void * addr;
! 2284: void *buf;
! 2285: int size;
! 2286: void (*callback)(void *);
! 2287: void *arg;
! 2288: {
! 2289: struct gus_softc *sc = addr;
! 2290: bus_space_tag_t iot = sc->sc_iot;
! 2291: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 2292: u_char dmac;
! 2293: DMAPRINTF(("gus_dma_input called\n"));
! 2294:
! 2295: /*
! 2296: * Sample SIZE bytes of data from the card, into buffer at BUF.
! 2297: */
! 2298:
! 2299: if (sc->sc_precision == 16)
! 2300: return EINVAL; /* XXX */
! 2301:
! 2302: /* set DMA modes */
! 2303: dmac = GUSMASK_SAMPLE_IRQ|GUSMASK_SAMPLE_START;
! 2304: if (sc->sc_recdrq >= 4)
! 2305: dmac |= GUSMASK_SAMPLE_DATA16;
! 2306: if (sc->sc_encoding == AUDIO_ENCODING_ULAW ||
! 2307: sc->sc_encoding == AUDIO_ENCODING_ALAW ||
! 2308: sc->sc_encoding == AUDIO_ENCODING_ULINEAR_LE ||
! 2309: sc->sc_encoding == AUDIO_ENCODING_ULINEAR_BE)
! 2310: dmac |= GUSMASK_SAMPLE_INVBIT;
! 2311: if (sc->sc_channels == 2)
! 2312: dmac |= GUSMASK_SAMPLE_STEREO;
! 2313: isa_dmastart(sc->sc_dev.dv_parent, sc->sc_recdrq, buf, size,
! 2314: NULL, DMAMODE_READ, BUS_DMA_NOWAIT);
! 2315:
! 2316: DMAPRINTF(("gus_dma_input isadma_started\n"));
! 2317: sc->sc_flags |= GUS_DMAIN_ACTIVE;
! 2318: sc->sc_dmainintr = callback;
! 2319: sc->sc_inarg = arg;
! 2320: sc->sc_dmaincnt = size;
! 2321: sc->sc_dmainaddr = buf;
! 2322:
! 2323: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 2324: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, dmac); /* Go! */
! 2325:
! 2326:
! 2327: DMAPRINTF(("gus_dma_input returning\n"));
! 2328:
! 2329: return 0;
! 2330: }
! 2331:
! 2332: int
! 2333: gus_dmain_intr(sc)
! 2334: struct gus_softc *sc;
! 2335: {
! 2336: void (*callback)(void *);
! 2337: void *arg;
! 2338:
! 2339: DMAPRINTF(("gus_dmain_intr called\n"));
! 2340: if (sc->sc_dmainintr) {
! 2341: isa_dmadone(sc->sc_dev.dv_parent, sc->sc_recdrq);
! 2342: callback = sc->sc_dmainintr;
! 2343: arg = sc->sc_inarg;
! 2344:
! 2345: sc->sc_dmainaddr = 0;
! 2346: sc->sc_dmaincnt = 0;
! 2347: sc->sc_dmainintr = 0;
! 2348: sc->sc_inarg = 0;
! 2349:
! 2350: sc->sc_flags &= ~GUS_DMAIN_ACTIVE;
! 2351: DMAPRINTF(("calling dmain_intr callback %p(%p)\n", callback, arg));
! 2352: (*callback)(arg);
! 2353: return 1;
! 2354: } else {
! 2355: DMAPRINTF(("gus_dmain_intr false?\n"));
! 2356: return 0; /* XXX ??? */
! 2357: }
! 2358: }
! 2359:
! 2360: int
! 2361: gusmax_halt_out_dma(addr)
! 2362: void * addr;
! 2363: {
! 2364: struct ad1848_softc *sc = addr;
! 2365: return gus_halt_out_dma(sc->parent);
! 2366: }
! 2367:
! 2368:
! 2369: int
! 2370: gusmax_halt_in_dma(addr)
! 2371: void * addr;
! 2372: {
! 2373: struct ad1848_softc *sc = addr;
! 2374: return gus_halt_in_dma(sc->parent);
! 2375: }
! 2376:
! 2377: /*
! 2378: * Stop any DMA output. Called at splgus().
! 2379: */
! 2380: int
! 2381: gus_halt_out_dma(addr)
! 2382: void * addr;
! 2383: {
! 2384: struct gus_softc *sc = addr;
! 2385: bus_space_tag_t iot = sc->sc_iot;
! 2386: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 2387:
! 2388: DMAPRINTF(("gus_halt_out_dma called\n"));
! 2389: /*
! 2390: * Make sure the GUS _isn't_ setup for DMA
! 2391: */
! 2392:
! 2393: SELECT_GUS_REG(iot, ioh2, GUSREG_DMA_CONTROL);
! 2394: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0);
! 2395:
! 2396: timeout_del(&sc->sc_dma_tmo);
! 2397: isa_dmaabort(sc->sc_dev.dv_parent, sc->sc_drq);
! 2398: sc->sc_flags &= ~(GUS_DMAOUT_ACTIVE|GUS_LOCKED);
! 2399: sc->sc_dmaoutintr = 0;
! 2400: sc->sc_outarg = 0;
! 2401: sc->sc_dmaoutaddr = 0;
! 2402: sc->sc_dmaoutcnt = 0;
! 2403: sc->sc_dmabuf = 0;
! 2404: sc->sc_bufcnt = 0;
! 2405: sc->sc_playbuf = -1;
! 2406: /* also stop playing */
! 2407: gus_stop_voice(sc, GUS_VOICE_LEFT, 1);
! 2408: gus_stop_voice(sc, GUS_VOICE_RIGHT, 0);
! 2409:
! 2410: return 0;
! 2411: }
! 2412:
! 2413: /*
! 2414: * Stop any DMA output. Called at splgus().
! 2415: */
! 2416: int
! 2417: gus_halt_in_dma(addr)
! 2418: void * addr;
! 2419: {
! 2420: struct gus_softc *sc = addr;
! 2421: bus_space_tag_t iot = sc->sc_iot;
! 2422: bus_space_handle_t ioh2 = sc->sc_ioh2;
! 2423: DMAPRINTF(("gus_halt_in_dma called\n"));
! 2424:
! 2425: /*
! 2426: * Make sure the GUS _isn't_ setup for DMA
! 2427: */
! 2428:
! 2429: SELECT_GUS_REG(iot, ioh2, GUSREG_SAMPLE_CONTROL);
! 2430: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH,
! 2431: bus_space_read_1(iot, ioh2, GUS_DATA_HIGH) & ~(GUSMASK_SAMPLE_START|GUSMASK_SAMPLE_IRQ));
! 2432:
! 2433: isa_dmaabort(sc->sc_dev.dv_parent, sc->sc_recdrq);
! 2434: sc->sc_flags &= ~GUS_DMAIN_ACTIVE;
! 2435: sc->sc_dmainintr = 0;
! 2436: sc->sc_inarg = 0;
! 2437: sc->sc_dmainaddr = 0;
! 2438: sc->sc_dmaincnt = 0;
! 2439:
! 2440: return 0;
! 2441: }
! 2442:
! 2443:
! 2444: ad1848_devmap_t gusmapping[] = {
! 2445: {GUSMAX_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL},
! 2446: {GUSMAX_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL},
! 2447: {GUSMAX_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL},
! 2448: {GUSMAX_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL},
! 2449: {GUSMAX_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL},
! 2450: {GUSMAX_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL},
! 2451: {GUSMAX_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL},
! 2452: {GUSMAX_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL},
! 2453: {GUSMAX_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL},
! 2454: {GUSMAX_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL},
! 2455: {GUSMAX_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL},
! 2456: {GUSMAX_REC_LVL, AD1848_KIND_RECORDGAIN, -1},
! 2457: {GUSMAX_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1}
! 2458: };
! 2459:
! 2460: int nummap = sizeof(gusmapping) / sizeof(gusmapping[0]);
! 2461:
! 2462: int
! 2463: gusmax_mixer_get_port(addr, cp)
! 2464: void *addr;
! 2465: mixer_ctrl_t *cp;
! 2466: {
! 2467: struct ad1848_softc *ac = addr;
! 2468: struct gus_softc *sc = ac->parent;
! 2469: struct ad1848_volume vol;
! 2470: int error = ad1848_mixer_get_port(ac, gusmapping, nummap, cp);
! 2471:
! 2472: if (error != ENXIO)
! 2473: return (error);
! 2474:
! 2475: error = EINVAL;
! 2476:
! 2477: switch (cp->dev) {
! 2478: case GUSMAX_SPEAKER_LVL: /* fake speaker for mute naming */
! 2479: if (cp->type == AUDIO_MIXER_VALUE) {
! 2480: if (sc->sc_mixcontrol & GUSMASK_LINE_OUT)
! 2481: vol.left = vol.right = AUDIO_MAX_GAIN;
! 2482: else
! 2483: vol.left = vol.right = AUDIO_MIN_GAIN;
! 2484: error = 0;
! 2485: ad1848_from_vol(cp, &vol);
! 2486: }
! 2487: break;
! 2488:
! 2489: case GUSMAX_SPEAKER_MUTE:
! 2490: if (cp->type == AUDIO_MIXER_ENUM) {
! 2491: cp->un.ord = sc->sc_mixcontrol & GUSMASK_LINE_OUT ? 1 : 0;
! 2492: error = 0;
! 2493: }
! 2494: break;
! 2495: default:
! 2496: error = ENXIO;
! 2497: break;
! 2498: }
! 2499:
! 2500: return(error);
! 2501: }
! 2502:
! 2503: int
! 2504: gus_mixer_get_port(addr, cp)
! 2505: void *addr;
! 2506: mixer_ctrl_t *cp;
! 2507: {
! 2508: struct gus_softc *sc = addr;
! 2509: struct ics2101_softc *ic = &sc->sc_mixer;
! 2510: struct ad1848_volume vol;
! 2511: int error = EINVAL;
! 2512:
! 2513: DPRINTF(("gus_mixer_get_port: dev=%d type=%d\n", cp->dev, cp->type));
! 2514:
! 2515: if (!HAS_MIXER(sc) && cp->dev > GUSICS_MASTER_MUTE)
! 2516: return ENXIO;
! 2517:
! 2518: switch (cp->dev) {
! 2519:
! 2520: case GUSICS_MIC_IN_MUTE: /* Microphone */
! 2521: if (cp->type == AUDIO_MIXER_ENUM) {
! 2522: if (HAS_MIXER(sc))
! 2523: cp->un.ord = ic->sc_mute[GUSMIX_CHAN_MIC][ICSMIX_LEFT];
! 2524: else
! 2525: cp->un.ord =
! 2526: sc->sc_mixcontrol & GUSMASK_MIC_IN ? 0 : 1;
! 2527: error = 0;
! 2528: }
! 2529: break;
! 2530:
! 2531: case GUSICS_LINE_IN_MUTE:
! 2532: if (cp->type == AUDIO_MIXER_ENUM) {
! 2533: if (HAS_MIXER(sc))
! 2534: cp->un.ord = ic->sc_mute[GUSMIX_CHAN_LINE][ICSMIX_LEFT];
! 2535: else
! 2536: cp->un.ord =
! 2537: sc->sc_mixcontrol & GUSMASK_LINE_IN ? 1 : 0;
! 2538: error = 0;
! 2539: }
! 2540: break;
! 2541:
! 2542: case GUSICS_MASTER_MUTE:
! 2543: if (cp->type == AUDIO_MIXER_ENUM) {
! 2544: if (HAS_MIXER(sc))
! 2545: cp->un.ord = ic->sc_mute[GUSMIX_CHAN_MASTER][ICSMIX_LEFT];
! 2546: else
! 2547: cp->un.ord =
! 2548: sc->sc_mixcontrol & GUSMASK_LINE_OUT ? 1 : 0;
! 2549: error = 0;
! 2550: }
! 2551: break;
! 2552:
! 2553: case GUSICS_DAC_MUTE:
! 2554: if (cp->type == AUDIO_MIXER_ENUM) {
! 2555: cp->un.ord = ic->sc_mute[GUSMIX_CHAN_DAC][ICSMIX_LEFT];
! 2556: error = 0;
! 2557: }
! 2558: break;
! 2559:
! 2560: case GUSICS_CD_MUTE:
! 2561: if (cp->type == AUDIO_MIXER_ENUM) {
! 2562: cp->un.ord = ic->sc_mute[GUSMIX_CHAN_CD][ICSMIX_LEFT];
! 2563: error = 0;
! 2564: }
! 2565: break;
! 2566:
! 2567: case GUSICS_MASTER_LVL:
! 2568: if (cp->type == AUDIO_MIXER_VALUE) {
! 2569: vol.left = ic->sc_setting[GUSMIX_CHAN_MASTER][ICSMIX_LEFT];
! 2570: vol.right = ic->sc_setting[GUSMIX_CHAN_MASTER][ICSMIX_RIGHT];
! 2571: if (ad1848_from_vol(cp, &vol))
! 2572: error = 0;
! 2573: }
! 2574: break;
! 2575:
! 2576: case GUSICS_MIC_IN_LVL: /* Microphone */
! 2577: if (cp->type == AUDIO_MIXER_VALUE) {
! 2578: vol.left = ic->sc_setting[GUSMIX_CHAN_MIC][ICSMIX_LEFT];
! 2579: vol.right = ic->sc_setting[GUSMIX_CHAN_MIC][ICSMIX_RIGHT];
! 2580: if (ad1848_from_vol(cp, &vol))
! 2581: error = 0;
! 2582: }
! 2583: break;
! 2584:
! 2585: case GUSICS_LINE_IN_LVL: /* line in */
! 2586: if (cp->type == AUDIO_MIXER_VALUE) {
! 2587: vol.left = ic->sc_setting[GUSMIX_CHAN_LINE][ICSMIX_LEFT];
! 2588: vol.right = ic->sc_setting[GUSMIX_CHAN_LINE][ICSMIX_RIGHT];
! 2589: if (ad1848_from_vol(cp, &vol))
! 2590: error = 0;
! 2591: }
! 2592: break;
! 2593:
! 2594:
! 2595: case GUSICS_CD_LVL:
! 2596: if (cp->type == AUDIO_MIXER_VALUE) {
! 2597: vol.left = ic->sc_setting[GUSMIX_CHAN_CD][ICSMIX_LEFT];
! 2598: vol.right = ic->sc_setting[GUSMIX_CHAN_CD][ICSMIX_RIGHT];
! 2599: if (ad1848_from_vol(cp, &vol))
! 2600: error = 0;
! 2601: }
! 2602: break;
! 2603:
! 2604: case GUSICS_DAC_LVL: /* dac out */
! 2605: if (cp->type == AUDIO_MIXER_VALUE) {
! 2606: vol.left = ic->sc_setting[GUSMIX_CHAN_DAC][ICSMIX_LEFT];
! 2607: vol.right = ic->sc_setting[GUSMIX_CHAN_DAC][ICSMIX_RIGHT];
! 2608: if (ad1848_from_vol(cp, &vol))
! 2609: error = 0;
! 2610: }
! 2611: break;
! 2612:
! 2613:
! 2614: case GUSICS_RECORD_SOURCE:
! 2615: if (cp->type == AUDIO_MIXER_ENUM) {
! 2616: /* Can't set anything else useful, sigh. */
! 2617: cp->un.ord = 0;
! 2618: }
! 2619: break;
! 2620:
! 2621: default:
! 2622: return ENXIO;
! 2623: /*NOTREACHED*/
! 2624: }
! 2625: return error;
! 2626: }
! 2627:
! 2628: void
! 2629: gusics_master_mute(ic, mute)
! 2630: struct ics2101_softc *ic;
! 2631: int mute;
! 2632: {
! 2633: ics2101_mix_mute(ic, GUSMIX_CHAN_MASTER, ICSMIX_LEFT, mute);
! 2634: ics2101_mix_mute(ic, GUSMIX_CHAN_MASTER, ICSMIX_RIGHT, mute);
! 2635: }
! 2636:
! 2637: void
! 2638: gusics_mic_mute(ic, mute)
! 2639: struct ics2101_softc *ic;
! 2640: int mute;
! 2641: {
! 2642: ics2101_mix_mute(ic, GUSMIX_CHAN_MIC, ICSMIX_LEFT, mute);
! 2643: ics2101_mix_mute(ic, GUSMIX_CHAN_MIC, ICSMIX_RIGHT, mute);
! 2644: }
! 2645:
! 2646: void
! 2647: gusics_linein_mute(ic, mute)
! 2648: struct ics2101_softc *ic;
! 2649: int mute;
! 2650: {
! 2651: ics2101_mix_mute(ic, GUSMIX_CHAN_LINE, ICSMIX_LEFT, mute);
! 2652: ics2101_mix_mute(ic, GUSMIX_CHAN_LINE, ICSMIX_RIGHT, mute);
! 2653: }
! 2654:
! 2655: void
! 2656: gusics_cd_mute(ic, mute)
! 2657: struct ics2101_softc *ic;
! 2658: int mute;
! 2659: {
! 2660: ics2101_mix_mute(ic, GUSMIX_CHAN_CD, ICSMIX_LEFT, mute);
! 2661: ics2101_mix_mute(ic, GUSMIX_CHAN_CD, ICSMIX_RIGHT, mute);
! 2662: }
! 2663:
! 2664: void
! 2665: gusics_dac_mute(ic, mute)
! 2666: struct ics2101_softc *ic;
! 2667: int mute;
! 2668: {
! 2669: ics2101_mix_mute(ic, GUSMIX_CHAN_DAC, ICSMIX_LEFT, mute);
! 2670: ics2101_mix_mute(ic, GUSMIX_CHAN_DAC, ICSMIX_RIGHT, mute);
! 2671: }
! 2672:
! 2673: int
! 2674: gusmax_mixer_set_port(addr, cp)
! 2675: void *addr;
! 2676: mixer_ctrl_t *cp;
! 2677: {
! 2678: struct ad1848_softc *ac = addr;
! 2679: struct gus_softc *sc = ac->parent;
! 2680: struct ad1848_volume vol;
! 2681: int error = ad1848_mixer_set_port(ac, gusmapping, nummap, cp);
! 2682:
! 2683: if (error != ENXIO)
! 2684: return (error);
! 2685:
! 2686: DPRINTF(("gusmax_mixer_set_port: dev=%d type=%d\n", cp->dev, cp->type));
! 2687:
! 2688: switch (cp->dev) {
! 2689: case GUSMAX_SPEAKER_LVL:
! 2690: if (cp->type == AUDIO_MIXER_VALUE &&
! 2691: cp->un.value.num_channels == 1) {
! 2692: if (ad1848_to_vol(cp, &vol)) {
! 2693: gus_speaker_ctl(sc, vol.left > AUDIO_MIN_GAIN ?
! 2694: SPKR_ON : SPKR_OFF);
! 2695: error = 0;
! 2696: }
! 2697: }
! 2698: break;
! 2699:
! 2700: case GUSMAX_SPEAKER_MUTE:
! 2701: if (cp->type == AUDIO_MIXER_ENUM) {
! 2702: gus_speaker_ctl(sc, cp->un.ord ? SPKR_OFF : SPKR_ON);
! 2703: error = 0;
! 2704: }
! 2705: break;
! 2706:
! 2707: default:
! 2708: return ENXIO;
! 2709: /*NOTREACHED*/
! 2710: }
! 2711: return error;
! 2712: }
! 2713:
! 2714: int
! 2715: gus_mixer_set_port(addr, cp)
! 2716: void *addr;
! 2717: mixer_ctrl_t *cp;
! 2718: {
! 2719: struct gus_softc *sc = addr;
! 2720: struct ics2101_softc *ic = &sc->sc_mixer;
! 2721: struct ad1848_volume vol;
! 2722: int error = EINVAL;
! 2723:
! 2724: DPRINTF(("gus_mixer_set_port: dev=%d type=%d\n", cp->dev, cp->type));
! 2725:
! 2726: if (!HAS_MIXER(sc) && cp->dev > GUSICS_MASTER_MUTE)
! 2727: return ENXIO;
! 2728:
! 2729: switch (cp->dev) {
! 2730:
! 2731: case GUSICS_MIC_IN_MUTE: /* Microphone */
! 2732: if (cp->type == AUDIO_MIXER_ENUM) {
! 2733: DPRINTF(("mic mute %d\n", cp->un.ord));
! 2734: if (HAS_MIXER(sc)) {
! 2735: gusics_mic_mute(ic, cp->un.ord);
! 2736: }
! 2737: gus_mic_ctl(sc, cp->un.ord ? SPKR_OFF : SPKR_ON);
! 2738: error = 0;
! 2739: }
! 2740: break;
! 2741:
! 2742: case GUSICS_LINE_IN_MUTE:
! 2743: if (cp->type == AUDIO_MIXER_ENUM) {
! 2744: DPRINTF(("linein mute %d\n", cp->un.ord));
! 2745: if (HAS_MIXER(sc)) {
! 2746: gusics_linein_mute(ic, cp->un.ord);
! 2747: }
! 2748: gus_linein_ctl(sc, cp->un.ord ? SPKR_OFF : SPKR_ON);
! 2749: error = 0;
! 2750: }
! 2751: break;
! 2752:
! 2753: case GUSICS_MASTER_MUTE:
! 2754: if (cp->type == AUDIO_MIXER_ENUM) {
! 2755: DPRINTF(("master mute %d\n", cp->un.ord));
! 2756: if (HAS_MIXER(sc)) {
! 2757: gusics_master_mute(ic, cp->un.ord);
! 2758: }
! 2759: gus_speaker_ctl(sc, cp->un.ord ? SPKR_OFF : SPKR_ON);
! 2760: error = 0;
! 2761: }
! 2762: break;
! 2763:
! 2764: case GUSICS_DAC_MUTE:
! 2765: if (cp->type == AUDIO_MIXER_ENUM) {
! 2766: gusics_dac_mute(ic, cp->un.ord);
! 2767: error = 0;
! 2768: }
! 2769: break;
! 2770:
! 2771: case GUSICS_CD_MUTE:
! 2772: if (cp->type == AUDIO_MIXER_ENUM) {
! 2773: gusics_cd_mute(ic, cp->un.ord);
! 2774: error = 0;
! 2775: }
! 2776: break;
! 2777:
! 2778: case GUSICS_MASTER_LVL:
! 2779: if (cp->type == AUDIO_MIXER_VALUE) {
! 2780: if (ad1848_to_vol(cp, &vol)) {
! 2781: ics2101_mix_attenuate(ic,
! 2782: GUSMIX_CHAN_MASTER,
! 2783: ICSMIX_LEFT,
! 2784: vol.left);
! 2785: ics2101_mix_attenuate(ic,
! 2786: GUSMIX_CHAN_MASTER,
! 2787: ICSMIX_RIGHT,
! 2788: vol.right);
! 2789: error = 0;
! 2790: }
! 2791: }
! 2792: break;
! 2793:
! 2794: case GUSICS_MIC_IN_LVL: /* Microphone */
! 2795: if (cp->type == AUDIO_MIXER_VALUE) {
! 2796: if (ad1848_to_vol(cp, &vol)) {
! 2797: ics2101_mix_attenuate(ic,
! 2798: GUSMIX_CHAN_MIC,
! 2799: ICSMIX_LEFT,
! 2800: vol.left);
! 2801: ics2101_mix_attenuate(ic,
! 2802: GUSMIX_CHAN_MIC,
! 2803: ICSMIX_RIGHT,
! 2804: vol.right);
! 2805: error = 0;
! 2806: }
! 2807: }
! 2808: break;
! 2809:
! 2810: case GUSICS_LINE_IN_LVL: /* line in */
! 2811: if (cp->type == AUDIO_MIXER_VALUE) {
! 2812: if (ad1848_to_vol(cp, &vol)) {
! 2813: ics2101_mix_attenuate(ic,
! 2814: GUSMIX_CHAN_LINE,
! 2815: ICSMIX_LEFT,
! 2816: vol.left);
! 2817: ics2101_mix_attenuate(ic,
! 2818: GUSMIX_CHAN_LINE,
! 2819: ICSMIX_RIGHT,
! 2820: vol.right);
! 2821: error = 0;
! 2822: }
! 2823: }
! 2824: break;
! 2825:
! 2826:
! 2827: case GUSICS_CD_LVL:
! 2828: if (cp->type == AUDIO_MIXER_VALUE) {
! 2829: if (ad1848_to_vol(cp, &vol)) {
! 2830: ics2101_mix_attenuate(ic,
! 2831: GUSMIX_CHAN_CD,
! 2832: ICSMIX_LEFT,
! 2833: vol.left);
! 2834: ics2101_mix_attenuate(ic,
! 2835: GUSMIX_CHAN_CD,
! 2836: ICSMIX_RIGHT,
! 2837: vol.right);
! 2838: error = 0;
! 2839: }
! 2840: }
! 2841: break;
! 2842:
! 2843: case GUSICS_DAC_LVL: /* dac out */
! 2844: if (cp->type == AUDIO_MIXER_VALUE) {
! 2845: if (ad1848_to_vol(cp, &vol)) {
! 2846: ics2101_mix_attenuate(ic,
! 2847: GUSMIX_CHAN_DAC,
! 2848: ICSMIX_LEFT,
! 2849: vol.left);
! 2850: ics2101_mix_attenuate(ic,
! 2851: GUSMIX_CHAN_DAC,
! 2852: ICSMIX_RIGHT,
! 2853: vol.right);
! 2854: error = 0;
! 2855: }
! 2856: }
! 2857: break;
! 2858:
! 2859:
! 2860: case GUSICS_RECORD_SOURCE:
! 2861: if (cp->type == AUDIO_MIXER_ENUM && cp->un.ord == 0) {
! 2862: /* Can't set anything else useful, sigh. */
! 2863: error = 0;
! 2864: }
! 2865: break;
! 2866:
! 2867: default:
! 2868: return ENXIO;
! 2869: /*NOTREACHED*/
! 2870: }
! 2871: return error;
! 2872: }
! 2873:
! 2874: int
! 2875: gus_get_props(addr)
! 2876: void *addr;
! 2877: {
! 2878: struct gus_softc *sc = addr;
! 2879: return AUDIO_PROP_MMAP |
! 2880: (sc->sc_recdrq == sc->sc_drq ? 0 : AUDIO_PROP_FULLDUPLEX);
! 2881: }
! 2882:
! 2883: int
! 2884: gusmax_get_props(addr)
! 2885: void *addr;
! 2886: {
! 2887: struct ad1848_softc *ac = addr;
! 2888: return gus_get_props(ac->parent);
! 2889: }
! 2890:
! 2891: int
! 2892: gusmax_mixer_query_devinfo(addr, dip)
! 2893: void *addr;
! 2894: mixer_devinfo_t *dip;
! 2895: {
! 2896: DPRINTF(("gusmax_query_devinfo: index=%d\n", dip->index));
! 2897:
! 2898: switch(dip->index) {
! 2899: #if 0
! 2900: case GUSMAX_MIC_IN_LVL: /* Microphone */
! 2901: dip->type = AUDIO_MIXER_VALUE;
! 2902: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2903: dip->prev = AUDIO_MIXER_LAST;
! 2904: dip->next = GUSMAX_MIC_IN_MUTE;
! 2905: strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
! 2906: dip->un.v.num_channels = 2;
! 2907: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2908: sizeof dip->un.v.units.name);
! 2909: break;
! 2910: #endif
! 2911:
! 2912: case GUSMAX_MONO_LVL: /* mono/microphone mixer */
! 2913: dip->type = AUDIO_MIXER_VALUE;
! 2914: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2915: dip->prev = AUDIO_MIXER_LAST;
! 2916: dip->next = GUSMAX_MONO_MUTE;
! 2917: strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
! 2918: dip->un.v.num_channels = 1;
! 2919: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2920: sizeof dip->un.v.units.name);
! 2921: break;
! 2922:
! 2923: case GUSMAX_DAC_LVL: /* dacout */
! 2924: dip->type = AUDIO_MIXER_VALUE;
! 2925: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2926: dip->prev = AUDIO_MIXER_LAST;
! 2927: dip->next = GUSMAX_DAC_MUTE;
! 2928: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
! 2929: dip->un.v.num_channels = 2;
! 2930: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2931: sizeof dip->un.v.units.name);
! 2932: break;
! 2933:
! 2934: case GUSMAX_LINE_IN_LVL: /* line */
! 2935: dip->type = AUDIO_MIXER_VALUE;
! 2936: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2937: dip->prev = AUDIO_MIXER_LAST;
! 2938: dip->next = GUSMAX_LINE_IN_MUTE;
! 2939: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
! 2940: dip->un.v.num_channels = 2;
! 2941: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2942: sizeof dip->un.v.units.name);
! 2943: break;
! 2944:
! 2945: case GUSMAX_CD_LVL: /* cd */
! 2946: dip->type = AUDIO_MIXER_VALUE;
! 2947: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2948: dip->prev = AUDIO_MIXER_LAST;
! 2949: dip->next = GUSMAX_CD_MUTE;
! 2950: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
! 2951: dip->un.v.num_channels = 2;
! 2952: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2953: sizeof dip->un.v.units.name);
! 2954: break;
! 2955:
! 2956:
! 2957: case GUSMAX_MONITOR_LVL: /* monitor level */
! 2958: dip->type = AUDIO_MIXER_VALUE;
! 2959: dip->mixer_class = GUSMAX_MONITOR_CLASS;
! 2960: dip->next = GUSMAX_MONITOR_MUTE;
! 2961: dip->prev = AUDIO_MIXER_LAST;
! 2962: strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
! 2963: dip->un.v.num_channels = 1;
! 2964: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2965: sizeof dip->un.v.units.name);
! 2966: break;
! 2967:
! 2968: case GUSMAX_OUT_LVL: /* cs4231 output volume: not useful? */
! 2969: dip->type = AUDIO_MIXER_VALUE;
! 2970: dip->mixer_class = GUSMAX_MONITOR_CLASS;
! 2971: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 2972: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 2973: dip->un.v.num_channels = 2;
! 2974: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2975: sizeof dip->un.v.units.name);
! 2976: break;
! 2977:
! 2978: case GUSMAX_SPEAKER_LVL: /* fake speaker volume */
! 2979: dip->type = AUDIO_MIXER_VALUE;
! 2980: dip->mixer_class = GUSMAX_MONITOR_CLASS;
! 2981: dip->prev = AUDIO_MIXER_LAST;
! 2982: dip->next = GUSMAX_SPEAKER_MUTE;
! 2983: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
! 2984: dip->un.v.num_channels = 2;
! 2985: strlcpy(dip->un.v.units.name, AudioNvolume,
! 2986: sizeof dip->un.v.units.name);
! 2987: break;
! 2988:
! 2989: case GUSMAX_LINE_IN_MUTE:
! 2990: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2991: dip->type = AUDIO_MIXER_ENUM;
! 2992: dip->prev = GUSMAX_LINE_IN_LVL;
! 2993: dip->next = AUDIO_MIXER_LAST;
! 2994: goto mute;
! 2995:
! 2996: case GUSMAX_DAC_MUTE:
! 2997: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 2998: dip->type = AUDIO_MIXER_ENUM;
! 2999: dip->prev = GUSMAX_DAC_LVL;
! 3000: dip->next = AUDIO_MIXER_LAST;
! 3001: goto mute;
! 3002:
! 3003: case GUSMAX_CD_MUTE:
! 3004: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 3005: dip->type = AUDIO_MIXER_ENUM;
! 3006: dip->prev = GUSMAX_CD_LVL;
! 3007: dip->next = AUDIO_MIXER_LAST;
! 3008: goto mute;
! 3009:
! 3010: case GUSMAX_MONO_MUTE:
! 3011: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 3012: dip->type = AUDIO_MIXER_ENUM;
! 3013: dip->prev = GUSMAX_MONO_LVL;
! 3014: dip->next = AUDIO_MIXER_LAST;
! 3015: goto mute;
! 3016:
! 3017: case GUSMAX_MONITOR_MUTE:
! 3018: dip->mixer_class = GUSMAX_OUTPUT_CLASS;
! 3019: dip->type = AUDIO_MIXER_ENUM;
! 3020: dip->prev = GUSMAX_MONITOR_LVL;
! 3021: dip->next = AUDIO_MIXER_LAST;
! 3022: goto mute;
! 3023:
! 3024: case GUSMAX_SPEAKER_MUTE:
! 3025: dip->mixer_class = GUSMAX_OUTPUT_CLASS;
! 3026: dip->type = AUDIO_MIXER_ENUM;
! 3027: dip->prev = GUSMAX_SPEAKER_LVL;
! 3028: dip->next = AUDIO_MIXER_LAST;
! 3029: mute:
! 3030: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
! 3031: dip->un.e.num_mem = 2;
! 3032: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 3033: sizeof dip->un.e.member[0].label.name);
! 3034: dip->un.e.member[0].ord = 0;
! 3035: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 3036: sizeof dip->un.e.member[1].label.name);
! 3037: dip->un.e.member[1].ord = 1;
! 3038: break;
! 3039:
! 3040: case GUSMAX_REC_LVL: /* record level */
! 3041: dip->type = AUDIO_MIXER_VALUE;
! 3042: dip->mixer_class = GUSMAX_RECORD_CLASS;
! 3043: dip->prev = AUDIO_MIXER_LAST;
! 3044: dip->next = GUSMAX_RECORD_SOURCE;
! 3045: strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
! 3046: dip->un.v.num_channels = 2;
! 3047: strlcpy(dip->un.v.units.name, AudioNvolume, sizeof dip->un.v.units.name);
! 3048: break;
! 3049:
! 3050: case GUSMAX_RECORD_SOURCE:
! 3051: dip->mixer_class = GUSMAX_RECORD_CLASS;
! 3052: dip->type = AUDIO_MIXER_ENUM;
! 3053: dip->prev = GUSMAX_REC_LVL;
! 3054: dip->next = AUDIO_MIXER_LAST;
! 3055: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 3056: dip->un.e.num_mem = 4;
! 3057: strlcpy(dip->un.e.member[0].label.name, AudioNoutput,
! 3058: sizeof dip->un.e.member[0].label.name);
! 3059: dip->un.e.member[0].ord = DAC_IN_PORT;
! 3060: strlcpy(dip->un.e.member[1].label.name, AudioNmicrophone,
! 3061: sizeof dip->un.e.member[1].label.name);
! 3062: dip->un.e.member[1].ord = MIC_IN_PORT;
! 3063: strlcpy(dip->un.e.member[2].label.name, AudioNdac,
! 3064: sizeof dip->un.e.member[2].label.name);
! 3065: dip->un.e.member[2].ord = AUX1_IN_PORT;
! 3066: strlcpy(dip->un.e.member[3].label.name, AudioNline,
! 3067: sizeof dip->un.e.member[3].label.name);
! 3068: dip->un.e.member[3].ord = LINE_IN_PORT;
! 3069: break;
! 3070:
! 3071: case GUSMAX_INPUT_CLASS: /* input class descriptor */
! 3072: dip->type = AUDIO_MIXER_CLASS;
! 3073: dip->mixer_class = GUSMAX_INPUT_CLASS;
! 3074: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3075: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
! 3076: break;
! 3077:
! 3078: case GUSMAX_OUTPUT_CLASS: /* output class descriptor */
! 3079: dip->type = AUDIO_MIXER_CLASS;
! 3080: dip->mixer_class = GUSMAX_OUTPUT_CLASS;
! 3081: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3082: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
! 3083: break;
! 3084:
! 3085: case GUSMAX_MONITOR_CLASS: /* monitor class descriptor */
! 3086: dip->type = AUDIO_MIXER_CLASS;
! 3087: dip->mixer_class = GUSMAX_MONITOR_CLASS;
! 3088: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3089: strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
! 3090: break;
! 3091:
! 3092: case GUSMAX_RECORD_CLASS: /* record source class */
! 3093: dip->type = AUDIO_MIXER_CLASS;
! 3094: dip->mixer_class = GUSMAX_RECORD_CLASS;
! 3095: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3096: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
! 3097: break;
! 3098:
! 3099: default:
! 3100: return ENXIO;
! 3101: /*NOTREACHED*/
! 3102: }
! 3103: DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
! 3104: return 0;
! 3105: }
! 3106:
! 3107: int
! 3108: gus_mixer_query_devinfo(addr, dip)
! 3109: void *addr;
! 3110: mixer_devinfo_t *dip;
! 3111: {
! 3112: struct gus_softc *sc = addr;
! 3113:
! 3114: DPRINTF(("gusmax_query_devinfo: index=%d\n", dip->index));
! 3115:
! 3116: if (!HAS_MIXER(sc) && dip->index > GUSICS_MASTER_MUTE)
! 3117: return ENXIO;
! 3118:
! 3119: switch(dip->index) {
! 3120:
! 3121: case GUSICS_MIC_IN_LVL: /* Microphone */
! 3122: dip->type = AUDIO_MIXER_VALUE;
! 3123: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3124: dip->prev = AUDIO_MIXER_LAST;
! 3125: dip->next = GUSICS_MIC_IN_MUTE;
! 3126: strlcpy(dip->label.name, AudioNmicrophone,
! 3127: sizeof dip->label.name);
! 3128: dip->un.v.num_channels = 2;
! 3129: strlcpy(dip->un.v.units.name, AudioNvolume,
! 3130: sizeof dip->un.v.units.name);
! 3131: break;
! 3132:
! 3133: case GUSICS_LINE_IN_LVL: /* line */
! 3134: dip->type = AUDIO_MIXER_VALUE;
! 3135: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3136: dip->prev = AUDIO_MIXER_LAST;
! 3137: dip->next = GUSICS_LINE_IN_MUTE;
! 3138: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
! 3139: dip->un.v.num_channels = 2;
! 3140: strlcpy(dip->un.v.units.name, AudioNvolume,
! 3141: sizeof dip->un.v.units.name);
! 3142: break;
! 3143:
! 3144: case GUSICS_CD_LVL: /* cd */
! 3145: dip->type = AUDIO_MIXER_VALUE;
! 3146: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3147: dip->prev = AUDIO_MIXER_LAST;
! 3148: dip->next = GUSICS_CD_MUTE;
! 3149: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
! 3150: dip->un.v.num_channels = 2;
! 3151: strlcpy(dip->un.v.units.name, AudioNvolume,
! 3152: sizeof dip->un.v.units.name);
! 3153: break;
! 3154:
! 3155: case GUSICS_DAC_LVL: /* dacout */
! 3156: dip->type = AUDIO_MIXER_VALUE;
! 3157: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3158: dip->prev = AUDIO_MIXER_LAST;
! 3159: dip->next = GUSICS_DAC_MUTE;
! 3160: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
! 3161: dip->un.v.num_channels = 2;
! 3162: strlcpy(dip->un.v.units.name, AudioNvolume,
! 3163: sizeof dip->un.v.units.name);
! 3164: break;
! 3165:
! 3166: case GUSICS_MASTER_LVL: /* master output */
! 3167: dip->type = AUDIO_MIXER_VALUE;
! 3168: dip->mixer_class = GUSICS_OUTPUT_CLASS;
! 3169: dip->prev = AUDIO_MIXER_LAST;
! 3170: dip->next = GUSICS_MASTER_MUTE;
! 3171: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
! 3172: dip->un.v.num_channels = 2;
! 3173: strlcpy(dip->un.v.units.name, AudioNvolume,
! 3174: sizeof dip->un.v.units.name);
! 3175: break;
! 3176:
! 3177:
! 3178: case GUSICS_LINE_IN_MUTE:
! 3179: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3180: dip->type = AUDIO_MIXER_ENUM;
! 3181: dip->prev = GUSICS_LINE_IN_LVL;
! 3182: dip->next = AUDIO_MIXER_LAST;
! 3183: goto mute;
! 3184:
! 3185: case GUSICS_DAC_MUTE:
! 3186: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3187: dip->type = AUDIO_MIXER_ENUM;
! 3188: dip->prev = GUSICS_DAC_LVL;
! 3189: dip->next = AUDIO_MIXER_LAST;
! 3190: goto mute;
! 3191:
! 3192: case GUSICS_CD_MUTE:
! 3193: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3194: dip->type = AUDIO_MIXER_ENUM;
! 3195: dip->prev = GUSICS_CD_LVL;
! 3196: dip->next = AUDIO_MIXER_LAST;
! 3197: goto mute;
! 3198:
! 3199: case GUSICS_MIC_IN_MUTE:
! 3200: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3201: dip->type = AUDIO_MIXER_ENUM;
! 3202: dip->prev = GUSICS_MIC_IN_LVL;
! 3203: dip->next = AUDIO_MIXER_LAST;
! 3204: goto mute;
! 3205:
! 3206: case GUSICS_MASTER_MUTE:
! 3207: dip->mixer_class = GUSICS_OUTPUT_CLASS;
! 3208: dip->type = AUDIO_MIXER_ENUM;
! 3209: dip->prev = GUSICS_MASTER_LVL;
! 3210: dip->next = AUDIO_MIXER_LAST;
! 3211: mute:
! 3212: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
! 3213: dip->un.e.num_mem = 2;
! 3214: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 3215: sizeof dip->un.e.member[0].label.name);
! 3216: dip->un.e.member[0].ord = 0;
! 3217: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 3218: sizeof dip->un.e.member[1].label.name);
! 3219: dip->un.e.member[1].ord = 1;
! 3220: break;
! 3221:
! 3222: case GUSICS_RECORD_SOURCE:
! 3223: dip->mixer_class = GUSICS_RECORD_CLASS;
! 3224: dip->type = AUDIO_MIXER_ENUM;
! 3225: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 3226: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 3227: dip->un.e.num_mem = 1;
! 3228: strlcpy(dip->un.e.member[0].label.name, AudioNoutput,
! 3229: sizeof dip->un.e.member[0].label.name);
! 3230: dip->un.e.member[0].ord = GUSICS_MASTER_LVL;
! 3231: break;
! 3232:
! 3233: case GUSICS_INPUT_CLASS:
! 3234: dip->type = AUDIO_MIXER_CLASS;
! 3235: dip->mixer_class = GUSICS_INPUT_CLASS;
! 3236: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3237: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
! 3238: break;
! 3239:
! 3240: case GUSICS_OUTPUT_CLASS:
! 3241: dip->type = AUDIO_MIXER_CLASS;
! 3242: dip->mixer_class = GUSICS_OUTPUT_CLASS;
! 3243: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3244: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
! 3245: break;
! 3246:
! 3247: case GUSICS_RECORD_CLASS:
! 3248: dip->type = AUDIO_MIXER_CLASS;
! 3249: dip->mixer_class = GUSICS_RECORD_CLASS;
! 3250: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 3251: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
! 3252: break;
! 3253:
! 3254: default:
! 3255: return ENXIO;
! 3256: /*NOTREACHED*/
! 3257: }
! 3258: DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
! 3259: return 0;
! 3260: }
! 3261:
! 3262: int
! 3263: gus_query_encoding(addr, fp)
! 3264: void *addr;
! 3265: struct audio_encoding *fp;
! 3266: {
! 3267: switch (fp->index) {
! 3268: case 0:
! 3269: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 3270: fp->encoding = AUDIO_ENCODING_ULAW;
! 3271: fp->precision = 8;
! 3272: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 3273: break;
! 3274: case 1:
! 3275: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 3276: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 3277: fp->precision = 8;
! 3278: fp->flags = 0;
! 3279: break;
! 3280: case 2:
! 3281: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 3282: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 3283: fp->precision = 16;
! 3284: fp->flags = 0;
! 3285: break;
! 3286: case 3:
! 3287: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 3288: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 3289: fp->precision = 8;
! 3290: fp->flags = 0;
! 3291: break;
! 3292: case 4:
! 3293: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 3294: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 3295: fp->precision = 16;
! 3296: fp->flags = 0;
! 3297: break;
! 3298: case 5:
! 3299: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 3300: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 3301: fp->precision = 16;
! 3302: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 3303: break;
! 3304: case 6:
! 3305: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 3306: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 3307: fp->precision = 16;
! 3308: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 3309: break;
! 3310: case 7:
! 3311: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 3312: fp->encoding = AUDIO_ENCODING_ALAW;
! 3313: fp->precision = 8;
! 3314: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 3315: break;
! 3316:
! 3317: default:
! 3318: return(EINVAL);
! 3319: /*NOTREACHED*/
! 3320: }
! 3321: return (0);
! 3322: }
! 3323:
! 3324: /*
! 3325: * Setup the ICS mixer in "transparent" mode: reset everything to a sensible
! 3326: * level. Levels as suggested by GUS SDK code.
! 3327: */
! 3328:
! 3329: void
! 3330: gus_init_ics2101(sc)
! 3331: struct gus_softc *sc;
! 3332: {
! 3333: struct ics2101_softc *ic = &sc->sc_mixer;
! 3334: sc->sc_mixer.sc_iot = sc->sc_iot;
! 3335: sc->sc_mixer.sc_selio = GUS_MIXER_SELECT;
! 3336: sc->sc_mixer.sc_selio_ioh = sc->sc_ioh3;
! 3337: sc->sc_mixer.sc_dataio = GUS_MIXER_DATA;
! 3338: sc->sc_mixer.sc_dataio_ioh = sc->sc_ioh2;
! 3339: sc->sc_mixer.sc_flags = (sc->sc_revision == 5) ? ICS_FLIP : 0;
! 3340:
! 3341: ics2101_mix_attenuate(ic,
! 3342: GUSMIX_CHAN_MIC,
! 3343: ICSMIX_LEFT,
! 3344: ICSMIX_MIN_ATTN);
! 3345: ics2101_mix_attenuate(ic,
! 3346: GUSMIX_CHAN_MIC,
! 3347: ICSMIX_RIGHT,
! 3348: ICSMIX_MIN_ATTN);
! 3349: /*
! 3350: * Start with microphone muted by the mixer...
! 3351: */
! 3352: gusics_mic_mute(ic, 1);
! 3353:
! 3354: /* ... and enabled by the GUS master mix control */
! 3355: gus_mic_ctl(sc, SPKR_ON);
! 3356:
! 3357: ics2101_mix_attenuate(ic,
! 3358: GUSMIX_CHAN_LINE,
! 3359: ICSMIX_LEFT,
! 3360: ICSMIX_MIN_ATTN);
! 3361: ics2101_mix_attenuate(ic,
! 3362: GUSMIX_CHAN_LINE,
! 3363: ICSMIX_RIGHT,
! 3364: ICSMIX_MIN_ATTN);
! 3365:
! 3366: ics2101_mix_attenuate(ic,
! 3367: GUSMIX_CHAN_CD,
! 3368: ICSMIX_LEFT,
! 3369: ICSMIX_MIN_ATTN);
! 3370: ics2101_mix_attenuate(ic,
! 3371: GUSMIX_CHAN_CD,
! 3372: ICSMIX_RIGHT,
! 3373: ICSMIX_MIN_ATTN);
! 3374:
! 3375: ics2101_mix_attenuate(ic,
! 3376: GUSMIX_CHAN_DAC,
! 3377: ICSMIX_LEFT,
! 3378: ICSMIX_MIN_ATTN);
! 3379: ics2101_mix_attenuate(ic,
! 3380: GUSMIX_CHAN_DAC,
! 3381: ICSMIX_RIGHT,
! 3382: ICSMIX_MIN_ATTN);
! 3383:
! 3384: ics2101_mix_attenuate(ic,
! 3385: ICSMIX_CHAN_4,
! 3386: ICSMIX_LEFT,
! 3387: ICSMIX_MAX_ATTN);
! 3388: ics2101_mix_attenuate(ic,
! 3389: ICSMIX_CHAN_4,
! 3390: ICSMIX_RIGHT,
! 3391: ICSMIX_MAX_ATTN);
! 3392:
! 3393: ics2101_mix_attenuate(ic,
! 3394: GUSMIX_CHAN_MASTER,
! 3395: ICSMIX_LEFT,
! 3396: ICSMIX_MIN_ATTN);
! 3397: ics2101_mix_attenuate(ic,
! 3398: GUSMIX_CHAN_MASTER,
! 3399: ICSMIX_RIGHT,
! 3400: ICSMIX_MIN_ATTN);
! 3401: /* unmute other stuff: */
! 3402: gusics_cd_mute(ic, 0);
! 3403: gusics_dac_mute(ic, 0);
! 3404: gusics_linein_mute(ic, 0);
! 3405: return;
! 3406: }
! 3407:
! 3408:
! 3409:
! 3410: void
! 3411: gus_subattach(sc, ia)
! 3412: struct gus_softc *sc;
! 3413: struct isa_attach_args *ia;
! 3414: {
! 3415: int i;
! 3416: bus_space_tag_t iot;
! 3417: unsigned char c,d,m;
! 3418:
! 3419: iot = sc->sc_iot;
! 3420:
! 3421: /*
! 3422: * Figure out our board rev, and see if we need to initialize the
! 3423: * mixer
! 3424: */
! 3425:
! 3426: c = bus_space_read_1(iot, sc->sc_ioh3, GUS_BOARD_REV);
! 3427: if (c != 0xff)
! 3428: sc->sc_revision = c;
! 3429: else
! 3430: sc->sc_revision = 0;
! 3431:
! 3432: SELECT_GUS_REG(iot, sc->sc_ioh2, GUSREG_RESET);
! 3433: bus_space_write_1(iot, sc->sc_ioh2, GUS_DATA_HIGH, 0x00);
! 3434:
! 3435: gusreset(sc, GUS_MAX_VOICES); /* initialize all voices */
! 3436: gusreset(sc, GUS_MIN_VOICES); /* then set to just the ones we use */
! 3437:
! 3438: /*
! 3439: * Setup the IRQ and DRQ lines in software, using values from
! 3440: * config file
! 3441: */
! 3442:
! 3443: m = GUSMASK_LINE_IN|GUSMASK_LINE_OUT; /* disable all */
! 3444:
! 3445: c = ((unsigned char) gus_irq_map[ia->ia_irq]) | GUSMASK_BOTH_RQ;
! 3446:
! 3447: if (sc->sc_recdrq == sc->sc_drq)
! 3448: d = (unsigned char) (gus_drq_map[sc->sc_drq] |
! 3449: GUSMASK_BOTH_RQ);
! 3450: else
! 3451: d = (unsigned char) (gus_drq_map[sc->sc_drq] |
! 3452: gus_drq_map[sc->sc_recdrq] << 3);
! 3453:
! 3454: /*
! 3455: * Program the IRQ and DMA channels on the GUS. Note that we hardwire
! 3456: * the GUS to only use one IRQ channel, but we give the user the
! 3457: * option of using two DMA channels (the other one given by the drq2
! 3458: * option in the config file). Two DMA channels are needed for full-
! 3459: * duplex operation.
! 3460: *
! 3461: * The order of these operations is very magical.
! 3462: */
! 3463:
! 3464: disable_intr(); /* XXX needed? */
! 3465:
! 3466: bus_space_write_1(iot, sc->sc_ioh1, GUS_REG_CONTROL, GUS_REG_IRQCTL);
! 3467: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL, m);
! 3468: bus_space_write_1(iot, sc->sc_ioh1, GUS_IRQCTL_CONTROL, 0x00);
! 3469: bus_space_write_1(iot, sc->sc_ioh1, 0x0f, 0x00);
! 3470:
! 3471: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL, m);
! 3472:
! 3473: /* magic reset? */
! 3474: bus_space_write_1(iot, sc->sc_ioh1, GUS_DMA_CONTROL, d | 0x80);
! 3475:
! 3476: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL,
! 3477: m | GUSMASK_CONTROL_SEL);
! 3478: bus_space_write_1(iot, sc->sc_ioh1, GUS_IRQ_CONTROL, c);
! 3479:
! 3480: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL, m);
! 3481: bus_space_write_1(iot, sc->sc_ioh1, GUS_DMA_CONTROL, d);
! 3482:
! 3483: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL,
! 3484: m | GUSMASK_CONTROL_SEL);
! 3485: bus_space_write_1(iot, sc->sc_ioh1, GUS_IRQ_CONTROL, c);
! 3486:
! 3487: bus_space_write_1(iot, sc->sc_ioh2, GUS_VOICE_SELECT, 0x00);
! 3488:
! 3489: /* enable line in, line out. leave mic disabled. */
! 3490: bus_space_write_1(iot, sc->sc_ioh1, GUS_MIX_CONTROL,
! 3491: (m | GUSMASK_LATCHES) & ~(GUSMASK_LINE_OUT|GUSMASK_LINE_IN));
! 3492: bus_space_write_1(iot, sc->sc_ioh2, GUS_VOICE_SELECT, 0x00);
! 3493:
! 3494: enable_intr();
! 3495:
! 3496: sc->sc_mixcontrol =
! 3497: (m | GUSMASK_LATCHES) & ~(GUSMASK_LINE_OUT|GUSMASK_LINE_IN);
! 3498:
! 3499: sc->sc_codec.sc_isa = sc->sc_isa;
! 3500:
! 3501: if (sc->sc_revision >= 5 && sc->sc_revision <= 9) {
! 3502: sc->sc_flags |= GUS_MIXER_INSTALLED;
! 3503: gus_init_ics2101(sc);
! 3504: }
! 3505: if (sc->sc_revision < 10 || !gus_init_cs4231(sc)) {
! 3506: /* Not using the CS4231, so create our DMA maps. */
! 3507: if (sc->sc_drq != -1) {
! 3508: if (isa_dmamap_create(sc->sc_isa, sc->sc_drq,
! 3509: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
! 3510: printf("%s: can't create map for drq %d\n",
! 3511: sc->sc_dev.dv_xname, sc->sc_drq);
! 3512: return;
! 3513: }
! 3514: }
! 3515: if (sc->sc_recdrq != -1 && sc->sc_recdrq != sc->sc_drq) {
! 3516: if (isa_dmamap_create(sc->sc_isa, sc->sc_recdrq,
! 3517: MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
! 3518: printf("%s: can't create map for drq %d\n",
! 3519: sc->sc_dev.dv_xname, sc->sc_recdrq);
! 3520: return;
! 3521: }
! 3522: }
! 3523: }
! 3524:
! 3525: timeout_set(&sc->sc_dma_tmo, gus_dmaout_timeout, sc);
! 3526:
! 3527: SELECT_GUS_REG(iot, sc->sc_ioh2, GUSREG_RESET);
! 3528: /*
! 3529: * Check to see how much memory we have on this card; see if any
! 3530: * "mirroring" occurs. We're assuming at least 256K already exists
! 3531: * on the card; otherwise the initial probe would have failed
! 3532: */
! 3533:
! 3534: guspoke(iot, sc->sc_ioh2, 0L, 0x00);
! 3535: for(i = 1; i < 1024; i++) {
! 3536: u_long loc;
! 3537:
! 3538: /*
! 3539: * See if we've run into mirroring yet
! 3540: */
! 3541:
! 3542: if (guspeek(iot, sc->sc_ioh2, 0L) != 0)
! 3543: break;
! 3544:
! 3545: loc = i << 10;
! 3546:
! 3547: guspoke(iot, sc->sc_ioh2, loc, 0xaa);
! 3548: if (guspeek(iot, sc->sc_ioh2, loc) != 0xaa)
! 3549: break;
! 3550: }
! 3551:
! 3552: sc->sc_dsize = i;
! 3553: /*
! 3554: * The "official" (3.x) version number cannot easily be obtained.
! 3555: * The revision register does not correspond to the minor number
! 3556: * of the board version. Simply use the revision register as
! 3557: * identification.
! 3558: */
! 3559: snprintf(gus_device.version, sizeof gus_device.version, "%d",
! 3560: sc->sc_revision);
! 3561:
! 3562: printf(": ver %d", sc->sc_revision);
! 3563: if (sc->sc_revision >= 10)
! 3564: printf(", MAX");
! 3565: else {
! 3566: if (HAS_MIXER(sc))
! 3567: printf(", ICS2101 mixer");
! 3568: if (HAS_CODEC(sc))
! 3569: printf(", %s codec/mixer", sc->sc_codec.chip_name);
! 3570: }
! 3571: printf(", %dKB DRAM, ", sc->sc_dsize);
! 3572: if (sc->sc_recdrq == sc->sc_drq) {
! 3573: printf("half-duplex");
! 3574: } else {
! 3575: printf("full-duplex, record drq %d", sc->sc_recdrq);
! 3576: }
! 3577:
! 3578: printf("\n");
! 3579:
! 3580: /*
! 3581: * Setup a default interrupt handler
! 3582: */
! 3583:
! 3584: /* XXX we shouldn't have to use splgus == splclock, nor should
! 3585: * we use IPL_CLOCK.
! 3586: */
! 3587: sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
! 3588: IPL_AUDIO, gusintr, sc /* sc->sc_gusdsp */, sc->sc_dev.dv_xname);
! 3589:
! 3590: /*
! 3591: * Set some default values
! 3592: * XXX others start with 8kHz mono mulaw
! 3593: */
! 3594:
! 3595: sc->sc_irate = sc->sc_orate = 44100;
! 3596: sc->sc_encoding = AUDIO_ENCODING_SLINEAR_LE;
! 3597: sc->sc_precision = 16;
! 3598: sc->sc_voc[GUS_VOICE_LEFT].voccntl |= GUSMASK_DATA_SIZE16;
! 3599: sc->sc_voc[GUS_VOICE_RIGHT].voccntl |= GUSMASK_DATA_SIZE16;
! 3600: sc->sc_channels = 1;
! 3601: sc->sc_ogain = 340;
! 3602: gus_commit_settings(sc);
! 3603:
! 3604: /*
! 3605: * We always put the left channel full left & right channel
! 3606: * full right.
! 3607: * For mono playback, we set up both voices playing the same buffer.
! 3608: */
! 3609: bus_space_write_1(iot, sc->sc_ioh2, GUS_VOICE_SELECT,
! 3610: (u_char)GUS_VOICE_LEFT);
! 3611: SELECT_GUS_REG(iot, sc->sc_ioh2, GUSREG_PAN_POS);
! 3612: bus_space_write_1(iot, sc->sc_ioh2, GUS_DATA_HIGH, GUS_PAN_FULL_LEFT);
! 3613:
! 3614: bus_space_write_1(iot, sc->sc_ioh2, GUS_VOICE_SELECT,
! 3615: (u_char)GUS_VOICE_RIGHT);
! 3616: SELECT_GUS_REG(iot, sc->sc_ioh2, GUSREG_PAN_POS);
! 3617: bus_space_write_1(iot, sc->sc_ioh2, GUS_DATA_HIGH, GUS_PAN_FULL_RIGHT);
! 3618:
! 3619: /*
! 3620: * Attach to the generic audio layer
! 3621: */
! 3622:
! 3623: audio_attach_mi(&gus_hw_if, HAS_CODEC(sc) ? (void *)&sc->sc_codec :
! 3624: (void *)sc, &sc->sc_dev);
! 3625: }
! 3626:
! 3627: /*
! 3628: * Test to see if a particular I/O base is valid for the GUS. Return true
! 3629: * if it is.
! 3630: */
! 3631:
! 3632: int
! 3633: gus_test_iobase (iot, iobase)
! 3634: bus_space_tag_t iot;
! 3635: int iobase;
! 3636: {
! 3637: bus_space_handle_t ioh1, ioh2, ioh3, ioh4;
! 3638: u_char s1, s2;
! 3639: int s, rv = 0;
! 3640:
! 3641: /* Map i/o space */
! 3642: if (bus_space_map(iot, iobase, GUS_NPORT1, 0, &ioh1))
! 3643: return 0;
! 3644: if (bus_space_map(iot, iobase+GUS_IOH2_OFFSET, GUS_NPORT2, 0, &ioh2))
! 3645: goto bad1;
! 3646:
! 3647: /* XXX Maybe we shouldn't fail on mapping this, but just assume
! 3648: * the card is of revision 0? */
! 3649: if (bus_space_map(iot, iobase+GUS_IOH3_OFFSET, GUS_NPORT3, 0, &ioh3))
! 3650: goto bad2;
! 3651:
! 3652: if (bus_space_map(iot, iobase+GUS_IOH4_OFFSET, GUS_NPORT4, 0, &ioh4))
! 3653: goto bad3;
! 3654:
! 3655: /*
! 3656: * Reset GUS to an initial state before we do anything.
! 3657: */
! 3658:
! 3659: s = splgus();
! 3660: delay(500);
! 3661:
! 3662: SELECT_GUS_REG(iot, ioh2, GUSREG_RESET);
! 3663: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, 0x00);
! 3664:
! 3665: delay(500);
! 3666:
! 3667: SELECT_GUS_REG(iot, ioh2, GUSREG_RESET);
! 3668: bus_space_write_1(iot, ioh2, GUS_DATA_HIGH, GUSMASK_MASTER_RESET);
! 3669:
! 3670: delay(500);
! 3671:
! 3672: splx(s);
! 3673:
! 3674: /*
! 3675: * See if we can write to the board's memory
! 3676: */
! 3677:
! 3678: s1 = guspeek(iot, ioh2, 0L);
! 3679: s2 = guspeek(iot, ioh2, 1L);
! 3680:
! 3681: guspoke(iot, ioh2, 0L, 0xaa);
! 3682: guspoke(iot, ioh2, 1L, 0x55);
! 3683:
! 3684: if (guspeek(iot, ioh2, 0L) != 0xaa)
! 3685: goto bad;
! 3686:
! 3687: guspoke(iot, ioh2, 0L, s1);
! 3688: guspoke(iot, ioh2, 1L, s2);
! 3689:
! 3690: rv = 1;
! 3691:
! 3692: bad:
! 3693: bus_space_unmap(iot, ioh4, GUS_NPORT4);
! 3694: bad3:
! 3695: bus_space_unmap(iot, ioh3, GUS_NPORT3);
! 3696: bad2:
! 3697: bus_space_unmap(iot, ioh2, GUS_NPORT2);
! 3698: bad1:
! 3699: bus_space_unmap(iot, ioh1, GUS_NPORT1);
! 3700: return rv;
! 3701: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gus.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa