/* $OpenBSD: auixp.c,v 1.3 2005/11/26 14:31:26 krw Exp $ */ /* $NetBSD: auixp.c,v 1.9 2005/06/27 21:13:09 thorpej Exp $ */ /* * Copyright (c) 2004, 2005 Reinoud Zandijk * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Audio driver for ATI IXP-{150,200,...} audio driver hardware. * * Recording and playback has been tested OK on various sample rates and * encodings. * * Known problems and issues : * - SPDIF is untested and needs some work still (LED stays off) * - 32 bit audio playback failed last time i tried but that might an AC'97 * codec support problem. * - 32 bit recording works but can't try out playing: see above. * - no suspend/resume support yet. * - multiple codecs are `supported' but not tested; the implemetation needs * some cleaning up. */ /*#define DEBUG_AUIXP*/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* codec detection constant indicating the interrupt flags */ #define ALL_CODECS_NOT_READY \ (ATI_REG_ISR_CODEC0_NOT_READY | ATI_REG_ISR_CODEC1_NOT_READY |\ ATI_REG_ISR_CODEC2_NOT_READY) #define CODEC_CHECK_BITS (ALL_CODECS_NOT_READY|ATI_REG_ISR_NEW_FRAME) /* why isn't this base address register not in the headerfile? */ #define PCI_CBIO 0x10 /* macro's used */ #define KERNADDR(p) ((void *)((p)->addr)) #define DMAADDR(p) ((p)->map->dm_segs[0].ds_addr) const struct pci_matchid auixp_pci_devices[] = { { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_200 }, { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_300 }, { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_400 }, }; struct cfdriver auixp_cd = { NULL, "auixp", DV_DULL }; int auixp_match( struct device *, void *, void *); void auixp_attach(struct device *, struct device *, void *); int auixp_detach(struct device *, int); struct cfattach auixp_ca = { sizeof(struct auixp_softc), auixp_match, auixp_attach }; int auixp_open(void *v, int flags); void auixp_close(void *v); int auixp_query_encoding(void *, struct audio_encoding *); int auixp_set_params(void *, int, int, struct audio_params *, struct audio_params *); int auixp_commit_settings(void *); int auixp_round_blocksize(void *, int); int auixp_trigger_output(void *, void *, void *, int, void (*)(void *), void *, struct audio_params *); int auixp_trigger_input(void *, void *, void *, int, void (*)(void *), void *, struct audio_params *); int auixp_halt_output(void *); int auixp_halt_input(void *); int auixp_set_port(void *, mixer_ctrl_t *); int auixp_get_port(void *, mixer_ctrl_t *); int auixp_query_devinfo(void *, mixer_devinfo_t *); void * auixp_malloc(void *, int, size_t, int, int); void auixp_free(void *, void *, int); int auixp_getdev(void *, struct audio_device *); size_t auixp_round_buffersize(void *, int, size_t); int auixp_get_props(void *); int auixp_intr(void *); int auixp_allocmem(struct auixp_softc *, size_t, size_t, struct auixp_dma *); int auixp_freemem(struct auixp_softc *, struct auixp_dma *); paddr_t auixp_mappage(void *, void *, off_t, int); /* power management (do we support that already?) */ int auixp_power(struct auixp_softc *, int); #if 0 void auixp_powerhook(int, void *); int auixp_suspend(struct auixp_softc *); int auixp_resume(struct auixp_softc *); #endif /* Supporting subroutines */ int auixp_init(struct auixp_softc *); void auixp_autodetect_codecs(struct auixp_softc *); void auixp_post_config(void *); void auixp_reset_aclink(struct auixp_softc *); int auixp_attach_codec(void *, struct ac97_codec_if *); int auixp_read_codec(void *, u_int8_t, u_int16_t *); int auixp_write_codec(void *, u_int8_t, u_int16_t); int auixp_wait_for_codecs(struct auixp_softc *, const char *); void auixp_reset_codec(void *); enum ac97_host_flags auixp_flags_codec(void *); void auixp_enable_dma(struct auixp_softc *, struct auixp_dma *); void auixp_disable_dma(struct auixp_softc *, struct auixp_dma *); void auixp_enable_interrupts(struct auixp_softc *); void auixp_disable_interrupts(struct auixp_softc *); void auixp_link_daisychain(struct auixp_softc *, struct auixp_dma *, struct auixp_dma *, int, int); int auixp_allocate_dma_chain(struct auixp_softc *, struct auixp_dma **); void auixp_program_dma_chain(struct auixp_softc *, struct auixp_dma *); void auixp_dma_update(struct auixp_softc *, struct auixp_dma *); void auixp_update_busbusy(struct auixp_softc *); #ifdef DEBUG_AUIXP #define DPRINTF(x) printf x; #else #define DPRINTF(x) #endif struct audio_hw_if auixp_hw_if = { auixp_open, auixp_close, NULL, /* drain */ auixp_query_encoding, auixp_set_params, auixp_round_blocksize, auixp_commit_settings, NULL, /* init_output */ NULL, /* init_input */ NULL, /* start_output */ NULL, /* start_input */ auixp_halt_output, auixp_halt_input, NULL, /* speaker_ctl */ auixp_getdev, NULL, /* getfd */ auixp_set_port, auixp_get_port, auixp_query_devinfo, auixp_malloc, auixp_free, auixp_round_buffersize, auixp_mappage, auixp_get_props, auixp_trigger_output, auixp_trigger_input }; int auixp_open(void *v, int flags) { return 0; } void auixp_close(void *v) { } int auixp_query_encoding(void *hdl, struct audio_encoding *aep) { switch (aep->index) { case 0: strlcpy(aep->name, AudioEulinear, sizeof aep->name); aep->encoding = AUDIO_ENCODING_ULINEAR; aep->precision = 8; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 1: strlcpy(aep->name, AudioEmulaw, sizeof aep->name); aep->encoding = AUDIO_ENCODING_ULAW; aep->precision = 8; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 2: strlcpy(aep->name, AudioEalaw, sizeof aep->name); aep->encoding = AUDIO_ENCODING_ALAW; aep->precision = 8; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 3: strlcpy(aep->name, AudioEslinear, sizeof aep->name); aep->encoding = AUDIO_ENCODING_SLINEAR; aep->precision = 8; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 4: strlcpy(aep->name, AudioEslinear_le, sizeof aep->name); aep->encoding = AUDIO_ENCODING_SLINEAR_LE; aep->precision = 16; aep->flags = 0; return (0); case 5: strlcpy(aep->name, AudioEulinear_le, sizeof aep->name); aep->encoding = AUDIO_ENCODING_ULINEAR_LE; aep->precision = 16; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 6: strlcpy(aep->name, AudioEslinear_be, sizeof aep->name); aep->encoding = AUDIO_ENCODING_SLINEAR_BE; aep->precision = 16; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); case 7: strlcpy(aep->name, AudioEulinear_be, sizeof aep->name); aep->encoding = AUDIO_ENCODING_ULINEAR_BE; aep->precision = 16; aep->flags = AUDIO_ENCODINGFLAG_EMULATED; return (0); default: return (EINVAL); } } /* commit setting and program ATI IXP chip */ int auixp_commit_settings(void *hdl) { struct auixp_codec *co; struct auixp_softc *sc; bus_space_tag_t iot; bus_space_handle_t ioh; struct audio_params *params; u_int32_t value; /* XXX would it be better to stop interrupts first? XXX */ co = (struct auixp_codec *) hdl; sc = co->sc; iot = sc->sc_iot; ioh = sc->sc_ioh; /* process input settings */ params = &sc->sc_play_params; /* set input interleaving (precision) */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value &= ~ATI_REG_CMD_INTERLEAVE_IN; if (params->precision <= 16) value |= ATI_REG_CMD_INTERLEAVE_IN; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* process output settings */ params = &sc->sc_play_params; value = bus_space_read_4(iot, ioh, ATI_REG_OUT_DMA_SLOT); value &= ~ATI_REG_OUT_DMA_SLOT_MASK; /* TODO SPDIF case for 8 channels */ switch (params->channels) { case 6: value |= ATI_REG_OUT_DMA_SLOT_BIT(7) | ATI_REG_OUT_DMA_SLOT_BIT(8); /* FALLTHRU */ case 4: value |= ATI_REG_OUT_DMA_SLOT_BIT(6) | ATI_REG_OUT_DMA_SLOT_BIT(9); /* FALLTHRU */ default: value |= ATI_REG_OUT_DMA_SLOT_BIT(3) | ATI_REG_OUT_DMA_SLOT_BIT(4); break; } /* set output threshold */ value |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT; bus_space_write_4(iot, ioh, ATI_REG_OUT_DMA_SLOT, value); /* set output interleaving (precision) */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value &= ~ATI_REG_CMD_INTERLEAVE_OUT; if (params->precision <= 16) value |= ATI_REG_CMD_INTERLEAVE_OUT; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* enable 6 channel reordering */ value = bus_space_read_4(iot, ioh, ATI_REG_6CH_REORDER); value &= ~ATI_REG_6CH_REORDER_EN; if (params->channels == 6) value |= ATI_REG_6CH_REORDER_EN; bus_space_write_4(iot, ioh, ATI_REG_6CH_REORDER, value); if (sc->has_spdif) { /* set SPDIF (if present) */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value &= ~ATI_REG_CMD_SPDF_CONFIG_MASK; value |= ATI_REG_CMD_SPDF_CONFIG_34; /* NetBSD AC'97 default */ /* XXX this prolly is not nessisary unless splitted XXX */ value &= ~ATI_REG_CMD_INTERLEAVE_SPDF; if (params->precision <= 16) value |= ATI_REG_CMD_INTERLEAVE_SPDF; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); } return 0; } /* set audio properties in desired setting */ int auixp_set_params(void *hdl, int setmode, int usemode, struct audio_params *play, struct audio_params *rec) { struct auixp_codec *co; struct auixp_softc *sc; int error; co = (struct auixp_codec *) hdl; sc = co->sc; if (setmode & AUMODE_PLAY) { play->factor = 1; play->sw_code = NULL; switch(play->encoding) { case AUDIO_ENCODING_ULAW: switch (play->channels) { case 1: play->factor = 4; play->sw_code = mulaw_to_slinear16_mts; break; case 2: play->factor = 2; play->sw_code = mulaw_to_slinear16; break; default: return (EINVAL); } break; case AUDIO_ENCODING_SLINEAR_LE: switch (play->precision) { case 8: switch (play->channels) { case 1: play->factor = 4; play->sw_code = linear8_to_linear16_mts; break; case 2: play->factor = 2; play->sw_code = linear8_to_linear16; break; default: return (EINVAL); } break; case 16: switch (play->channels) { case 1: play->factor = 2; play->sw_code = noswap_bytes_mts; break; case 2: break; default: return (EINVAL); } break; default: return (EINVAL); } break; case AUDIO_ENCODING_ULINEAR_LE: switch (play->precision) { case 8: switch (play->channels) { case 1: play->factor = 4; play->sw_code = ulinear8_to_linear16_mts; break; case 2: play->factor = 2; play->sw_code = ulinear8_to_linear16; break; default: return (EINVAL); } break; case 16: switch (play->channels) { case 1: play->factor = 2; play->sw_code = change_sign16_mts; break; case 2: play->sw_code = change_sign16; break; default: return (EINVAL); } break; default: return (EINVAL); } break; case AUDIO_ENCODING_ALAW: switch (play->channels) { case 1: play->factor = 4; play->sw_code = alaw_to_slinear16_mts; break; case 2: play->factor = 2; play->sw_code = alaw_to_slinear16; break; default: return (EINVAL); } break; case AUDIO_ENCODING_SLINEAR_BE: switch (play->precision) { case 8: switch (play->channels) { case 1: play->factor = 4; play->sw_code = linear8_to_linear16_mts; break; case 2: play->factor = 2; play->sw_code = linear8_to_linear16; break; default: return (EINVAL); } break; case 16: switch (play->channels) { case 1: play->factor = 2; play->sw_code = swap_bytes_mts; break; case 2: play->sw_code = swap_bytes; break; default: return (EINVAL); } break; default: return (EINVAL); } break; case AUDIO_ENCODING_ULINEAR_BE: switch (play->precision) { case 8: switch (play->channels) { case 1: play->factor = 4; play->sw_code = ulinear8_to_linear16_mts; break; case 2: play->factor = 2; play->sw_code = ulinear8_to_linear16; break; default: return (EINVAL); } break; case 16: switch (play->channels) { case 1: play->factor = 2; play->sw_code = change_sign16_swap_bytes_mts; break; case 2: play->sw_code = change_sign16_swap_bytes; break; default: return (EINVAL); } break; default: return (EINVAL); } break; default: return (EINVAL); } error = ac97_set_rate(co->codec_if, play, AUMODE_PLAY); if (error) return (error); } if (setmode & AUMODE_RECORD) { rec->factor = 1; rec->sw_code = 0; switch(rec->encoding) { case AUDIO_ENCODING_ULAW: rec->sw_code = ulinear8_to_mulaw; break; case AUDIO_ENCODING_SLINEAR_LE: if (rec->precision == 8) rec->sw_code = change_sign8; break; case AUDIO_ENCODING_ULINEAR_LE: if (rec->precision == 16) rec->sw_code = change_sign16; break; case AUDIO_ENCODING_ALAW: rec->sw_code = ulinear8_to_alaw; break; case AUDIO_ENCODING_SLINEAR_BE: if (rec->precision == 16) rec->sw_code = swap_bytes; else rec->sw_code = change_sign8; break; case AUDIO_ENCODING_ULINEAR_BE: if (rec->precision == 16) rec->sw_code = swap_bytes_change_sign16; break; default: return (EINVAL); } error = ac97_set_rate(co->codec_if, rec, AUMODE_RECORD); if (error) return (error); } return (0); } /* called to translate a requested blocksize to a hw-possible one */ int auixp_round_blocksize(void *v, int blk) { blk = (blk + 0x1f) & ~0x1f; /* Be conservative; align to 32 bytes and maximise it to 64 kb */ if (blk > 0x10000) blk = 0x10000; return blk; } /* * allocate dma capable memory and record its information for later retrieval * when we program the dma chain itself. The trigger routines passes on the * kernel virtual address we return here as a reference to the mapping. */ void * auixp_malloc(void *hdl, int direction, size_t size, int pool, int flags) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *dma; int error; co = (struct auixp_codec *) hdl; sc = co->sc; /* get us a auixp_dma structure */ dma = malloc(sizeof(*dma), pool, flags); if (!dma) return NULL; /* get us a dma buffer itself */ error = auixp_allocmem(sc, size, 16, dma); if (error) { free(dma, pool); printf("%s: auixp_malloc: not enough memory\n", sc->sc_dev.dv_xname); return NULL; } SLIST_INSERT_HEAD(&sc->sc_dma_list, dma, dma_chain); DPRINTF(("auixp_malloc: returning kern %p, hw 0x%08x for %d bytes " "in %d segs\n", KERNADDR(dma), (u_int32_t) DMAADDR(dma), dma->size, dma->nsegs) ); return KERNADDR(dma); } /* * free and release dma capable memory we allocated before and remove its * recording */ void auixp_free(void *hdl, void *addr, int pool) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *dma; co = (struct auixp_codec *) hdl; sc = co->sc; SLIST_FOREACH(dma, &sc->sc_dma_list, dma_chain) { if (KERNADDR(dma) == addr) { SLIST_REMOVE(&sc->sc_dma_list, dma, auixp_dma, dma_chain); auixp_freemem(sc, dma); free(dma, pool); return; } } } int auixp_getdev(void *v, struct audio_device *adp) { struct auixp_softc *sc = v; *adp = sc->sc_audev; return 0; } /* pass request to AC'97 codec code */ int auixp_set_port(void *hdl, mixer_ctrl_t *mc) { struct auixp_codec *co; co = (struct auixp_codec *) hdl; return co->codec_if->vtbl->mixer_set_port(co->codec_if, mc); } /* pass request to AC'97 codec code */ int auixp_get_port(void *hdl, mixer_ctrl_t *mc) { struct auixp_codec *co; co = (struct auixp_codec *) hdl; return co->codec_if->vtbl->mixer_get_port(co->codec_if, mc); } /* pass request to AC'97 codec code */ int auixp_query_devinfo(void *hdl, mixer_devinfo_t *di) { struct auixp_codec *co; co = (struct auixp_codec *) hdl; return co->codec_if->vtbl->query_devinfo(co->codec_if, di); } size_t auixp_round_buffersize(void *hdl, int direction, size_t bufsize) { /* XXX force maximum? i.e. 256 kb? */ return bufsize; } int auixp_get_props(void *hdl) { return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX; } /* * A dma descriptor has dma->nsegs segments defined in dma->segs set up when * we claimed the memory. * * Due to our demand for one contiguous DMA area, we only have one segment. A * c_dma structure is about 3 kb for the 256 entries we maximally program * -arbitrary limit AFAIK- so all is most likely to be in one segment/page * anyway. * * XXX ought to implement fragmented dma area XXX * * Note that _v variables depict kernel virtual addresses, _p variables depict * physical addresses. */ void auixp_link_daisychain(struct auixp_softc *sc, struct auixp_dma *c_dma, struct auixp_dma *s_dma, int blksize, int blocks) { atiixp_dma_desc_t *caddr_v, *next_caddr_v; u_int32_t caddr_p, next_caddr_p, saddr_p; int i; /* just make sure we are not changing when its running */ auixp_disable_dma(sc, c_dma); /* setup dma chain start addresses */ caddr_v = KERNADDR(c_dma); caddr_p = DMAADDR(c_dma); saddr_p = DMAADDR(s_dma); /* program the requested number of blocks */ for (i = 0; i < blocks; i++) { /* clear the block just in case */ bzero(caddr_v, sizeof(atiixp_dma_desc_t)); /* round robin the chain dma addresses for its successor */ next_caddr_v = caddr_v + 1; next_caddr_p = caddr_p + sizeof(atiixp_dma_desc_t); if (i == blocks-1) { next_caddr_v = KERNADDR(c_dma); next_caddr_p = DMAADDR(c_dma); } /* fill in the hardware dma chain descriptor in little-endian */ caddr_v->addr = htole32(saddr_p); caddr_v->status = htole16(0); caddr_v->size = htole16((blksize >> 2)); /* in dwords (!!!) */ caddr_v->next = htole32(next_caddr_p); /* advance slot */ saddr_p += blksize; /* XXX assuming contiguous XXX */ caddr_v = next_caddr_v; caddr_p = next_caddr_p; } } int auixp_allocate_dma_chain(struct auixp_softc *sc, struct auixp_dma **dmap) { struct auixp_dma *dma; int error; /* allocate keeper of dma area */ *dmap = NULL; dma = malloc(sizeof(*dma), M_DEVBUF, M_NOWAIT); if (!dma) return ENOMEM; bzero(dma, sizeof(*dma)); /* allocate for daisychain of IXP hardware-dma descriptors */ error = auixp_allocmem(sc, DMA_DESC_CHAIN * sizeof(atiixp_dma_desc_t), 16, dma); if (error) { printf("%s: can't malloc dma descriptor chain\n", sc->sc_dev.dv_xname); return ENOMEM; } /* return info and initialise structure */ dma->intr = NULL; dma->intrarg = NULL; *dmap = dma; return 0; } /* program dma chain in it's link address descriptor */ void auixp_program_dma_chain(struct auixp_softc *sc, struct auixp_dma *dma) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; iot = sc->sc_iot; ioh = sc->sc_ioh; /* get hardware start address of DMA chain and set valid-flag in it */ /* XXX allways at start? XXX */ value = DMAADDR(dma); value = value | ATI_REG_LINKPTR_EN; /* reset linkpointer */ bus_space_write_4(iot, ioh, dma->linkptr, 0); /* reset this DMA engine */ auixp_disable_dma(sc, dma); auixp_enable_dma(sc, dma); /* program new DMA linkpointer */ bus_space_write_4(iot, ioh, dma->linkptr, value); } /* called from interrupt code to signal end of one dma-slot */ void auixp_dma_update(struct auixp_softc *sc, struct auixp_dma *dma) { /* be very paranoid */ if (!dma) panic("auixp: update: dma = NULL"); if (!dma->intr) panic("auixp: update: dma->intr = NULL"); /* request more input from upper layer */ (*dma->intr)(dma->intrarg); } /* * The magic `busbusy' bit that needs to be set when dma is active; allowing * busmastering? */ void auixp_update_busbusy(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; int running; iot = sc->sc_iot; ioh = sc->sc_ioh; /* set bus-busy flag when either recording or playing is performed */ value = bus_space_read_4(iot, ioh, ATI_REG_IER); value &= ~ATI_REG_IER_SET_BUS_BUSY; running = ((sc->sc_output_dma->running) || (sc->sc_input_dma->running)); if (running) value |= ATI_REG_IER_SET_BUS_BUSY; bus_space_write_4(iot, ioh, ATI_REG_IER, value); } /* * Called from upper audio layer to request playing audio, only called once; * audio is refilled by calling the intr() function when space is available * again. */ /* XXX allmost literaly a copy of trigger-input; could be factorised XXX */ int auixp_trigger_output(void *hdl, void *start, void *end, int blksize, void (*intr)(void *), void *intrarg, struct audio_params *param) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *chain_dma; struct auixp_dma *sound_dma; u_int32_t blocks; co = (struct auixp_codec *) hdl; sc = co->sc; chain_dma = sc->sc_output_dma; /* add functions to call back */ chain_dma->intr = intr; chain_dma->intrarg = intrarg; /* * Program output DMA chain with blocks from [start...end] with * blksize fragments. * * NOTE, we can assume its in one block since we asked for it to be in * one contiguous blob; XXX change this? XXX */ blocks = (size_t) (((caddr_t) end) - ((caddr_t) start)) / blksize; /* lookup `start' address in our list of DMA area's */ SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) { if (KERNADDR(sound_dma) == start) break; } /* not ours ? then bail out */ if (!sound_dma) { printf("%s: auixp_trigger_output: bad sound addr %p\n", sc->sc_dev.dv_xname, start); return EINVAL; } /* link round-robin daisychain and program hardware */ auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks); auixp_program_dma_chain(sc, chain_dma); /* mark we are now able to run now */ chain_dma->running = 1; /* update bus-flags; XXX programs more flags XXX */ auixp_update_busbusy(sc); /* callbacks happen in interrupt routine */ return 0; } /* halt output of audio, just disable it's dma and update bus state */ int auixp_halt_output(void *hdl) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *dma; co = (struct auixp_codec *) hdl; sc = co->sc; dma = sc->sc_output_dma; auixp_disable_dma(sc, dma); dma->running = 0; auixp_update_busbusy(sc); return 0; } /* XXX allmost literaly a copy of trigger-output; could be factorised XXX */ int auixp_trigger_input(void *hdl, void *start, void *end, int blksize, void (*intr)(void *), void *intrarg, struct audio_params *param) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *chain_dma; struct auixp_dma *sound_dma; u_int32_t blocks; co = (struct auixp_codec *) hdl; sc = co->sc; chain_dma = sc->sc_input_dma; /* add functions to call back */ chain_dma->intr = intr; chain_dma->intrarg = intrarg; /* * Program output DMA chain with blocks from [start...end] with * blksize fragments. * * NOTE, we can assume its in one block since we asked for it to be in * one contiguous blob; XXX change this? XXX */ blocks = (size_t) (((caddr_t) end) - ((caddr_t) start)) / blksize; /* lookup `start' address in our list of DMA area's */ SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) { if (KERNADDR(sound_dma) == start) break; } /* not ours ? then bail out */ if (!sound_dma) { printf("%s: auixp_trigger_input: bad sound addr %p\n", sc->sc_dev.dv_xname, start); return EINVAL; } /* link round-robin daisychain and program hardware */ auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks); auixp_program_dma_chain(sc, chain_dma); /* mark we are now able to run now */ chain_dma->running = 1; /* update bus-flags; XXX programs more flags XXX */ auixp_update_busbusy(sc); /* callbacks happen in interrupt routine */ return 0; } /* halt sampling audio, just disable it's dma and update bus state */ int auixp_halt_input(void *hdl) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *dma; co = (struct auixp_codec *) hdl; sc = co->sc; dma = sc->sc_output_dma; auixp_disable_dma(sc, dma); dma->running = 0; auixp_update_busbusy(sc); return 0; } /* * IXP audio interrupt handler * * note that we return the number of bits handled; the return value is not * documentated but i saw it implemented in other drivers. Prolly returning a * value > 0 means "i've dealt with it" * */ int auixp_intr(void *softc) { struct auixp_softc *sc; bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t status, enable, detected_codecs; int ret; sc = softc; iot = sc->sc_iot; ioh = sc->sc_ioh; ret = 0; /* get status from the interrupt status register */ status = bus_space_read_4(iot, ioh, ATI_REG_ISR); if (status == 0) return 0; DPRINTF(("%s: (status = %x)\n", sc->sc_dev.dv_xname, status)); /* check DMA UPDATE flags for input & output */ if (status & ATI_REG_ISR_IN_STATUS) { ret++; DPRINTF(("IN_STATUS\n")); auixp_dma_update(sc, sc->sc_input_dma); } if (status & ATI_REG_ISR_OUT_STATUS) { ret++; DPRINTF(("OUT_STATUS\n")); auixp_dma_update(sc, sc->sc_output_dma); } /* XXX XRUN flags not used/needed yet; should i implement it? XXX */ /* acknowledge the interrupts nevertheless */ if (status & ATI_REG_ISR_IN_XRUN) { ret++; DPRINTF(("IN_XRUN\n")); /* auixp_dma_xrun(sc, sc->sc_input_dma); */ } if (status & ATI_REG_ISR_OUT_XRUN) { ret++; DPRINTF(("OUT_XRUN\n")); /* auixp_dma_xrun(sc, sc->sc_output_dma); */ } /* check if we are looking for codec detection */ if (status & CODEC_CHECK_BITS) { ret++; /* mark missing codecs as not ready */ detected_codecs = status & CODEC_CHECK_BITS; sc->sc_codec_not_ready_bits |= detected_codecs; /* disable detected interupt sources */ enable = bus_space_read_4(iot, ioh, ATI_REG_IER); enable &= ~detected_codecs; bus_space_write_4(iot, ioh, ATI_REG_IER, enable); } /* acknowledge interrupt sources */ bus_space_write_4(iot, ioh, ATI_REG_ISR, status); return ret; } /* allocate memory for dma purposes; on failure of any of the steps, roll back */ int auixp_allocmem(struct auixp_softc *sc, size_t size, size_t align, struct auixp_dma *dma) { int error; /* remember size */ dma->size = size; /* allocate DMA safe memory but in just one segment for now :( */ error = bus_dmamem_alloc(sc->sc_dmat, dma->size, align, 0, dma->segs, sizeof(dma->segs) / sizeof(dma->segs[0]), &dma->nsegs, BUS_DMA_NOWAIT); if (error) return error; /* * map allocated memory into kernel virtual address space and keep it * coherent with the CPU. */ error = bus_dmamem_map(sc->sc_dmat, dma->segs, dma->nsegs, dma->size, &dma->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT); if (error) goto free; /* allocate associated dma handle and initialize it. */ error = bus_dmamap_create(sc->sc_dmat, dma->size, 1, dma->size, 0, BUS_DMA_NOWAIT, &dma->map); if (error) goto unmap; /* * load the dma handle with mappings for a dma transfer; all pages * need to be wired. */ error = bus_dmamap_load(sc->sc_dmat, dma->map, dma->addr, dma->size, NULL, BUS_DMA_NOWAIT); if (error) goto destroy; return 0; destroy: bus_dmamap_destroy(sc->sc_dmat, dma->map); unmap: bus_dmamem_unmap(sc->sc_dmat, dma->addr, dma->size); free: bus_dmamem_free(sc->sc_dmat, dma->segs, dma->nsegs); return error; } /* undo dma mapping and release memory allocated */ int auixp_freemem(struct auixp_softc *sc, struct auixp_dma *p) { bus_dmamap_unload(sc->sc_dmat, p->map); bus_dmamap_destroy(sc->sc_dmat, p->map); bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size); bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs); return 0; } /* memory map dma memory */ paddr_t auixp_mappage(void *hdl, void *mem, off_t off, int prot) { struct auixp_codec *co; struct auixp_softc *sc; struct auixp_dma *p; co = (struct auixp_codec *) hdl; sc = co->sc; /* for sanity */ if (off < 0) return -1; /* look up allocated DMA area */ SLIST_FOREACH(p, &sc->sc_dma_list, dma_chain) { if (KERNADDR(p) == mem) break; } /* have we found it ? */ if (!p) return -1; /* return mmap'd region */ return bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nsegs, off, prot, BUS_DMA_WAITOK); } int auixp_match(struct device *dev, void *match, void *aux) { return (pci_matchbyid((struct pci_attach_args *)aux, auixp_pci_devices, sizeof(auixp_pci_devices)/sizeof(auixp_pci_devices[0]))); } void auixp_attach(struct device *parent, struct device *self, void *aux) { struct auixp_softc *sc; struct pci_attach_args *pa; pcitag_t tag; pci_chipset_tag_t pc; pci_intr_handle_t ih; const char *intrstr; int len; sc = (struct auixp_softc *)self; pa = (struct pci_attach_args *)aux; tag = pa->pa_tag; pc = pa->pa_pc; /* map memory; its not sized -> what is the size? max PCI slot size? */ if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_MEM, 0, &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios, 0)) { printf(": can't map memory space\n"); return; } /* Initialize softc */ sc->sc_tag = tag; sc->sc_pct = pc; sc->sc_dmat = pa->pa_dmat; SLIST_INIT(&sc->sc_dma_list); /* get us the auixp_dma structures */ auixp_allocate_dma_chain(sc, &sc->sc_output_dma); auixp_allocate_dma_chain(sc, &sc->sc_input_dma); /* when that fails we are dead in the water */ if (!sc->sc_output_dma || !sc->sc_input_dma) return; /* fill in the missing details about the dma channels. */ /* for output */ sc->sc_output_dma->linkptr = ATI_REG_OUT_DMA_LINKPTR; sc->sc_output_dma->dma_enable_bit = ATI_REG_CMD_OUT_DMA_EN | ATI_REG_CMD_SEND_EN; /* have spdif? then this too! XXX not seeing LED yet! XXX */ if (sc->has_spdif) sc->sc_output_dma->dma_enable_bit |= ATI_REG_CMD_SPDF_OUT_EN; /* and for input */ sc->sc_input_dma->linkptr = ATI_REG_IN_DMA_LINKPTR; sc->sc_input_dma->dma_enable_bit = ATI_REG_CMD_IN_DMA_EN | ATI_REG_CMD_RECEIVE_EN; #if 0 /* could preliminary program DMA chain */ auixp_program_dma_chain(sc, sc->sc_output_dma); auixp_program_dma_chain(sc, sc->sc_input_dma); #endif if (pci_intr_map(pa, &ih)) { printf(": can't map interrupt\n"); return; } intrstr = pci_intr_string(pc, ih); sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, auixp_intr, sc, sc->sc_dev.dv_xname); if (sc->sc_ih == NULL) { printf(": can't establish interrupt"); if (intrstr != NULL) printf(" at %s", intrstr); printf("\n"); return; } printf(": %s\n", intrstr); strlcpy(sc->sc_audev.name, "ATI IXP AC97", sizeof sc->sc_audev.name); snprintf(sc->sc_audev.version, sizeof sc->sc_audev.version, "0x%02x", PCI_REVISION(pa->pa_class)); strlcpy(sc->sc_audev.config, sc->sc_dev.dv_xname, sizeof sc->sc_audev.config); /* power up chip */ auixp_power(sc, PCI_PMCSR_STATE_D0); /* init chip */ if (auixp_init(sc) == -1) { printf("%s: auixp_attach: unable to initialize the card\n", sc->sc_dev.dv_xname); return; } /* XXX set up power hooks; not implemented yet XXX */ len = 1; /* shut up gcc */ #ifdef notyet /* create suspend save area */ len = sizeof(u_int16_t) * (ESA_REV_B_CODE_MEMORY_LENGTH + ESA_REV_B_DATA_MEMORY_LENGTH + 1); sc->savemem = (u_int16_t *)malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); if (sc->savemem == NULL) { printf("%s: unable to allocate suspend buffer\n", sc->sc_dev.dv_xname); return; } sc->powerhook = powerhook_establish(auixp_powerhook, sc); if (sc->powerhook == NULL) printf("%s: WARNING: unable to establish powerhook\n", sc->sc_dev.dv_xname); #endif /* * delay further configuration of codecs and audio after interrupts * are enabled. */ mountroothook_establish(auixp_post_config, self); } /* called from autoconfigure system when interrupts are enabled */ void auixp_post_config(void *self) { struct auixp_softc *sc; struct auixp_codec *codec; int codec_nr; sc = (struct auixp_softc *)self; /* detect the AC97 codecs */ auixp_autodetect_codecs(sc); #if notyet /* copy formats and invalidate entries not suitable for codec0 */ sc->has_4ch = AC97_IS_4CH(codec->codec_if); sc->has_6ch = AC97_IS_6CH(codec->codec_if); sc->is_fixed = AC97_IS_FIXED_RATE(codec->codec_if); sc->has_spdif = AC97_HAS_SPDIF(codec->codec_if); #endif /* attach audio devices for all detected codecs */ for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) { codec = &sc->sc_codec[codec_nr]; if (codec->present) audio_attach_mi(&auixp_hw_if, codec, &sc->sc_dev); } /* done! now enable all interrupts we can service */ auixp_enable_interrupts(sc); } void auixp_enable_interrupts(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; iot = sc->sc_iot; ioh = sc->sc_ioh; /* clear all pending */ bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff); /* enable all relevant interrupt sources we can handle */ value = bus_space_read_4(iot, ioh, ATI_REG_IER); value |= ATI_REG_IER_IO_STATUS_EN; #ifdef notyet value |= ATI_REG_IER_IN_XRUN_EN; value |= ATI_REG_IER_OUT_XRUN_EN; value |= ATI_REG_IER_SPDIF_XRUN_EN; value |= ATI_REG_IER_SPDF_STATUS_EN; #endif bus_space_write_4(iot, ioh, ATI_REG_IER, value); } void auixp_disable_interrupts(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; iot = sc->sc_iot; ioh = sc->sc_ioh; /* disable all interrupt sources */ bus_space_write_4(iot, ioh, ATI_REG_IER, 0); /* clear all pending */ bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff); } /* dismantle what we've set up by undoing setup */ int auixp_detach(struct device *self, int flags) { struct auixp_softc *sc; sc = (struct auixp_softc *)self; /* XXX shouldn't we just reset the chip? XXX */ /* * should we explicitly disable interrupt generation and acknowledge * what's left on? better be safe than sorry. */ auixp_disable_interrupts(sc); /* tear down .... */ config_detach(&sc->sc_dev, flags); /* XXX OK? XXX */ if (sc->sc_ih != NULL) pci_intr_disestablish(sc->sc_pct, sc->sc_ih); if (sc->sc_ios) bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios); if (sc->savemem) free(sc->savemem, M_DEVBUF); return 0; } /* * codec handling * * IXP audio support can have upto 3 codecs! are they chained ? or * alternative outlets with the same audio feed i.e. with different mixer * settings? XXX does NetBSD support more than one audio codec? XXX */ int auixp_attach_codec(void *aux, struct ac97_codec_if *codec_if) { struct auixp_codec *ixp_codec; ixp_codec = aux; ixp_codec->codec_if = codec_if; ixp_codec->present = 1; return 0; } int auixp_read_codec(void *aux, u_int8_t reg, u_int16_t *result) { struct auixp_codec *co; struct auixp_softc *sc; bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t data; int timeout; co = aux; sc = co->sc; iot = sc->sc_iot; ioh = sc->sc_ioh; if (auixp_wait_for_codecs(sc, "read_codec")) return 0xffff; /* build up command for reading codec register */ data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) | ATI_REG_PHYS_OUT_ADDR_EN | ATI_REG_PHYS_OUT_RW | co->codec_nr; bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, data); if (auixp_wait_for_codecs(sc, "read_codec")) return 0xffff; /* wait until codec info is clocked in */ timeout = 500; /* 500*2 usec -> 0.001 sec */ do { data = bus_space_read_4(iot, ioh, ATI_REG_PHYS_IN_ADDR); if (data & ATI_REG_PHYS_IN_READ_FLAG) { DPRINTF(("read ac'97 codec reg 0x%x = 0x%08x\n", reg, data >> ATI_REG_PHYS_IN_DATA_SHIFT)); *result = data >> ATI_REG_PHYS_IN_DATA_SHIFT; return 0; } DELAY(2); timeout--; } while (timeout > 0); if (reg < 0x7c) printf("%s: codec read timeout! (reg %x)\n", sc->sc_dev.dv_xname, reg); return 0xffff; } int auixp_write_codec(void *aux, u_int8_t reg, u_int16_t data) { struct auixp_codec *co; struct auixp_softc *sc; bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; DPRINTF(("write ac'97 codec reg 0x%x = 0x%08x\n", reg, data)); co = aux; sc = co->sc; iot = sc->sc_iot; ioh = sc->sc_ioh; if (auixp_wait_for_codecs(sc, "write_codec")) return -1; /* build up command for writing codec register */ value = (((u_int32_t) data) << ATI_REG_PHYS_OUT_DATA_SHIFT) | (((u_int32_t) reg) << ATI_REG_PHYS_OUT_ADDR_SHIFT) | ATI_REG_PHYS_OUT_ADDR_EN | co->codec_nr; bus_space_write_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR, value); return 0; } void auixp_reset_codec(void *aux) { /* nothing to be done? */ } enum ac97_host_flags auixp_flags_codec(void *aux) { struct auixp_codec *ixp_codec; ixp_codec = aux; return ixp_codec->codec_flags; } int auixp_wait_for_codecs(struct auixp_softc *sc, const char *func) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; int timeout; iot = sc->sc_iot; ioh = sc->sc_ioh; /* wait until all codec transfers are done */ timeout = 500; /* 500*2 usec -> 0.001 sec */ do { value = bus_space_read_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR); if ((value & ATI_REG_PHYS_OUT_ADDR_EN) == 0) return 0; DELAY(2); timeout--; } while (timeout > 0); printf("%s: %s: timed out\n", func, sc->sc_dev.dv_xname); return -1; } void auixp_autodetect_codecs(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; struct auixp_codec *codec; int timeout, codec_nr; iot = sc->sc_iot; ioh = sc->sc_ioh; /* ATI IXP can have upto 3 codecs; mark all codecs as not existing */ sc->sc_codec_not_ready_bits = 0; sc->sc_num_codecs = 0; /* enable all codecs to interrupt as well as the new frame interrupt */ bus_space_write_4(iot, ioh, ATI_REG_IER, CODEC_CHECK_BITS); /* wait for the interrupts to happen */ timeout = 100; /* 100.000 usec -> 0.1 sec */ while (timeout > 0) { DELAY(1000); if (sc->sc_codec_not_ready_bits) break; timeout--; } if (timeout == 0) printf("%s: WARNING: timeout during codec detection; " "codecs might be present but haven't interrupted\n", sc->sc_dev.dv_xname); /* disable all interrupts for now */ auixp_disable_interrupts(sc); /* Attach AC97 host interfaces */ for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) { codec = &sc->sc_codec[codec_nr]; bzero(codec, sizeof(struct auixp_codec)); codec->sc = sc; codec->codec_nr = codec_nr; codec->present = 0; codec->host_if.arg = codec; codec->host_if.attach = auixp_attach_codec; codec->host_if.read = auixp_read_codec; codec->host_if.write = auixp_write_codec; codec->host_if.reset = auixp_reset_codec; codec->host_if.flags = auixp_flags_codec; } if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC0_NOT_READY)) { /* codec 0 present */ DPRINTF(("auixp : YAY! codec 0 present!\n")); if (ac97_attach(&sc->sc_codec[0].host_if) == 0) sc->sc_num_codecs++; } #ifdef notyet if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC1_NOT_READY)) { /* codec 1 present */ DPRINTF(("auixp : YAY! codec 1 present!\n")); if (ac97_attach(&sc->sc_codec[1].host_if, &sc->sc_dev) == 0) sc->sc_num_codecs++; } if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC2_NOT_READY)) { /* codec 2 present */ DPRINTF(("auixp : YAY! codec 2 present!\n")); if (ac97_attach(&sc->sc_codec[2].host_if, &sc->sc_dev) == 0) sc->sc_num_codecs++; } #endif if (sc->sc_num_codecs == 0) { printf("%s: no codecs detected or initialised\n", sc->sc_dev.dv_xname); return; } } void auixp_disable_dma(struct auixp_softc *sc, struct auixp_dma *dma) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; iot = sc->sc_iot; ioh = sc->sc_ioh; /* lets not stress the DMA engine more than nessisary */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); if (value & dma->dma_enable_bit) { value &= ~dma->dma_enable_bit; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); } } void auixp_enable_dma(struct auixp_softc *sc, struct auixp_dma *dma) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; iot = sc->sc_iot; ioh = sc->sc_ioh; /* lets not stress the DMA engine more than nessisary */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); if (!(value & dma->dma_enable_bit)) { value |= dma->dma_enable_bit; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); } } void auixp_reset_aclink(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value, timeout; iot = sc->sc_iot; ioh = sc->sc_ioh; /* if power is down, power it up */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); if (value & ATI_REG_CMD_POWERDOWN) { printf("%s: powering up\n", sc->sc_dev.dv_xname); /* explicitly enable power */ value &= ~ATI_REG_CMD_POWERDOWN; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* have to wait at least 10 usec for it to initialise */ DELAY(20); }; printf("%s: soft resetting aclink\n", sc->sc_dev.dv_xname); /* perform a soft reset */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value |= ATI_REG_CMD_AC_SOFT_RESET; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* need to read the CMD reg and wait aprox. 10 usec to init */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); DELAY(20); /* clear soft reset flag again */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value &= ~ATI_REG_CMD_AC_SOFT_RESET; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* check if the ac-link is working; reset device otherwise */ timeout = 10; value = bus_space_read_4(iot, ioh, ATI_REG_CMD); while (!(value & ATI_REG_CMD_ACLINK_ACTIVE)) { printf("%s: not up; resetting aclink hardware\n", sc->sc_dev.dv_xname); /* dip aclink reset but keep the acsync */ value &= ~ATI_REG_CMD_AC_RESET; value |= ATI_REG_CMD_AC_SYNC; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* need to read CMD again and wait again (clocking in issue?) */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); DELAY(20); /* assert aclink reset again */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value |= ATI_REG_CMD_AC_RESET; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* check if its active now */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); timeout--; if (timeout == 0) break; }; if (timeout == 0) { printf("%s: giving up aclink reset\n", sc->sc_dev.dv_xname); }; if (timeout != 10) { printf("%s: aclink hardware reset successful\n", sc->sc_dev.dv_xname); }; /* assert reset and sync for safety */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value |= ATI_REG_CMD_AC_SYNC | ATI_REG_CMD_AC_RESET; bus_space_write_4(iot, ioh, ATI_REG_CMD, value); } /* chip hard init */ int auixp_init(struct auixp_softc *sc) { bus_space_tag_t iot; bus_space_handle_t ioh; u_int32_t value; iot = sc->sc_iot; ioh = sc->sc_ioh; /* disable all interrupts and clear all sources */ auixp_disable_interrupts(sc); /* clear all DMA enables (preserving rest of settings) */ value = bus_space_read_4(iot, ioh, ATI_REG_CMD); value &= ~( ATI_REG_CMD_IN_DMA_EN | ATI_REG_CMD_OUT_DMA_EN | ATI_REG_CMD_SPDF_OUT_EN ); bus_space_write_4(iot, ioh, ATI_REG_CMD, value); /* Reset AC-link */ auixp_reset_aclink(sc); /* * codecs get auto-detected later * * note: we are NOT enabling interrupts yet, no codecs have been * detected yet nor is anything else set up */ return 0; } /* * TODO power saving and suspend / resume support */ int auixp_power(struct auixp_softc *sc, int state) { pcitag_t tag; pci_chipset_tag_t pc; pcireg_t data; int pmcapreg; tag = sc->sc_tag; pc = sc->sc_pct; if (pci_get_capability(pc, tag, PCI_CAP_PWRMGMT, &pmcapreg, 0)) { data = pci_conf_read(pc, tag, pmcapreg + PCI_PMCSR); if ((data & PCI_PMCSR_STATE_MASK) != state) pci_conf_write(pc, tag, pmcapreg + PCI_PMCSR, state); } return 0; } #if 0 void auixp_powerhook(int why, void *hdl) { struct auixp_softc *sc; sc = (struct auixp_softc *)hdl; switch (why) { case PWR_SUSPEND: case PWR_STANDBY: auixp_suspend(sc); break; case PWR_RESUME: auixp_resume(sc); /* XXX fix me XXX */ (sc->codec_if->vtbl->restore_ports)(sc->codec_if); break; } } int auixp_suspend(struct auixp_softc *sc) { /* XXX no power functions yet XXX */ return 0; } int auixp_resume(struct auixp_softc *sc) { /* XXX no power functions yet XXX */ return 0; } #endif /* 0 */