1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2001 Scott Long <scottl@freebsd.org> 5 * Copyright (c) 2001 Darrell Anderson <anderson@cs.duke.edu> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * Maestro-3/Allegro FreeBSD pcm sound driver 32 * 33 * executive status summary: 34 * (+) /dev/dsp multiple concurrent play channels. 35 * (+) /dev/dsp config (speed, mono/stereo, 8/16 bit). 36 * (+) /dev/mixer sets left/right volumes. 37 * (+) /dev/dsp recording works. Tested successfully with the cdrom channel 38 * (+) apm suspend/resume works, and works properly!. 39 * (-) hardware volme controls don't work =-( 40 * (-) setblocksize() does nothing. 41 * 42 * The real credit goes to: 43 * 44 * Zach Brown for his Linux driver core and helpful technical comments. 45 * <zab@zabbo.net>, http://www.zabbo.net/maestro3 46 * 47 * Cameron Grant created the pcm framework used here nearly verbatim. 48 * <cg@freebsd.org>, https://people.freebsd.org/~cg/template.c 49 * 50 * Taku YAMAMOTO for his Maestro-1/2 FreeBSD driver and sanity reference. 51 * <taku@cent.saitama-u.ac.jp> 52 * 53 * ESS docs explained a few magic registers and numbers. 54 * http://virgo.caltech.edu/~dmoore/maestro3.pdf.gz 55 */ 56 57 #ifdef HAVE_KERNEL_OPTION_HEADERS 58 #include "opt_snd.h" 59 #endif 60 61 #include <dev/sound/pcm/sound.h> 62 #include <dev/sound/pcm/ac97.h> 63 64 #include <dev/pci/pcireg.h> 65 #include <dev/pci/pcivar.h> 66 67 #define M3_MODEL 1 68 69 #include <dev/sound/pci/allegro_reg.h> 70 #include <dev/sound/pci/allegro_code.h> 71 72 SND_DECLARE_FILE("$FreeBSD$"); 73 74 /* -------------------------------------------------------------------- */ 75 76 enum {CHANGE=0, CALL=1, INTR=2, BORING=3, NONE=-1}; 77 #ifndef M3_DEBUG_LEVEL 78 #define M3_DEBUG_LEVEL NONE 79 #endif 80 #define M3_DEBUG(level, _msg) {if ((level) <= M3_DEBUG_LEVEL) {printf _msg;}} 81 82 /* -------------------------------------------------------------------- */ 83 enum { 84 ESS_ALLEGRO_1, 85 ESS_MAESTRO3 86 }; 87 88 static struct m3_card_type { 89 u_int32_t pci_id; int which; int delay1; int delay2; char *name; 90 } m3_card_types[] = { 91 { 0x1988125d, ESS_ALLEGRO_1, 50, 800, "ESS Technology Allegro-1" }, 92 { 0x1998125d, ESS_MAESTRO3, 20, 500, "ESS Technology Maestro3" }, 93 { 0x199a125d, ESS_MAESTRO3, 20, 500, "ESS Technology Maestro3" }, 94 { 0, 0, 0, 0, NULL } 95 }; 96 97 #define M3_BUFSIZE_MIN 4096 98 #define M3_BUFSIZE_MAX 65536 99 #define M3_BUFSIZE_DEFAULT 4096 100 #define M3_PCHANS 4 /* create /dev/dsp0.[0-N] to use more than one */ 101 #define M3_RCHANS 1 102 #define M3_MAXADDR ((1 << 27) - 1) 103 #define M3_DEFAULT_VOL 0x6800 104 105 struct sc_info; 106 107 struct sc_pchinfo { 108 u_int32_t spd; 109 u_int32_t fmt; 110 struct snd_dbuf *buffer; 111 struct pcm_channel *channel; 112 struct sc_info *parent; 113 u_int32_t bufsize; 114 u_int32_t dac_data; 115 u_int32_t dac_idx; 116 u_int32_t active; 117 u_int32_t ptr; 118 u_int32_t prevptr; 119 }; 120 121 struct sc_rchinfo { 122 u_int32_t spd; 123 u_int32_t fmt; 124 struct snd_dbuf *buffer; 125 struct pcm_channel *channel; 126 struct sc_info *parent; 127 u_int32_t bufsize; 128 u_int32_t adc_data; 129 u_int32_t adc_idx; 130 u_int32_t active; 131 u_int32_t ptr; 132 u_int32_t prevptr; 133 }; 134 135 struct sc_info { 136 device_t dev; 137 u_int32_t type; 138 int which; 139 int delay1; 140 int delay2; 141 142 bus_space_tag_t st; 143 bus_space_handle_t sh; 144 bus_dma_tag_t parent_dmat; 145 146 struct resource *reg; 147 struct resource *irq; 148 int regtype; 149 int regid; 150 int irqid; 151 void *ih; 152 153 struct sc_pchinfo pch[M3_PCHANS]; 154 struct sc_rchinfo rch[M3_RCHANS]; 155 int pch_cnt; 156 int rch_cnt; 157 int pch_active_cnt; 158 unsigned int bufsz; 159 u_int16_t *savemem; 160 161 struct mtx *sc_lock; 162 }; 163 164 #define M3_LOCK(_sc) snd_mtxlock((_sc)->sc_lock) 165 #define M3_UNLOCK(_sc) snd_mtxunlock((_sc)->sc_lock) 166 #define M3_LOCK_ASSERT(_sc) snd_mtxassert((_sc)->sc_lock) 167 168 /* -------------------------------------------------------------------- */ 169 170 /* play channel interface */ 171 static void *m3_pchan_init(kobj_t, void *, struct snd_dbuf *, struct pcm_channel *, int); 172 static int m3_pchan_free(kobj_t, void *); 173 static int m3_pchan_setformat(kobj_t, void *, u_int32_t); 174 static u_int32_t m3_pchan_setspeed(kobj_t, void *, u_int32_t); 175 static u_int32_t m3_pchan_setblocksize(kobj_t, void *, u_int32_t); 176 static int m3_pchan_trigger(kobj_t, void *, int); 177 static int m3_pchan_trigger_locked(kobj_t, void *, int); 178 static u_int32_t m3_pchan_getptr_internal(struct sc_pchinfo *); 179 static u_int32_t m3_pchan_getptr(kobj_t, void *); 180 static struct pcmchan_caps *m3_pchan_getcaps(kobj_t, void *); 181 182 /* record channel interface */ 183 static void *m3_rchan_init(kobj_t, void *, struct snd_dbuf *, struct pcm_channel *, int); 184 static int m3_rchan_free(kobj_t, void *); 185 static int m3_rchan_setformat(kobj_t, void *, u_int32_t); 186 static u_int32_t m3_rchan_setspeed(kobj_t, void *, u_int32_t); 187 static u_int32_t m3_rchan_setblocksize(kobj_t, void *, u_int32_t); 188 static int m3_rchan_trigger(kobj_t, void *, int); 189 static int m3_rchan_trigger_locked(kobj_t, void *, int); 190 static u_int32_t m3_rchan_getptr_internal(struct sc_rchinfo *); 191 static u_int32_t m3_rchan_getptr(kobj_t, void *); 192 static struct pcmchan_caps *m3_rchan_getcaps(kobj_t, void *); 193 194 static int m3_chan_active(struct sc_info *); 195 196 /* talk to the codec - called from ac97.c */ 197 static u_int32_t m3_initcd(kobj_t, void *); 198 static int m3_rdcd(kobj_t, void *, int); 199 static int m3_wrcd(kobj_t, void *, int, u_int32_t); 200 201 /* stuff */ 202 static void m3_intr(void *); 203 static int m3_power(struct sc_info *, int); 204 static int m3_init(struct sc_info *); 205 static int m3_uninit(struct sc_info *); 206 static u_int8_t m3_assp_halt(struct sc_info *); 207 static void m3_config(struct sc_info *); 208 static void m3_amp_enable(struct sc_info *); 209 static void m3_enable_ints(struct sc_info *); 210 static void m3_codec_reset(struct sc_info *); 211 212 /* -------------------------------------------------------------------- */ 213 /* Codec descriptor */ 214 static kobj_method_t m3_codec_methods[] = { 215 KOBJMETHOD(ac97_init, m3_initcd), 216 KOBJMETHOD(ac97_read, m3_rdcd), 217 KOBJMETHOD(ac97_write, m3_wrcd), 218 KOBJMETHOD_END 219 }; 220 AC97_DECLARE(m3_codec); 221 222 /* -------------------------------------------------------------------- */ 223 /* channel descriptors */ 224 225 static u_int32_t m3_playfmt[] = { 226 SND_FORMAT(AFMT_U8, 1, 0), 227 SND_FORMAT(AFMT_U8, 2, 0), 228 SND_FORMAT(AFMT_S16_LE, 1, 0), 229 SND_FORMAT(AFMT_S16_LE, 2, 0), 230 0 231 }; 232 static struct pcmchan_caps m3_playcaps = {8000, 48000, m3_playfmt, 0}; 233 234 static kobj_method_t m3_pch_methods[] = { 235 KOBJMETHOD(channel_init, m3_pchan_init), 236 KOBJMETHOD(channel_setformat, m3_pchan_setformat), 237 KOBJMETHOD(channel_setspeed, m3_pchan_setspeed), 238 KOBJMETHOD(channel_setblocksize, m3_pchan_setblocksize), 239 KOBJMETHOD(channel_trigger, m3_pchan_trigger), 240 KOBJMETHOD(channel_getptr, m3_pchan_getptr), 241 KOBJMETHOD(channel_getcaps, m3_pchan_getcaps), 242 KOBJMETHOD(channel_free, m3_pchan_free), 243 KOBJMETHOD_END 244 }; 245 CHANNEL_DECLARE(m3_pch); 246 247 static u_int32_t m3_recfmt[] = { 248 SND_FORMAT(AFMT_U8, 1, 0), 249 SND_FORMAT(AFMT_U8, 2, 0), 250 SND_FORMAT(AFMT_S16_LE, 1, 0), 251 SND_FORMAT(AFMT_S16_LE, 2, 0), 252 0 253 }; 254 static struct pcmchan_caps m3_reccaps = {8000, 48000, m3_recfmt, 0}; 255 256 static kobj_method_t m3_rch_methods[] = { 257 KOBJMETHOD(channel_init, m3_rchan_init), 258 KOBJMETHOD(channel_setformat, m3_rchan_setformat), 259 KOBJMETHOD(channel_setspeed, m3_rchan_setspeed), 260 KOBJMETHOD(channel_setblocksize, m3_rchan_setblocksize), 261 KOBJMETHOD(channel_trigger, m3_rchan_trigger), 262 KOBJMETHOD(channel_getptr, m3_rchan_getptr), 263 KOBJMETHOD(channel_getcaps, m3_rchan_getcaps), 264 KOBJMETHOD(channel_free, m3_rchan_free), 265 KOBJMETHOD_END 266 }; 267 CHANNEL_DECLARE(m3_rch); 268 269 /* -------------------------------------------------------------------- */ 270 /* some i/o convenience functions */ 271 272 #define m3_rd_1(sc, regno) bus_space_read_1(sc->st, sc->sh, regno) 273 #define m3_rd_2(sc, regno) bus_space_read_2(sc->st, sc->sh, regno) 274 #define m3_rd_4(sc, regno) bus_space_read_4(sc->st, sc->sh, regno) 275 #define m3_wr_1(sc, regno, data) bus_space_write_1(sc->st, sc->sh, regno, data) 276 #define m3_wr_2(sc, regno, data) bus_space_write_2(sc->st, sc->sh, regno, data) 277 #define m3_wr_4(sc, regno, data) bus_space_write_4(sc->st, sc->sh, regno, data) 278 #define m3_rd_assp_code(sc, index) \ 279 m3_rd_assp(sc, MEMTYPE_INTERNAL_CODE, index) 280 #define m3_wr_assp_code(sc, index, data) \ 281 m3_wr_assp(sc, MEMTYPE_INTERNAL_CODE, index, data) 282 #define m3_rd_assp_data(sc, index) \ 283 m3_rd_assp(sc, MEMTYPE_INTERNAL_DATA, index) 284 #define m3_wr_assp_data(sc, index, data) \ 285 m3_wr_assp(sc, MEMTYPE_INTERNAL_DATA, index, data) 286 287 static __inline u_int16_t 288 m3_rd_assp(struct sc_info *sc, u_int16_t region, u_int16_t index) 289 { 290 m3_wr_2(sc, DSP_PORT_MEMORY_TYPE, region & MEMTYPE_MASK); 291 m3_wr_2(sc, DSP_PORT_MEMORY_INDEX, index); 292 return m3_rd_2(sc, DSP_PORT_MEMORY_DATA); 293 } 294 295 static __inline void 296 m3_wr_assp(struct sc_info *sc, u_int16_t region, u_int16_t index, 297 u_int16_t data) 298 { 299 m3_wr_2(sc, DSP_PORT_MEMORY_TYPE, region & MEMTYPE_MASK); 300 m3_wr_2(sc, DSP_PORT_MEMORY_INDEX, index); 301 m3_wr_2(sc, DSP_PORT_MEMORY_DATA, data); 302 } 303 304 static __inline int 305 m3_wait(struct sc_info *sc) 306 { 307 int i; 308 309 for (i=0 ; i<20 ; i++) { 310 if ((m3_rd_1(sc, CODEC_STATUS) & 1) == 0) { 311 return 0; 312 } 313 DELAY(2); 314 } 315 return -1; 316 } 317 318 /* -------------------------------------------------------------------- */ 319 /* ac97 codec */ 320 321 static u_int32_t 322 m3_initcd(kobj_t kobj, void *devinfo) 323 { 324 struct sc_info *sc = (struct sc_info *)devinfo; 325 u_int32_t data; 326 327 M3_DEBUG(CALL, ("m3_initcd\n")); 328 329 /* init ac-link */ 330 331 data = m3_rd_1(sc, CODEC_COMMAND); 332 return ((data & 0x1) ? 0 : 1); 333 } 334 335 static int 336 m3_rdcd(kobj_t kobj, void *devinfo, int regno) 337 { 338 struct sc_info *sc = (struct sc_info *)devinfo; 339 u_int32_t data; 340 341 if (m3_wait(sc)) { 342 device_printf(sc->dev, "m3_rdcd timed out.\n"); 343 return -1; 344 } 345 m3_wr_1(sc, CODEC_COMMAND, (regno & 0x7f) | 0x80); 346 DELAY(50); /* ac97 cycle = 20.8 usec */ 347 if (m3_wait(sc)) { 348 device_printf(sc->dev, "m3_rdcd timed out.\n"); 349 return -1; 350 } 351 data = m3_rd_2(sc, CODEC_DATA); 352 return data; 353 } 354 355 static int 356 m3_wrcd(kobj_t kobj, void *devinfo, int regno, u_int32_t data) 357 { 358 struct sc_info *sc = (struct sc_info *)devinfo; 359 if (m3_wait(sc)) { 360 device_printf(sc->dev, "m3_wrcd timed out.\n"); 361 return -1; 362 } 363 m3_wr_2(sc, CODEC_DATA, data); 364 m3_wr_1(sc, CODEC_COMMAND, regno & 0x7f); 365 DELAY(50); /* ac97 cycle = 20.8 usec */ 366 return 0; 367 } 368 369 /* -------------------------------------------------------------------- */ 370 /* play channel interface */ 371 372 #define LO(x) (((x) & 0x0000ffff) ) 373 #define HI(x) (((x) & 0xffff0000) >> 16) 374 375 static void * 376 m3_pchan_init(kobj_t kobj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 377 { 378 struct sc_info *sc = devinfo; 379 struct sc_pchinfo *ch; 380 u_int32_t bus_addr, i; 381 int idx, data_bytes, dac_data; 382 int dsp_in_size, dsp_out_size, dsp_in_buf, dsp_out_buf; 383 384 struct data_word { 385 u_int16_t addr, val; 386 } pv[] = { 387 {CDATA_LEFT_VOLUME, M3_DEFAULT_VOL}, 388 {CDATA_RIGHT_VOLUME, M3_DEFAULT_VOL}, 389 {SRC3_DIRECTION_OFFSET, 0} , 390 {SRC3_DIRECTION_OFFSET + 3, 0x0000}, 391 {SRC3_DIRECTION_OFFSET + 4, 0}, 392 {SRC3_DIRECTION_OFFSET + 5, 0}, 393 {SRC3_DIRECTION_OFFSET + 6, 0}, 394 {SRC3_DIRECTION_OFFSET + 7, 0}, 395 {SRC3_DIRECTION_OFFSET + 8, 0}, 396 {SRC3_DIRECTION_OFFSET + 9, 0}, 397 {SRC3_DIRECTION_OFFSET + 10, 0x8000}, 398 {SRC3_DIRECTION_OFFSET + 11, 0xFF00}, 399 {SRC3_DIRECTION_OFFSET + 13, 0}, 400 {SRC3_DIRECTION_OFFSET + 14, 0}, 401 {SRC3_DIRECTION_OFFSET + 15, 0}, 402 {SRC3_DIRECTION_OFFSET + 16, 8}, 403 {SRC3_DIRECTION_OFFSET + 17, 50*2}, 404 {SRC3_DIRECTION_OFFSET + 18, MINISRC_BIQUAD_STAGE - 1}, 405 {SRC3_DIRECTION_OFFSET + 20, 0}, 406 {SRC3_DIRECTION_OFFSET + 21, 0} 407 }; 408 409 M3_LOCK(sc); 410 idx = sc->pch_cnt; /* dac instance number, no active reuse! */ 411 M3_DEBUG(CHANGE, ("m3_pchan_init(dac=%d)\n", idx)); 412 413 if (dir != PCMDIR_PLAY) { 414 M3_UNLOCK(sc); 415 device_printf(sc->dev, "m3_pchan_init not PCMDIR_PLAY\n"); 416 return (NULL); 417 } 418 419 data_bytes = (((MINISRC_TMP_BUFFER_SIZE & ~1) + 420 (MINISRC_IN_BUFFER_SIZE & ~1) + 421 (MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255) &~ 255; 422 dac_data = 0x1100 + (data_bytes * idx); 423 424 dsp_in_size = MINISRC_IN_BUFFER_SIZE - (0x20 * 2); 425 dsp_out_size = MINISRC_OUT_BUFFER_SIZE - (0x20 * 2); 426 dsp_in_buf = dac_data + (MINISRC_TMP_BUFFER_SIZE/2); 427 dsp_out_buf = dsp_in_buf + (dsp_in_size/2) + 1; 428 429 ch = &sc->pch[idx]; 430 ch->dac_idx = idx; 431 ch->dac_data = dac_data; 432 if (ch->dac_data + data_bytes/2 >= 0x1c00) { 433 M3_UNLOCK(sc); 434 device_printf(sc->dev, "m3_pchan_init: revb mem exhausted\n"); 435 return (NULL); 436 } 437 438 ch->buffer = b; 439 ch->parent = sc; 440 ch->channel = c; 441 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 442 ch->spd = DSP_DEFAULT_SPEED; 443 M3_UNLOCK(sc); /* XXX */ 444 if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0) { 445 device_printf(sc->dev, "m3_pchan_init chn_allocbuf failed\n"); 446 return (NULL); 447 } 448 M3_LOCK(sc); 449 ch->bufsize = sndbuf_getsize(ch->buffer); 450 451 /* host dma buffer pointers */ 452 bus_addr = sndbuf_getbufaddr(ch->buffer); 453 if (bus_addr & 3) { 454 device_printf(sc->dev, "m3_pchan_init unaligned bus_addr\n"); 455 bus_addr = (bus_addr + 4) & ~3; 456 } 457 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_ADDRL, LO(bus_addr)); 458 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_ADDRH, HI(bus_addr)); 459 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_END_PLUS_1L, 460 LO(bus_addr + ch->bufsize)); 461 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_END_PLUS_1H, 462 HI(bus_addr + ch->bufsize)); 463 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTL, 464 LO(bus_addr)); 465 m3_wr_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTH, 466 HI(bus_addr)); 467 468 /* dsp buffers */ 469 m3_wr_assp_data(sc, ch->dac_data + CDATA_IN_BUF_BEGIN, dsp_in_buf); 470 m3_wr_assp_data(sc, ch->dac_data + CDATA_IN_BUF_END_PLUS_1, 471 dsp_in_buf + dsp_in_size/2); 472 m3_wr_assp_data(sc, ch->dac_data + CDATA_IN_BUF_HEAD, dsp_in_buf); 473 m3_wr_assp_data(sc, ch->dac_data + CDATA_IN_BUF_TAIL, dsp_in_buf); 474 m3_wr_assp_data(sc, ch->dac_data + CDATA_OUT_BUF_BEGIN, dsp_out_buf); 475 m3_wr_assp_data(sc, ch->dac_data + CDATA_OUT_BUF_END_PLUS_1, 476 dsp_out_buf + dsp_out_size/2); 477 m3_wr_assp_data(sc, ch->dac_data + CDATA_OUT_BUF_HEAD, dsp_out_buf); 478 m3_wr_assp_data(sc, ch->dac_data + CDATA_OUT_BUF_TAIL, dsp_out_buf); 479 480 /* some per client initializers */ 481 m3_wr_assp_data(sc, ch->dac_data + SRC3_DIRECTION_OFFSET + 12, 482 ch->dac_data + 40 + 8); 483 m3_wr_assp_data(sc, ch->dac_data + SRC3_DIRECTION_OFFSET + 19, 484 0x400 + MINISRC_COEF_LOC); 485 /* enable or disable low pass filter? (0xff if rate> 45000) */ 486 m3_wr_assp_data(sc, ch->dac_data + SRC3_DIRECTION_OFFSET + 22, 0); 487 /* tell it which way dma is going? */ 488 m3_wr_assp_data(sc, ch->dac_data + CDATA_DMA_CONTROL, 489 DMACONTROL_AUTOREPEAT + DMAC_PAGE3_SELECTOR + 490 DMAC_BLOCKF_SELECTOR); 491 492 /* set an armload of static initializers */ 493 for(i = 0 ; i < (sizeof(pv) / sizeof(pv[0])) ; i++) { 494 m3_wr_assp_data(sc, ch->dac_data + pv[i].addr, pv[i].val); 495 } 496 497 /* put us in the packed task lists */ 498 m3_wr_assp_data(sc, KDATA_INSTANCE0_MINISRC + 499 (sc->pch_cnt + sc->rch_cnt), 500 ch->dac_data >> DP_SHIFT_COUNT); 501 m3_wr_assp_data(sc, KDATA_DMA_XFER0 + (sc->pch_cnt + sc->rch_cnt), 502 ch->dac_data >> DP_SHIFT_COUNT); 503 m3_wr_assp_data(sc, KDATA_MIXER_XFER0 + sc->pch_cnt, 504 ch->dac_data >> DP_SHIFT_COUNT); 505 506 /* gotta start before stop */ 507 m3_pchan_trigger_locked(NULL, ch, PCMTRIG_START); 508 /* silence noise on load */ 509 m3_pchan_trigger_locked(NULL, ch, PCMTRIG_STOP); 510 511 sc->pch_cnt++; 512 M3_UNLOCK(sc); 513 514 return (ch); 515 } 516 517 static int 518 m3_pchan_free(kobj_t kobj, void *chdata) 519 { 520 struct sc_pchinfo *ch = chdata; 521 struct sc_info *sc = ch->parent; 522 523 M3_LOCK(sc); 524 M3_DEBUG(CHANGE, ("m3_pchan_free(dac=%d)\n", ch->dac_idx)); 525 526 /* 527 * should remove this exact instance from the packed lists, but all 528 * are released at once (and in a stopped state) so this is ok. 529 */ 530 m3_wr_assp_data(sc, KDATA_INSTANCE0_MINISRC + 531 (sc->pch_cnt - 1) + sc->rch_cnt, 0); 532 m3_wr_assp_data(sc, KDATA_DMA_XFER0 + 533 (sc->pch_cnt - 1) + sc->rch_cnt, 0); 534 m3_wr_assp_data(sc, KDATA_MIXER_XFER0 + (sc->pch_cnt-1), 0); 535 sc->pch_cnt--; 536 M3_UNLOCK(sc); 537 538 return (0); 539 } 540 541 static int 542 m3_pchan_setformat(kobj_t kobj, void *chdata, u_int32_t format) 543 { 544 struct sc_pchinfo *ch = chdata; 545 struct sc_info *sc = ch->parent; 546 u_int32_t data; 547 548 M3_LOCK(sc); 549 M3_DEBUG(CHANGE, 550 ("m3_pchan_setformat(dac=%d, format=0x%x{%s-%s})\n", 551 ch->dac_idx, format, 552 format & (AFMT_U8|AFMT_S8) ? "8bit":"16bit", 553 (AFMT_CHANNEL(format) > 1) ? "STEREO":"MONO")); 554 555 /* mono word */ 556 data = (AFMT_CHANNEL(format) > 1)? 0 : 1; 557 m3_wr_assp_data(sc, ch->dac_data + SRC3_MODE_OFFSET, data); 558 559 /* 8bit word */ 560 data = ((format & AFMT_U8) || (format & AFMT_S8)) ? 1 : 0; 561 m3_wr_assp_data(sc, ch->dac_data + SRC3_WORD_LENGTH_OFFSET, data); 562 563 ch->fmt = format; 564 M3_UNLOCK(sc); 565 566 return (0); 567 } 568 569 static u_int32_t 570 m3_pchan_setspeed(kobj_t kobj, void *chdata, u_int32_t speed) 571 { 572 struct sc_pchinfo *ch = chdata; 573 struct sc_info *sc = ch->parent; 574 u_int32_t freq; 575 576 M3_LOCK(sc); 577 M3_DEBUG(CHANGE, ("m3_pchan_setspeed(dac=%d, speed=%d)\n", 578 ch->dac_idx, speed)); 579 580 if ((freq = ((speed << 15) + 24000) / 48000) != 0) { 581 freq--; 582 } 583 584 m3_wr_assp_data(sc, ch->dac_data + CDATA_FREQUENCY, freq); 585 ch->spd = speed; 586 M3_UNLOCK(sc); 587 588 /* return closest possible speed */ 589 return (speed); 590 } 591 592 static u_int32_t 593 m3_pchan_setblocksize(kobj_t kobj, void *chdata, u_int32_t blocksize) 594 { 595 struct sc_pchinfo *ch = chdata; 596 597 M3_DEBUG(CHANGE, ("m3_pchan_setblocksize(dac=%d, blocksize=%d)\n", 598 ch->dac_idx, blocksize)); 599 600 return (sndbuf_getblksz(ch->buffer)); 601 } 602 603 static int 604 m3_pchan_trigger(kobj_t kobj, void *chdata, int go) 605 { 606 struct sc_pchinfo *ch = chdata; 607 struct sc_info *sc = ch->parent; 608 int ret; 609 610 if (!PCMTRIG_COMMON(go)) 611 return (0); 612 613 M3_LOCK(sc); 614 ret = m3_pchan_trigger_locked(kobj, chdata, go); 615 M3_UNLOCK(sc); 616 617 return (ret); 618 } 619 620 static int 621 m3_chan_active(struct sc_info *sc) 622 { 623 int i, ret; 624 625 ret = 0; 626 627 for (i = 0; i < sc->pch_cnt; i++) 628 ret += sc->pch[i].active; 629 630 for (i = 0; i < sc->rch_cnt; i++) 631 ret += sc->rch[i].active; 632 633 return (ret); 634 } 635 636 static int 637 m3_pchan_trigger_locked(kobj_t kobj, void *chdata, int go) 638 { 639 struct sc_pchinfo *ch = chdata; 640 struct sc_info *sc = ch->parent; 641 u_int32_t data; 642 643 M3_LOCK_ASSERT(sc); 644 M3_DEBUG(go == PCMTRIG_START ? CHANGE : 645 go == PCMTRIG_STOP ? CHANGE : 646 go == PCMTRIG_ABORT ? CHANGE : 647 CALL, 648 ("m3_pchan_trigger(dac=%d, go=0x%x{%s})\n", ch->dac_idx, go, 649 go == PCMTRIG_START ? "PCMTRIG_START" : 650 go == PCMTRIG_STOP ? "PCMTRIG_STOP" : 651 go == PCMTRIG_ABORT ? "PCMTRIG_ABORT" : "ignore")); 652 653 switch(go) { 654 case PCMTRIG_START: 655 if (ch->active) { 656 return 0; 657 } 658 ch->active = 1; 659 ch->ptr = 0; 660 ch->prevptr = 0; 661 sc->pch_active_cnt++; 662 663 /*[[inc_timer_users]]*/ 664 if (m3_chan_active(sc) == 1) { 665 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_RELOAD, 240); 666 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_CURRENT, 240); 667 data = m3_rd_2(sc, HOST_INT_CTRL); 668 m3_wr_2(sc, HOST_INT_CTRL, data | CLKRUN_GEN_ENABLE); 669 } 670 671 m3_wr_assp_data(sc, ch->dac_data + CDATA_INSTANCE_READY, 1); 672 m3_wr_assp_data(sc, KDATA_MIXER_TASK_NUMBER, 673 sc->pch_active_cnt); 674 break; 675 676 case PCMTRIG_STOP: 677 case PCMTRIG_ABORT: 678 if (ch->active == 0) { 679 return 0; 680 } 681 ch->active = 0; 682 sc->pch_active_cnt--; 683 684 /* XXX should the channel be drained? */ 685 /*[[dec_timer_users]]*/ 686 if (m3_chan_active(sc) == 0) { 687 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_RELOAD, 0); 688 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_CURRENT, 0); 689 data = m3_rd_2(sc, HOST_INT_CTRL); 690 m3_wr_2(sc, HOST_INT_CTRL, data & ~CLKRUN_GEN_ENABLE); 691 } 692 693 m3_wr_assp_data(sc, ch->dac_data + CDATA_INSTANCE_READY, 0); 694 m3_wr_assp_data(sc, KDATA_MIXER_TASK_NUMBER, 695 sc->pch_active_cnt); 696 break; 697 698 case PCMTRIG_EMLDMAWR: 699 /* got play irq, transfer next buffer - ignore if using dma */ 700 case PCMTRIG_EMLDMARD: 701 /* got rec irq, transfer next buffer - ignore if using dma */ 702 default: 703 break; 704 } 705 return 0; 706 } 707 708 static u_int32_t 709 m3_pchan_getptr_internal(struct sc_pchinfo *ch) 710 { 711 struct sc_info *sc = ch->parent; 712 u_int32_t hi, lo, bus_base, bus_crnt; 713 714 bus_base = sndbuf_getbufaddr(ch->buffer); 715 hi = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTH); 716 lo = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTL); 717 bus_crnt = lo | (hi << 16); 718 719 M3_DEBUG(CALL, ("m3_pchan_getptr(dac=%d) result=%d\n", 720 ch->dac_idx, bus_crnt - bus_base)); 721 722 return (bus_crnt - bus_base); /* current byte offset of channel */ 723 } 724 725 static u_int32_t 726 m3_pchan_getptr(kobj_t kobj, void *chdata) 727 { 728 struct sc_pchinfo *ch = chdata; 729 struct sc_info *sc = ch->parent; 730 u_int32_t ptr; 731 732 M3_LOCK(sc); 733 ptr = ch->ptr; 734 M3_UNLOCK(sc); 735 736 return (ptr); 737 } 738 739 static struct pcmchan_caps * 740 m3_pchan_getcaps(kobj_t kobj, void *chdata) 741 { 742 struct sc_pchinfo *ch = chdata; 743 744 M3_DEBUG(CALL, ("m3_pchan_getcaps(dac=%d)\n", ch->dac_idx)); 745 746 return &m3_playcaps; 747 } 748 749 /* -------------------------------------------------------------------- */ 750 /* rec channel interface */ 751 752 static void * 753 m3_rchan_init(kobj_t kobj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 754 { 755 struct sc_info *sc = devinfo; 756 struct sc_rchinfo *ch; 757 u_int32_t bus_addr, i; 758 759 int idx, data_bytes, adc_data; 760 int dsp_in_size, dsp_out_size, dsp_in_buf, dsp_out_buf; 761 762 struct data_word { 763 u_int16_t addr, val; 764 } rv[] = { 765 {CDATA_LEFT_VOLUME, M3_DEFAULT_VOL}, 766 {CDATA_RIGHT_VOLUME, M3_DEFAULT_VOL}, 767 {SRC3_DIRECTION_OFFSET, 1}, 768 {SRC3_DIRECTION_OFFSET + 3, 0x0000}, 769 {SRC3_DIRECTION_OFFSET + 4, 0}, 770 {SRC3_DIRECTION_OFFSET + 5, 0}, 771 {SRC3_DIRECTION_OFFSET + 6, 0}, 772 {SRC3_DIRECTION_OFFSET + 7, 0}, 773 {SRC3_DIRECTION_OFFSET + 8, 0}, 774 {SRC3_DIRECTION_OFFSET + 9, 0}, 775 {SRC3_DIRECTION_OFFSET + 10, 0x8000}, 776 {SRC3_DIRECTION_OFFSET + 11, 0xFF00}, 777 {SRC3_DIRECTION_OFFSET + 13, 0}, 778 {SRC3_DIRECTION_OFFSET + 14, 0}, 779 {SRC3_DIRECTION_OFFSET + 15, 0}, 780 {SRC3_DIRECTION_OFFSET + 16, 50}, 781 {SRC3_DIRECTION_OFFSET + 17, 8}, 782 {SRC3_DIRECTION_OFFSET + 18, 0}, 783 {SRC3_DIRECTION_OFFSET + 19, 0}, 784 {SRC3_DIRECTION_OFFSET + 20, 0}, 785 {SRC3_DIRECTION_OFFSET + 21, 0}, 786 {SRC3_DIRECTION_OFFSET + 22, 0xff} 787 }; 788 789 M3_LOCK(sc); 790 idx = sc->rch_cnt; /* adc instance number, no active reuse! */ 791 M3_DEBUG(CHANGE, ("m3_rchan_init(adc=%d)\n", idx)); 792 793 if (dir != PCMDIR_REC) { 794 M3_UNLOCK(sc); 795 device_printf(sc->dev, "m3_pchan_init not PCMDIR_REC\n"); 796 return (NULL); 797 } 798 799 data_bytes = (((MINISRC_TMP_BUFFER_SIZE & ~1) + 800 (MINISRC_IN_BUFFER_SIZE & ~1) + 801 (MINISRC_OUT_BUFFER_SIZE & ~1) + 4) + 255) &~ 255; 802 adc_data = 0x1100 + (data_bytes * idx) + data_bytes/2; 803 dsp_in_size = MINISRC_IN_BUFFER_SIZE + (0x10 * 2); 804 dsp_out_size = MINISRC_OUT_BUFFER_SIZE - (0x10 * 2); 805 dsp_in_buf = adc_data + (MINISRC_TMP_BUFFER_SIZE / 2); 806 dsp_out_buf = dsp_in_buf + (dsp_in_size / 2) + 1; 807 808 ch = &sc->rch[idx]; 809 ch->adc_idx = idx; 810 ch->adc_data = adc_data; 811 if (ch->adc_data + data_bytes/2 >= 0x1c00) { 812 M3_UNLOCK(sc); 813 device_printf(sc->dev, "m3_rchan_init: revb mem exhausted\n"); 814 return (NULL); 815 } 816 817 ch->buffer = b; 818 ch->parent = sc; 819 ch->channel = c; 820 ch->fmt = SND_FORMAT(AFMT_U8, 1, 0); 821 ch->spd = DSP_DEFAULT_SPEED; 822 M3_UNLOCK(sc); /* XXX */ 823 if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0) { 824 device_printf(sc->dev, "m3_rchan_init chn_allocbuf failed\n"); 825 return (NULL); 826 } 827 M3_LOCK(sc); 828 ch->bufsize = sndbuf_getsize(ch->buffer); 829 830 /* host dma buffer pointers */ 831 bus_addr = sndbuf_getbufaddr(ch->buffer); 832 if (bus_addr & 3) { 833 device_printf(sc->dev, "m3_rchan_init unaligned bus_addr\n"); 834 bus_addr = (bus_addr + 4) & ~3; 835 } 836 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_ADDRL, LO(bus_addr)); 837 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_ADDRH, HI(bus_addr)); 838 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_END_PLUS_1L, 839 LO(bus_addr + ch->bufsize)); 840 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_END_PLUS_1H, 841 HI(bus_addr + ch->bufsize)); 842 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTL, 843 LO(bus_addr)); 844 m3_wr_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTH, 845 HI(bus_addr)); 846 847 /* dsp buffers */ 848 m3_wr_assp_data(sc, ch->adc_data + CDATA_IN_BUF_BEGIN, dsp_in_buf); 849 m3_wr_assp_data(sc, ch->adc_data + CDATA_IN_BUF_END_PLUS_1, 850 dsp_in_buf + dsp_in_size/2); 851 m3_wr_assp_data(sc, ch->adc_data + CDATA_IN_BUF_HEAD, dsp_in_buf); 852 m3_wr_assp_data(sc, ch->adc_data + CDATA_IN_BUF_TAIL, dsp_in_buf); 853 m3_wr_assp_data(sc, ch->adc_data + CDATA_OUT_BUF_BEGIN, dsp_out_buf); 854 m3_wr_assp_data(sc, ch->adc_data + CDATA_OUT_BUF_END_PLUS_1, 855 dsp_out_buf + dsp_out_size/2); 856 m3_wr_assp_data(sc, ch->adc_data + CDATA_OUT_BUF_HEAD, dsp_out_buf); 857 m3_wr_assp_data(sc, ch->adc_data + CDATA_OUT_BUF_TAIL, dsp_out_buf); 858 859 /* some per client initializers */ 860 m3_wr_assp_data(sc, ch->adc_data + SRC3_DIRECTION_OFFSET + 12, 861 ch->adc_data + 40 + 8); 862 m3_wr_assp_data(sc, ch->adc_data + CDATA_DMA_CONTROL, 863 DMACONTROL_DIRECTION + DMACONTROL_AUTOREPEAT + 864 DMAC_PAGE3_SELECTOR + DMAC_BLOCKF_SELECTOR); 865 866 /* set an armload of static initializers */ 867 for(i = 0 ; i < (sizeof(rv) / sizeof(rv[0])) ; i++) { 868 m3_wr_assp_data(sc, ch->adc_data + rv[i].addr, rv[i].val); 869 } 870 871 /* put us in the packed task lists */ 872 m3_wr_assp_data(sc, KDATA_INSTANCE0_MINISRC + 873 (sc->pch_cnt + sc->rch_cnt), 874 ch->adc_data >> DP_SHIFT_COUNT); 875 m3_wr_assp_data(sc, KDATA_DMA_XFER0 + (sc->pch_cnt + sc->rch_cnt), 876 ch->adc_data >> DP_SHIFT_COUNT); 877 m3_wr_assp_data(sc, KDATA_ADC1_XFER0 + sc->rch_cnt, 878 ch->adc_data >> DP_SHIFT_COUNT); 879 880 /* gotta start before stop */ 881 m3_rchan_trigger_locked(NULL, ch, PCMTRIG_START); 882 /* stop on init */ 883 m3_rchan_trigger_locked(NULL, ch, PCMTRIG_STOP); 884 885 sc->rch_cnt++; 886 M3_UNLOCK(sc); 887 888 return (ch); 889 } 890 891 static int 892 m3_rchan_free(kobj_t kobj, void *chdata) 893 { 894 struct sc_rchinfo *ch = chdata; 895 struct sc_info *sc = ch->parent; 896 897 M3_LOCK(sc); 898 M3_DEBUG(CHANGE, ("m3_rchan_free(adc=%d)\n", ch->adc_idx)); 899 900 /* 901 * should remove this exact instance from the packed lists, but all 902 * are released at once (and in a stopped state) so this is ok. 903 */ 904 m3_wr_assp_data(sc, KDATA_INSTANCE0_MINISRC + 905 (sc->rch_cnt - 1) + sc->pch_cnt, 0); 906 m3_wr_assp_data(sc, KDATA_DMA_XFER0 + 907 (sc->rch_cnt - 1) + sc->pch_cnt, 0); 908 m3_wr_assp_data(sc, KDATA_ADC1_XFER0 + (sc->rch_cnt - 1), 0); 909 sc->rch_cnt--; 910 M3_UNLOCK(sc); 911 912 return (0); 913 } 914 915 static int 916 m3_rchan_setformat(kobj_t kobj, void *chdata, u_int32_t format) 917 { 918 struct sc_rchinfo *ch = chdata; 919 struct sc_info *sc = ch->parent; 920 u_int32_t data; 921 922 M3_LOCK(sc); 923 M3_DEBUG(CHANGE, 924 ("m3_rchan_setformat(dac=%d, format=0x%x{%s-%s})\n", 925 ch->adc_idx, format, 926 format & (AFMT_U8|AFMT_S8) ? "8bit":"16bit", 927 (AFMT_CHANNEL(format) > 1) ? "STEREO":"MONO")); 928 929 /* mono word */ 930 data = (AFMT_CHANNEL(format) > 1) ? 0 : 1; 931 m3_wr_assp_data(sc, ch->adc_data + SRC3_MODE_OFFSET, data); 932 933 /* 8bit word */ 934 data = ((format & AFMT_U8) || (format & AFMT_S8)) ? 1 : 0; 935 m3_wr_assp_data(sc, ch->adc_data + SRC3_WORD_LENGTH_OFFSET, data); 936 ch->fmt = format; 937 M3_UNLOCK(sc); 938 939 return (0); 940 } 941 942 static u_int32_t 943 m3_rchan_setspeed(kobj_t kobj, void *chdata, u_int32_t speed) 944 { 945 struct sc_rchinfo *ch = chdata; 946 struct sc_info *sc = ch->parent; 947 u_int32_t freq; 948 949 M3_LOCK(sc); 950 M3_DEBUG(CHANGE, ("m3_rchan_setspeed(adc=%d, speed=%d)\n", 951 ch->adc_idx, speed)); 952 953 if ((freq = ((speed << 15) + 24000) / 48000) != 0) { 954 freq--; 955 } 956 957 m3_wr_assp_data(sc, ch->adc_data + CDATA_FREQUENCY, freq); 958 ch->spd = speed; 959 M3_UNLOCK(sc); 960 961 /* return closest possible speed */ 962 return (speed); 963 } 964 965 static u_int32_t 966 m3_rchan_setblocksize(kobj_t kobj, void *chdata, u_int32_t blocksize) 967 { 968 struct sc_rchinfo *ch = chdata; 969 970 M3_DEBUG(CHANGE, ("m3_rchan_setblocksize(adc=%d, blocksize=%d)\n", 971 ch->adc_idx, blocksize)); 972 973 return (sndbuf_getblksz(ch->buffer)); 974 } 975 976 static int 977 m3_rchan_trigger(kobj_t kobj, void *chdata, int go) 978 { 979 struct sc_rchinfo *ch = chdata; 980 struct sc_info *sc = ch->parent; 981 int ret; 982 983 if (!PCMTRIG_COMMON(go)) 984 return (0); 985 986 M3_LOCK(sc); 987 ret = m3_rchan_trigger_locked(kobj, chdata, go); 988 M3_UNLOCK(sc); 989 990 return (ret); 991 } 992 993 static int 994 m3_rchan_trigger_locked(kobj_t kobj, void *chdata, int go) 995 { 996 struct sc_rchinfo *ch = chdata; 997 struct sc_info *sc = ch->parent; 998 u_int32_t data; 999 1000 M3_LOCK_ASSERT(sc); 1001 M3_DEBUG(go == PCMTRIG_START ? CHANGE : 1002 go == PCMTRIG_STOP ? CHANGE : 1003 go == PCMTRIG_ABORT ? CHANGE : 1004 CALL, 1005 ("m3_rchan_trigger(adc=%d, go=0x%x{%s})\n", ch->adc_idx, go, 1006 go == PCMTRIG_START ? "PCMTRIG_START" : 1007 go == PCMTRIG_STOP ? "PCMTRIG_STOP" : 1008 go == PCMTRIG_ABORT ? "PCMTRIG_ABORT" : "ignore")); 1009 1010 switch(go) { 1011 case PCMTRIG_START: 1012 if (ch->active) { 1013 return 0; 1014 } 1015 ch->active = 1; 1016 ch->ptr = 0; 1017 ch->prevptr = 0; 1018 1019 /*[[inc_timer_users]]*/ 1020 if (m3_chan_active(sc) == 1) { 1021 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_RELOAD, 240); 1022 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_CURRENT, 240); 1023 data = m3_rd_2(sc, HOST_INT_CTRL); 1024 m3_wr_2(sc, HOST_INT_CTRL, data | CLKRUN_GEN_ENABLE); 1025 } 1026 1027 m3_wr_assp_data(sc, KDATA_ADC1_REQUEST, 1); 1028 m3_wr_assp_data(sc, ch->adc_data + CDATA_INSTANCE_READY, 1); 1029 break; 1030 1031 case PCMTRIG_STOP: 1032 case PCMTRIG_ABORT: 1033 if (ch->active == 0) { 1034 return 0; 1035 } 1036 ch->active = 0; 1037 1038 /*[[dec_timer_users]]*/ 1039 if (m3_chan_active(sc) == 0) { 1040 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_RELOAD, 0); 1041 m3_wr_assp_data(sc, KDATA_TIMER_COUNT_CURRENT, 0); 1042 data = m3_rd_2(sc, HOST_INT_CTRL); 1043 m3_wr_2(sc, HOST_INT_CTRL, data & ~CLKRUN_GEN_ENABLE); 1044 } 1045 1046 m3_wr_assp_data(sc, ch->adc_data + CDATA_INSTANCE_READY, 0); 1047 m3_wr_assp_data(sc, KDATA_ADC1_REQUEST, 0); 1048 break; 1049 1050 case PCMTRIG_EMLDMAWR: 1051 /* got play irq, transfer next buffer - ignore if using dma */ 1052 case PCMTRIG_EMLDMARD: 1053 /* got rec irq, transfer next buffer - ignore if using dma */ 1054 default: 1055 break; 1056 } 1057 return 0; 1058 } 1059 1060 static u_int32_t 1061 m3_rchan_getptr_internal(struct sc_rchinfo *ch) 1062 { 1063 struct sc_info *sc = ch->parent; 1064 u_int32_t hi, lo, bus_base, bus_crnt; 1065 1066 bus_base = sndbuf_getbufaddr(ch->buffer); 1067 hi = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTH); 1068 lo = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTL); 1069 bus_crnt = lo | (hi << 16); 1070 1071 M3_DEBUG(CALL, ("m3_rchan_getptr(adc=%d) result=%d\n", 1072 ch->adc_idx, bus_crnt - bus_base)); 1073 1074 return (bus_crnt - bus_base); /* current byte offset of channel */ 1075 } 1076 1077 static u_int32_t 1078 m3_rchan_getptr(kobj_t kobj, void *chdata) 1079 { 1080 struct sc_rchinfo *ch = chdata; 1081 struct sc_info *sc = ch->parent; 1082 u_int32_t ptr; 1083 1084 M3_LOCK(sc); 1085 ptr = ch->ptr; 1086 M3_UNLOCK(sc); 1087 1088 return (ptr); 1089 } 1090 1091 static struct pcmchan_caps * 1092 m3_rchan_getcaps(kobj_t kobj, void *chdata) 1093 { 1094 struct sc_rchinfo *ch = chdata; 1095 1096 M3_DEBUG(CALL, ("m3_rchan_getcaps(adc=%d)\n", ch->adc_idx)); 1097 1098 return &m3_reccaps; 1099 } 1100 1101 /* -------------------------------------------------------------------- */ 1102 /* The interrupt handler */ 1103 1104 static void 1105 m3_intr(void *p) 1106 { 1107 struct sc_info *sc = (struct sc_info *)p; 1108 struct sc_pchinfo *pch; 1109 struct sc_rchinfo *rch; 1110 u_int32_t status, ctl, i, delta; 1111 1112 M3_DEBUG(INTR, ("m3_intr\n")); 1113 1114 M3_LOCK(sc); 1115 status = m3_rd_1(sc, HOST_INT_STATUS); 1116 if (!status) { 1117 M3_UNLOCK(sc); 1118 return; 1119 } 1120 1121 m3_wr_1(sc, HOST_INT_STATUS, 0xff); /* ack the int? */ 1122 1123 if (status & HV_INT_PENDING) { 1124 u_int8_t event; 1125 1126 event = m3_rd_1(sc, HW_VOL_COUNTER_MASTER); 1127 switch (event) { 1128 case 0x99: 1129 mixer_hwvol_mute(sc->dev); 1130 break; 1131 case 0xaa: 1132 mixer_hwvol_step(sc->dev, 1, 1); 1133 break; 1134 case 0x66: 1135 mixer_hwvol_step(sc->dev, -1, -1); 1136 break; 1137 case 0x88: 1138 break; 1139 default: 1140 device_printf(sc->dev, "Unknown HWVOL event\n"); 1141 } 1142 m3_wr_1(sc, HW_VOL_COUNTER_MASTER, 0x88); 1143 1144 } 1145 1146 if (status & ASSP_INT_PENDING) { 1147 ctl = m3_rd_1(sc, ASSP_CONTROL_B); 1148 if (!(ctl & STOP_ASSP_CLOCK)) { 1149 ctl = m3_rd_1(sc, ASSP_HOST_INT_STATUS); 1150 if (ctl & DSP2HOST_REQ_TIMER) { 1151 m3_wr_1(sc, ASSP_HOST_INT_STATUS, 1152 DSP2HOST_REQ_TIMER); 1153 /*[[ess_update_ptr]]*/ 1154 goto m3_handle_channel_intr; 1155 } 1156 } 1157 } 1158 1159 goto m3_handle_channel_intr_out; 1160 1161 m3_handle_channel_intr: 1162 for (i=0 ; i<sc->pch_cnt ; i++) { 1163 pch = &sc->pch[i]; 1164 if (pch->active) { 1165 pch->ptr = m3_pchan_getptr_internal(pch); 1166 delta = pch->bufsize + pch->ptr - pch->prevptr; 1167 delta %= pch->bufsize; 1168 if (delta < sndbuf_getblksz(pch->buffer)) 1169 continue; 1170 pch->prevptr = pch->ptr; 1171 M3_UNLOCK(sc); 1172 chn_intr(pch->channel); 1173 M3_LOCK(sc); 1174 } 1175 } 1176 for (i=0 ; i<sc->rch_cnt ; i++) { 1177 rch = &sc->rch[i]; 1178 if (rch->active) { 1179 rch->ptr = m3_rchan_getptr_internal(rch); 1180 delta = rch->bufsize + rch->ptr - rch->prevptr; 1181 delta %= rch->bufsize; 1182 if (delta < sndbuf_getblksz(rch->buffer)) 1183 continue; 1184 rch->prevptr = rch->ptr; 1185 M3_UNLOCK(sc); 1186 chn_intr(rch->channel); 1187 M3_LOCK(sc); 1188 } 1189 } 1190 1191 m3_handle_channel_intr_out: 1192 M3_UNLOCK(sc); 1193 } 1194 1195 /* -------------------------------------------------------------------- */ 1196 /* stuff */ 1197 1198 static int 1199 m3_power(struct sc_info *sc, int state) 1200 { 1201 u_int32_t data; 1202 1203 M3_DEBUG(CHANGE, ("m3_power(%d)\n", state)); 1204 M3_LOCK_ASSERT(sc); 1205 1206 data = pci_read_config(sc->dev, 0x34, 1); 1207 if (pci_read_config(sc->dev, data, 1) == 1) { 1208 pci_write_config(sc->dev, data + 4, state, 1); 1209 } 1210 1211 return 0; 1212 } 1213 1214 static int 1215 m3_init(struct sc_info *sc) 1216 { 1217 u_int32_t data, i, size; 1218 u_int8_t reset_state; 1219 1220 M3_LOCK_ASSERT(sc); 1221 M3_DEBUG(CHANGE, ("m3_init\n")); 1222 1223 /* diable legacy emulations. */ 1224 data = pci_read_config(sc->dev, PCI_LEGACY_AUDIO_CTRL, 2); 1225 data |= DISABLE_LEGACY; 1226 pci_write_config(sc->dev, PCI_LEGACY_AUDIO_CTRL, data, 2); 1227 1228 m3_config(sc); 1229 1230 reset_state = m3_assp_halt(sc); 1231 1232 m3_codec_reset(sc); 1233 1234 /* [m3_assp_init] */ 1235 /* zero kernel data */ 1236 size = REV_B_DATA_MEMORY_UNIT_LENGTH * NUM_UNITS_KERNEL_DATA; 1237 for(i = 0 ; i < size / 2 ; i++) { 1238 m3_wr_assp_data(sc, KDATA_BASE_ADDR + i, 0); 1239 } 1240 /* zero mixer data? */ 1241 size = REV_B_DATA_MEMORY_UNIT_LENGTH * NUM_UNITS_KERNEL_DATA; 1242 for(i = 0 ; i < size / 2 ; i++) { 1243 m3_wr_assp_data(sc, KDATA_BASE_ADDR2 + i, 0); 1244 } 1245 /* init dma pointer */ 1246 m3_wr_assp_data(sc, KDATA_CURRENT_DMA, 1247 KDATA_DMA_XFER0); 1248 /* write kernel into code memory */ 1249 size = sizeof(gaw_kernel_vect_code); 1250 for(i = 0 ; i < size / 2; i++) { 1251 m3_wr_assp_code(sc, REV_B_CODE_MEMORY_BEGIN + i, 1252 gaw_kernel_vect_code[i]); 1253 } 1254 /* 1255 * We only have this one client and we know that 0x400 is free in 1256 * our kernel's mem map, so lets just drop it there. It seems that 1257 * the minisrc doesn't need vectors, so we won't bother with them.. 1258 */ 1259 size = sizeof(gaw_minisrc_code_0400); 1260 for(i = 0 ; i < size / 2; i++) { 1261 m3_wr_assp_code(sc, 0x400 + i, gaw_minisrc_code_0400[i]); 1262 } 1263 /* write the coefficients for the low pass filter? */ 1264 size = sizeof(minisrc_lpf); 1265 for(i = 0; i < size / 2 ; i++) { 1266 m3_wr_assp_code(sc,0x400 + MINISRC_COEF_LOC + i, 1267 minisrc_lpf[i]); 1268 } 1269 m3_wr_assp_code(sc, 0x400 + MINISRC_COEF_LOC + size, 0x8000); 1270 /* the minisrc is the only thing on our task list */ 1271 m3_wr_assp_data(sc, KDATA_TASK0, 0x400); 1272 /* init the mixer number */ 1273 m3_wr_assp_data(sc, KDATA_MIXER_TASK_NUMBER, 0); 1274 /* extreme kernel master volume */ 1275 m3_wr_assp_data(sc, KDATA_DAC_LEFT_VOLUME, M3_DEFAULT_VOL); 1276 m3_wr_assp_data(sc, KDATA_DAC_RIGHT_VOLUME, M3_DEFAULT_VOL); 1277 1278 m3_amp_enable(sc); 1279 1280 /* [m3_assp_client_init] (only one client at index 0) */ 1281 for (i=0x1100 ; i<0x1c00 ; i++) { 1282 m3_wr_assp_data(sc, i, 0); /* zero entire dac/adc area */ 1283 } 1284 1285 /* [m3_assp_continue] */ 1286 m3_wr_1(sc, DSP_PORT_CONTROL_REG_B, reset_state | REGB_ENABLE_RESET); 1287 1288 return 0; 1289 } 1290 1291 static int 1292 m3_uninit(struct sc_info *sc) 1293 { 1294 M3_DEBUG(CHANGE, ("m3_uninit\n")); 1295 return 0; 1296 } 1297 1298 /* -------------------------------------------------------------------- */ 1299 /* Probe and attach the card */ 1300 1301 static int 1302 m3_pci_probe(device_t dev) 1303 { 1304 struct m3_card_type *card; 1305 1306 M3_DEBUG(CALL, ("m3_pci_probe(0x%x)\n", pci_get_devid(dev))); 1307 1308 for (card = m3_card_types ; card->pci_id ; card++) { 1309 if (pci_get_devid(dev) == card->pci_id) { 1310 device_set_desc(dev, card->name); 1311 return BUS_PROBE_DEFAULT; 1312 } 1313 } 1314 return ENXIO; 1315 } 1316 1317 static int 1318 m3_pci_attach(device_t dev) 1319 { 1320 struct sc_info *sc; 1321 struct ac97_info *codec = NULL; 1322 char status[SND_STATUSLEN]; 1323 struct m3_card_type *card; 1324 int i, len, dacn, adcn; 1325 1326 M3_DEBUG(CALL, ("m3_pci_attach\n")); 1327 1328 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 1329 sc->dev = dev; 1330 sc->type = pci_get_devid(dev); 1331 sc->sc_lock = snd_mtxcreate(device_get_nameunit(dev), 1332 "snd_maestro3 softc"); 1333 for (card = m3_card_types ; card->pci_id ; card++) { 1334 if (sc->type == card->pci_id) { 1335 sc->which = card->which; 1336 sc->delay1 = card->delay1; 1337 sc->delay2 = card->delay2; 1338 break; 1339 } 1340 } 1341 1342 if (resource_int_value(device_get_name(dev), device_get_unit(dev), 1343 "dac", &i) == 0) { 1344 if (i < 1) 1345 dacn = 1; 1346 else if (i > M3_PCHANS) 1347 dacn = M3_PCHANS; 1348 else 1349 dacn = i; 1350 } else 1351 dacn = M3_PCHANS; 1352 1353 adcn = M3_RCHANS; 1354 1355 pci_enable_busmaster(dev); 1356 1357 sc->regid = PCIR_BAR(0); 1358 sc->regtype = SYS_RES_MEMORY; 1359 sc->reg = bus_alloc_resource_any(dev, sc->regtype, &sc->regid, 1360 RF_ACTIVE); 1361 if (!sc->reg) { 1362 sc->regtype = SYS_RES_IOPORT; 1363 sc->reg = bus_alloc_resource_any(dev, sc->regtype, &sc->regid, 1364 RF_ACTIVE); 1365 } 1366 if (!sc->reg) { 1367 device_printf(dev, "unable to allocate register space\n"); 1368 goto bad; 1369 } 1370 sc->st = rman_get_bustag(sc->reg); 1371 sc->sh = rman_get_bushandle(sc->reg); 1372 1373 sc->irqid = 0; 1374 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid, 1375 RF_ACTIVE | RF_SHAREABLE); 1376 if (!sc->irq) { 1377 device_printf(dev, "unable to allocate interrupt\n"); 1378 goto bad; 1379 } 1380 1381 if (snd_setup_intr(dev, sc->irq, INTR_MPSAFE, m3_intr, sc, &sc->ih)) { 1382 device_printf(dev, "unable to setup interrupt\n"); 1383 goto bad; 1384 } 1385 1386 sc->bufsz = pcm_getbuffersize(dev, M3_BUFSIZE_MIN, M3_BUFSIZE_DEFAULT, 1387 M3_BUFSIZE_MAX); 1388 1389 if (bus_dma_tag_create( 1390 bus_get_dma_tag(dev), /* parent */ 1391 2, 0, /* alignment, boundary */ 1392 M3_MAXADDR, /* lowaddr */ 1393 BUS_SPACE_MAXADDR, /* highaddr */ 1394 NULL, NULL, /* filtfunc, filtfuncarg */ 1395 sc->bufsz, /* maxsize */ 1396 1, /* nsegments */ 1397 0x3ffff, /* maxsegz */ 1398 0, /* flags */ 1399 NULL, /* lockfunc */ 1400 NULL, /* lockfuncarg */ 1401 &sc->parent_dmat) != 0) { 1402 device_printf(dev, "unable to create dma tag\n"); 1403 goto bad; 1404 } 1405 1406 M3_LOCK(sc); 1407 m3_power(sc, 0); /* power up */ 1408 /* init chip */ 1409 i = m3_init(sc); 1410 M3_UNLOCK(sc); 1411 if (i == -1) { 1412 device_printf(dev, "unable to initialize the card\n"); 1413 goto bad; 1414 } 1415 1416 /* create/init mixer */ 1417 codec = AC97_CREATE(dev, sc, m3_codec); 1418 if (codec == NULL) { 1419 device_printf(dev, "ac97_create error\n"); 1420 goto bad; 1421 } 1422 if (mixer_init(dev, ac97_getmixerclass(), codec)) { 1423 device_printf(dev, "mixer_init error\n"); 1424 goto bad; 1425 } 1426 1427 m3_enable_ints(sc); 1428 1429 if (pcm_register(dev, sc, dacn, adcn)) { 1430 device_printf(dev, "pcm_register error\n"); 1431 goto bad; 1432 } 1433 for (i=0 ; i<dacn ; i++) { 1434 if (pcm_addchan(dev, PCMDIR_PLAY, &m3_pch_class, sc)) { 1435 device_printf(dev, "pcm_addchan (play) error\n"); 1436 goto bad; 1437 } 1438 } 1439 for (i=0 ; i<adcn ; i++) { 1440 if (pcm_addchan(dev, PCMDIR_REC, &m3_rch_class, sc)) { 1441 device_printf(dev, "pcm_addchan (rec) error\n"); 1442 goto bad; 1443 } 1444 } 1445 snprintf(status, SND_STATUSLEN, "at %s 0x%jx irq %jd %s", 1446 (sc->regtype == SYS_RES_IOPORT)? "io" : "memory", 1447 rman_get_start(sc->reg), rman_get_start(sc->irq), 1448 PCM_KLDSTRING(snd_maestro3)); 1449 if (pcm_setstatus(dev, status)) { 1450 device_printf(dev, "attach: pcm_setstatus error\n"); 1451 goto bad; 1452 } 1453 1454 mixer_hwvol_init(dev); 1455 1456 /* Create the buffer for saving the card state during suspend */ 1457 len = sizeof(u_int16_t) * (REV_B_CODE_MEMORY_LENGTH + 1458 REV_B_DATA_MEMORY_LENGTH); 1459 sc->savemem = (u_int16_t*)malloc(len, M_DEVBUF, M_WAITOK | M_ZERO); 1460 1461 return 0; 1462 1463 bad: 1464 if (codec) 1465 ac97_destroy(codec); 1466 if (sc->ih) 1467 bus_teardown_intr(dev, sc->irq, sc->ih); 1468 if (sc->irq) 1469 bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq); 1470 if (sc->reg) 1471 bus_release_resource(dev, sc->regtype, sc->regid, sc->reg); 1472 if (sc->parent_dmat) 1473 bus_dma_tag_destroy(sc->parent_dmat); 1474 if (sc->sc_lock) 1475 snd_mtxfree(sc->sc_lock); 1476 free(sc, M_DEVBUF); 1477 return ENXIO; 1478 } 1479 1480 static int 1481 m3_pci_detach(device_t dev) 1482 { 1483 struct sc_info *sc = pcm_getdevinfo(dev); 1484 int r; 1485 1486 M3_DEBUG(CALL, ("m3_pci_detach\n")); 1487 1488 if ((r = pcm_unregister(dev)) != 0) { 1489 return r; 1490 } 1491 1492 M3_LOCK(sc); 1493 m3_uninit(sc); /* shutdown chip */ 1494 m3_power(sc, 3); /* power off */ 1495 M3_UNLOCK(sc); 1496 1497 bus_teardown_intr(dev, sc->irq, sc->ih); 1498 bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq); 1499 bus_release_resource(dev, sc->regtype, sc->regid, sc->reg); 1500 bus_dma_tag_destroy(sc->parent_dmat); 1501 1502 free(sc->savemem, M_DEVBUF); 1503 snd_mtxfree(sc->sc_lock); 1504 free(sc, M_DEVBUF); 1505 return 0; 1506 } 1507 1508 static int 1509 m3_pci_suspend(device_t dev) 1510 { 1511 struct sc_info *sc = pcm_getdevinfo(dev); 1512 int i, index = 0; 1513 1514 M3_DEBUG(CHANGE, ("m3_pci_suspend\n")); 1515 1516 M3_LOCK(sc); 1517 for (i=0 ; i<sc->pch_cnt ; i++) { 1518 if (sc->pch[i].active) { 1519 m3_pchan_trigger_locked(NULL, &sc->pch[i], 1520 PCMTRIG_STOP); 1521 } 1522 } 1523 for (i=0 ; i<sc->rch_cnt ; i++) { 1524 if (sc->rch[i].active) { 1525 m3_rchan_trigger_locked(NULL, &sc->rch[i], 1526 PCMTRIG_STOP); 1527 } 1528 } 1529 DELAY(10 * 1000); /* give things a chance to stop */ 1530 1531 /* Disable interrupts */ 1532 m3_wr_2(sc, HOST_INT_CTRL, 0); 1533 m3_wr_1(sc, ASSP_CONTROL_C, 0); 1534 1535 m3_assp_halt(sc); 1536 1537 /* Save the state of the ASSP */ 1538 for (i = REV_B_CODE_MEMORY_BEGIN; i <= REV_B_CODE_MEMORY_END; i++) 1539 sc->savemem[index++] = m3_rd_assp_code(sc, i); 1540 for (i = REV_B_DATA_MEMORY_BEGIN; i <= REV_B_DATA_MEMORY_END; i++) 1541 sc->savemem[index++] = m3_rd_assp_data(sc, i); 1542 1543 /* Power down the card to D3 state */ 1544 m3_power(sc, 3); 1545 M3_UNLOCK(sc); 1546 1547 return 0; 1548 } 1549 1550 static int 1551 m3_pci_resume(device_t dev) 1552 { 1553 struct sc_info *sc = pcm_getdevinfo(dev); 1554 int i, index = 0; 1555 u_int8_t reset_state; 1556 1557 M3_DEBUG(CHANGE, ("m3_pci_resume\n")); 1558 1559 M3_LOCK(sc); 1560 /* Power the card back to D0 */ 1561 m3_power(sc, 0); 1562 1563 m3_config(sc); 1564 1565 reset_state = m3_assp_halt(sc); 1566 1567 m3_codec_reset(sc); 1568 1569 /* Restore the ASSP state */ 1570 for (i = REV_B_CODE_MEMORY_BEGIN; i <= REV_B_CODE_MEMORY_END; i++) 1571 m3_wr_assp_code(sc, i, sc->savemem[index++]); 1572 for (i = REV_B_DATA_MEMORY_BEGIN; i <= REV_B_DATA_MEMORY_END; i++) 1573 m3_wr_assp_data(sc, i, sc->savemem[index++]); 1574 1575 /* Restart the DMA engine */ 1576 m3_wr_assp_data(sc, KDATA_DMA_ACTIVE, 0); 1577 1578 /* [m3_assp_continue] */ 1579 m3_wr_1(sc, DSP_PORT_CONTROL_REG_B, reset_state | REGB_ENABLE_RESET); 1580 1581 m3_amp_enable(sc); 1582 1583 m3_enable_ints(sc); 1584 1585 M3_UNLOCK(sc); /* XXX */ 1586 if (mixer_reinit(dev) == -1) { 1587 device_printf(dev, "unable to reinitialize the mixer\n"); 1588 return (ENXIO); 1589 } 1590 M3_LOCK(sc); 1591 1592 /* Turn the channels back on */ 1593 for (i=0 ; i<sc->pch_cnt ; i++) { 1594 if (sc->pch[i].active) { 1595 m3_pchan_trigger_locked(NULL, &sc->pch[i], 1596 PCMTRIG_START); 1597 } 1598 } 1599 for (i=0 ; i<sc->rch_cnt ; i++) { 1600 if (sc->rch[i].active) { 1601 m3_rchan_trigger_locked(NULL, &sc->rch[i], 1602 PCMTRIG_START); 1603 } 1604 } 1605 1606 M3_UNLOCK(sc); 1607 return 0; 1608 } 1609 1610 static int 1611 m3_pci_shutdown(device_t dev) 1612 { 1613 struct sc_info *sc = pcm_getdevinfo(dev); 1614 1615 M3_DEBUG(CALL, ("m3_pci_shutdown\n")); 1616 1617 M3_LOCK(sc); 1618 m3_power(sc, 3); /* power off */ 1619 M3_UNLOCK(sc); 1620 1621 return 0; 1622 } 1623 1624 static u_int8_t 1625 m3_assp_halt(struct sc_info *sc) 1626 { 1627 u_int8_t data, reset_state; 1628 1629 M3_LOCK_ASSERT(sc); 1630 1631 data = m3_rd_1(sc, DSP_PORT_CONTROL_REG_B); 1632 reset_state = data & ~REGB_STOP_CLOCK; /* remember for continue */ 1633 DELAY(10 * 1000); 1634 m3_wr_1(sc, DSP_PORT_CONTROL_REG_B, reset_state & ~REGB_ENABLE_RESET); 1635 DELAY(10 * 1000); /* necessary? */ 1636 1637 return reset_state; 1638 } 1639 1640 static void 1641 m3_config(struct sc_info *sc) 1642 { 1643 u_int32_t data, hv_cfg; 1644 int hint; 1645 1646 M3_LOCK_ASSERT(sc); 1647 1648 M3_UNLOCK(sc); 1649 /* 1650 * The volume buttons can be wired up via two different sets of pins. 1651 * This presents a problem since we can't tell which way it's 1652 * configured. Allow the user to set a hint in order to twiddle 1653 * the proper bits. 1654 */ 1655 if (resource_int_value(device_get_name(sc->dev), 1656 device_get_unit(sc->dev), 1657 "hwvol_config", &hint) == 0) 1658 hv_cfg = (hint > 0) ? HV_BUTTON_FROM_GD : 0; 1659 else 1660 hv_cfg = HV_BUTTON_FROM_GD; 1661 M3_LOCK(sc); 1662 1663 data = pci_read_config(sc->dev, PCI_ALLEGRO_CONFIG, 4); 1664 data &= ~HV_BUTTON_FROM_GD; 1665 data |= REDUCED_DEBOUNCE | HV_CTRL_ENABLE | hv_cfg; 1666 data |= PM_CTRL_ENABLE | CLK_DIV_BY_49 | USE_PCI_TIMING; 1667 pci_write_config(sc->dev, PCI_ALLEGRO_CONFIG, data, 4); 1668 1669 m3_wr_1(sc, ASSP_CONTROL_B, RESET_ASSP); 1670 data = pci_read_config(sc->dev, PCI_ALLEGRO_CONFIG, 4); 1671 data &= ~INT_CLK_SELECT; 1672 if (sc->which == ESS_MAESTRO3) { 1673 data &= ~INT_CLK_MULT_ENABLE; 1674 data |= INT_CLK_SRC_NOT_PCI; 1675 } 1676 data &= ~(CLK_MULT_MODE_SELECT | CLK_MULT_MODE_SELECT_2); 1677 pci_write_config(sc->dev, PCI_ALLEGRO_CONFIG, data, 4); 1678 1679 if (sc->which == ESS_ALLEGRO_1) { 1680 data = pci_read_config(sc->dev, PCI_USER_CONFIG, 4); 1681 data |= IN_CLK_12MHZ_SELECT; 1682 pci_write_config(sc->dev, PCI_USER_CONFIG, data, 4); 1683 } 1684 1685 data = m3_rd_1(sc, ASSP_CONTROL_A); 1686 data &= ~(DSP_CLK_36MHZ_SELECT | ASSP_CLK_49MHZ_SELECT); 1687 data |= ASSP_CLK_49MHZ_SELECT; /*XXX assumes 49MHZ dsp XXX*/ 1688 data |= ASSP_0_WS_ENABLE; 1689 m3_wr_1(sc, ASSP_CONTROL_A, data); 1690 1691 m3_wr_1(sc, ASSP_CONTROL_B, RUN_ASSP); 1692 } 1693 1694 static void 1695 m3_enable_ints(struct sc_info *sc) 1696 { 1697 u_int8_t data; 1698 1699 m3_wr_2(sc, HOST_INT_CTRL, ASSP_INT_ENABLE | HV_INT_ENABLE); 1700 data = m3_rd_1(sc, ASSP_CONTROL_C); 1701 m3_wr_1(sc, ASSP_CONTROL_C, data | ASSP_HOST_INT_ENABLE); 1702 } 1703 1704 static void 1705 m3_amp_enable(struct sc_info *sc) 1706 { 1707 u_int32_t gpo, polarity_port, polarity; 1708 u_int16_t data; 1709 1710 M3_LOCK_ASSERT(sc); 1711 1712 switch (sc->which) { 1713 case ESS_ALLEGRO_1: 1714 polarity_port = 0x1800; 1715 break; 1716 case ESS_MAESTRO3: 1717 polarity_port = 0x1100; 1718 break; 1719 default: 1720 panic("bad sc->which"); 1721 } 1722 gpo = (polarity_port >> 8) & 0x0f; 1723 polarity = polarity_port >> 12; 1724 polarity = !polarity; /* enable */ 1725 polarity = polarity << gpo; 1726 gpo = 1 << gpo; 1727 m3_wr_2(sc, GPIO_MASK, ~gpo); 1728 data = m3_rd_2(sc, GPIO_DIRECTION); 1729 m3_wr_2(sc, GPIO_DIRECTION, data | gpo); 1730 data = GPO_SECONDARY_AC97 | GPO_PRIMARY_AC97 | polarity; 1731 m3_wr_2(sc, GPIO_DATA, data); 1732 m3_wr_2(sc, GPIO_MASK, ~0); 1733 } 1734 1735 static void 1736 m3_codec_reset(struct sc_info *sc) 1737 { 1738 u_int16_t data, dir; 1739 int retry = 0; 1740 1741 M3_LOCK_ASSERT(sc); 1742 do { 1743 data = m3_rd_2(sc, GPIO_DIRECTION); 1744 dir = data | 0x10; /* assuming pci bus master? */ 1745 1746 /* [[remote_codec_config]] */ 1747 data = m3_rd_2(sc, RING_BUS_CTRL_B); 1748 m3_wr_2(sc, RING_BUS_CTRL_B, data & ~SECOND_CODEC_ID_MASK); 1749 data = m3_rd_2(sc, SDO_OUT_DEST_CTRL); 1750 m3_wr_2(sc, SDO_OUT_DEST_CTRL, data & ~COMMAND_ADDR_OUT); 1751 data = m3_rd_2(sc, SDO_IN_DEST_CTRL); 1752 m3_wr_2(sc, SDO_IN_DEST_CTRL, data & ~STATUS_ADDR_IN); 1753 1754 m3_wr_2(sc, RING_BUS_CTRL_A, IO_SRAM_ENABLE); 1755 DELAY(20); 1756 1757 m3_wr_2(sc, GPIO_DIRECTION, dir & ~GPO_PRIMARY_AC97); 1758 m3_wr_2(sc, GPIO_MASK, ~GPO_PRIMARY_AC97); 1759 m3_wr_2(sc, GPIO_DATA, 0); 1760 m3_wr_2(sc, GPIO_DIRECTION, dir | GPO_PRIMARY_AC97); 1761 DELAY(sc->delay1 * 1000); /*delay1 (ALLEGRO:50, MAESTRO3:20)*/ 1762 m3_wr_2(sc, GPIO_DATA, GPO_PRIMARY_AC97); 1763 DELAY(5); 1764 m3_wr_2(sc, RING_BUS_CTRL_A, IO_SRAM_ENABLE | 1765 SERIAL_AC_LINK_ENABLE); 1766 m3_wr_2(sc, GPIO_MASK, ~0); 1767 DELAY(sc->delay2 * 1000); /*delay2 (ALLEGRO:800, MAESTRO3:500)*/ 1768 1769 /* [[try read vendor]] */ 1770 data = m3_rdcd(NULL, sc, 0x7c); 1771 if ((data == 0) || (data == 0xffff)) { 1772 retry++; 1773 if (retry > 3) { 1774 device_printf(sc->dev, "Codec reset failed\n"); 1775 break; 1776 } 1777 device_printf(sc->dev, "Codec reset retry\n"); 1778 } else retry = 0; 1779 } while (retry); 1780 } 1781 1782 static device_method_t m3_methods[] = { 1783 DEVMETHOD(device_probe, m3_pci_probe), 1784 DEVMETHOD(device_attach, m3_pci_attach), 1785 DEVMETHOD(device_detach, m3_pci_detach), 1786 DEVMETHOD(device_suspend, m3_pci_suspend), 1787 DEVMETHOD(device_resume, m3_pci_resume), 1788 DEVMETHOD(device_shutdown, m3_pci_shutdown), 1789 { 0, 0 } 1790 }; 1791 1792 static driver_t m3_driver = { 1793 "pcm", 1794 m3_methods, 1795 PCM_SOFTC_SIZE, 1796 }; 1797 1798 DRIVER_MODULE(snd_maestro3, pci, m3_driver, pcm_devclass, 0, 0); 1799 MODULE_DEPEND(snd_maestro3, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 1800 MODULE_VERSION(snd_maestro3, 1); 1801