root/dev/pci/auixp.c

DEFINITIONS

1. auixp_open
2. auixp_close
3. auixp_query_encoding
4. auixp_commit_settings
5. auixp_set_params
6. auixp_round_blocksize
7. auixp_malloc
8. auixp_free
9. auixp_getdev
10. auixp_set_port
11. auixp_get_port
12. auixp_query_devinfo
13. auixp_round_buffersize
14. auixp_get_props
15. auixp_link_daisychain
16. auixp_allocate_dma_chain
17. auixp_program_dma_chain
18. auixp_dma_update
19. auixp_update_busbusy
20. auixp_trigger_output
21. auixp_halt_output
22. auixp_trigger_input
23. auixp_halt_input
24. auixp_intr
25. auixp_allocmem
26. auixp_freemem
27. auixp_mappage
28. auixp_match
29. auixp_attach
30. auixp_post_config
31. auixp_enable_interrupts
32. auixp_disable_interrupts
33. auixp_detach
34. auixp_attach_codec
35. auixp_read_codec
36. auixp_write_codec
37. auixp_reset_codec
38. auixp_flags_codec
39. auixp_wait_for_codecs
40. auixp_autodetect_codecs
41. auixp_disable_dma
42. auixp_enable_dma
43. auixp_reset_aclink
44. auixp_init
45. auixp_power
46. auixp_powerhook
47. auixp_suspend
48. auixp_resume

    1 /* $OpenBSD: auixp.c,v 1.10 2007/05/26 00:36:03 krw Exp $ */
    2 /* $NetBSD: auixp.c,v 1.9 2005/06/27 21:13:09 thorpej Exp $ */
    4 /*
    5  * Copyright (c) 2004, 2005 Reinoud Zandijk <reinoud@netbsd.org>
    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. The name of the author may not be used to endorse or promote products
   14  *    derived from this software without specific prior written permission.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by the NetBSD
   18  *      Foundation, Inc. and its contributors.
   19  * 4. Neither the name of The NetBSD Foundation nor the names of its
   20  *    contributors may be used to endorse or promote products derived
   21  *    from this software without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  */
   35 /*
   36  * Audio driver for ATI IXP-{150,200,...} audio driver hardware.
   37  *
   38  * Recording and playback has been tested OK on various sample rates and
   39  * encodings.
   40  *
   41  * Known problems and issues :
   42  * - SPDIF is untested and needs some work still (LED stays off)
   43  * - 32 bit audio playback failed last time i tried but that might an AC'97
   44  *   codec support problem.
   45  * - 32 bit recording works but can't try out playing: see above.
   46  * - no suspend/resume support yet.
   47  * - multiple codecs are `supported' but not tested; the implemetation needs
   48  *   some cleaning up.
   49  */
   51 /*#define DEBUG_AUIXP*/
   53 #include <sys/types.h>
   54 #include <sys/errno.h>
   55 #include <sys/param.h>
   56 #include <sys/systm.h>
   57 #include <sys/malloc.h>
   58 #include <sys/device.h>
   59 #include <sys/conf.h>
   60 #include <sys/exec.h>
   61 #include <sys/selinfo.h>
   62 #include <sys/audioio.h>
   63 #include <sys/queue.h>
   65 #include <machine/bus.h>
   66 #include <machine/intr.h>
   68 #include <dev/pci/pcidevs.h>
   69 #include <dev/pci/pcivar.h>
   71 #include <dev/audio_if.h>
   72 #include <dev/mulaw.h>
   73 #include <dev/auconv.h>
   74 #include <dev/ic/ac97.h>
   76 #include <dev/pci/auixpreg.h>
   77 #include <dev/pci/auixpvar.h>
   79 /* codec detection constant indicating the interrupt flags */
   80 #define ALL_CODECS_NOT_READY \
   81     (ATI_REG_ISR_CODEC0_NOT_READY | ATI_REG_ISR_CODEC1_NOT_READY |\
ATI_REG_ISR_CODEC2_NOT_READY)
   83 #define CODEC_CHECK_BITS (ALL_CODECS_NOT_READY|ATI_REG_ISR_NEW_FRAME)
   85 /* why isn't this base address register not in the headerfile? */
   86 #define PCI_CBIO 0x10
   88 /* macro's used */
   89 #define KERNADDR(p)     ((void *)((p)->addr))
   90 #define DMAADDR(p)      ((p)->map->dm_segs[0].ds_addr)
   92 const struct pci_matchid auixp_pci_devices[] = {
   93         { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_200 },
   94         { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_300 },
   95         { PCI_VENDOR_ATI, PCI_PRODUCT_ATI_IXP_AUDIO_400 },
   96 };
   98 struct cfdriver auixp_cd = {
NULL, "auixp", DV_DULL
  100 };
  102 int     auixp_match( struct device *, void *, void *);
  103 void    auixp_attach(struct device *, struct device *, void *);
  104 int     auixp_detach(struct device *, int);
  106 struct cfattach auixp_ca = {
  107         sizeof(struct auixp_softc), auixp_match, auixp_attach
  108 };
  110 int     auixp_open(void *v, int flags);
  111 void    auixp_close(void *v);
  112 int     auixp_query_encoding(void *, struct audio_encoding *);
  113 int     auixp_set_params(void *, int, int, struct audio_params *,
  114     struct audio_params *);
  115 int     auixp_commit_settings(void *);
  116 int     auixp_round_blocksize(void *, int);
  117 int     auixp_trigger_output(void *, void *, void *, int,
  118     void (*)(void *), void *, struct audio_params *);
  119 int     auixp_trigger_input(void *, void *, void *, int,
  120     void (*)(void *), void *, struct audio_params *);
  121 int     auixp_halt_output(void *);
  122 int     auixp_halt_input(void *);
  123 int     auixp_set_port(void *, mixer_ctrl_t *);
  124 int     auixp_get_port(void *, mixer_ctrl_t *);
  125 int     auixp_query_devinfo(void *, mixer_devinfo_t *);
  126 void *  auixp_malloc(void *, int, size_t, int, int);
  127 void    auixp_free(void *, void *, int);
  128 int     auixp_getdev(void *, struct audio_device *);
size_t  auixp_round_buffersize(void *, int, size_t);
  130 int     auixp_get_props(void *);
  131 int     auixp_intr(void *);
  132 int     auixp_allocmem(struct auixp_softc *, size_t, size_t,
  133     struct auixp_dma *);
  134 int     auixp_freemem(struct auixp_softc *, struct auixp_dma *);
paddr_t auixp_mappage(void *, void *, off_t, int);
  138 /* power management (do we support that already?) */
  139 int     auixp_power(struct auixp_softc *, int);
  140 #if 0
  141 void    auixp_powerhook(int, void *);
  142 int     auixp_suspend(struct auixp_softc *);
  143 int     auixp_resume(struct auixp_softc *);
  144 #endif
  147 /* Supporting subroutines */
  148 int     auixp_init(struct auixp_softc *);
  149 void    auixp_autodetect_codecs(struct auixp_softc *);
  150 void    auixp_post_config(void *);
  152 void    auixp_reset_aclink(struct auixp_softc *);
  153 int     auixp_attach_codec(void *, struct ac97_codec_if *);
  154 int     auixp_read_codec(void *, u_int8_t, u_int16_t *);
  155 int     auixp_write_codec(void *, u_int8_t, u_int16_t);
  156 int     auixp_wait_for_codecs(struct auixp_softc *, const char *);
  157 void    auixp_reset_codec(void *);
  158 enum ac97_host_flags    auixp_flags_codec(void *);
  160 void    auixp_enable_dma(struct auixp_softc *, struct auixp_dma *);
  161 void    auixp_disable_dma(struct auixp_softc *, struct auixp_dma *);
  162 void    auixp_enable_interrupts(struct auixp_softc *);
  163 void    auixp_disable_interrupts(struct auixp_softc *);
  165 void    auixp_link_daisychain(struct auixp_softc *,
  166     struct auixp_dma *, struct auixp_dma *, int, int);
  167 int     auixp_allocate_dma_chain(struct auixp_softc *, struct auixp_dma **);
  168 void    auixp_program_dma_chain(struct auixp_softc *, struct auixp_dma *);
  169 void    auixp_dma_update(struct auixp_softc *, struct auixp_dma *);
  170 void    auixp_update_busbusy(struct auixp_softc *);
  172 #ifdef DEBUG_AUIXP
  173 #define DPRINTF(x)      printf x;
  174 #else
  175 #define DPRINTF(x)
  176 #endif
  178 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
  205 };
  207 int
auixp_open(void *v, int flags)
  209 {
  211         return 0;
  212 }
  214 void
auixp_close(void *v)
  216 {
  217 }
  219 int
auixp_query_encoding(void *hdl, struct audio_encoding *aep)
  221 {
  222         switch (aep->index) {
  223         case 0:
strlcpy(aep->name, AudioEulinear, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_ULINEAR;
aep->precision = 8;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  228                 return (0);
  229         case 1:
strlcpy(aep->name, AudioEmulaw, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_ULAW;
aep->precision = 8;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  234                 return (0);
  235         case 2:
strlcpy(aep->name, AudioEalaw, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_ALAW;
aep->precision = 8;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  240                 return (0);
  241         case 3:
strlcpy(aep->name, AudioEslinear, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_SLINEAR;
aep->precision = 8;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  246                 return (0);
  247         case 4:
strlcpy(aep->name, AudioEslinear_le, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_SLINEAR_LE;
aep->precision = 16;
aep->flags = 0;
  252                 return (0);
  253         case 5:
strlcpy(aep->name, AudioEulinear_le, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_ULINEAR_LE;
aep->precision = 16;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  258                 return (0);
  259         case 6:
strlcpy(aep->name, AudioEslinear_be, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_SLINEAR_BE;
aep->precision = 16;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  264                 return (0);
  265         case 7:
strlcpy(aep->name, AudioEulinear_be, sizeof aep->name);
aep->encoding = AUDIO_ENCODING_ULINEAR_BE;
aep->precision = 16;
aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
  270                 return (0);
  271         default:
  272                 return (EINVAL);
  273         }
  274 }
  277 /* commit setting and program ATI IXP chip */
  278 int
auixp_commit_settings(void *hdl)
  280 {
  281         struct auixp_codec *co;
  282         struct auixp_softc *sc;
bus_space_tag_t    iot;
bus_space_handle_t ioh;
  285         struct audio_params *params;
u_int32_t value;
  288         /* 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;
  294         /* process input settings */
params = &sc->sc_play_params;
  297         /* set input interleaving (precision) */
value  =  bus_space_read_4(iot, ioh, ATI_REG_CMD);
value &= ~ATI_REG_CMD_INTERLEAVE_IN;
  300         if (params->precision <= 16)
value |= ATI_REG_CMD_INTERLEAVE_IN;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
  304         /* 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;
  310         /* TODO SPDIF case for 8 channels */
  311         switch (params->channels) {
  312         case 6:
value |= ATI_REG_OUT_DMA_SLOT_BIT(7) |
ATI_REG_OUT_DMA_SLOT_BIT(8);
  315                 /* FALLTHROUGH */
  316         case 4:
value |= ATI_REG_OUT_DMA_SLOT_BIT(6) |
ATI_REG_OUT_DMA_SLOT_BIT(9);
  319                 /* FALLTHROUGH */
  320         default:
value |= ATI_REG_OUT_DMA_SLOT_BIT(3) |
ATI_REG_OUT_DMA_SLOT_BIT(4);
  323                 break;
  324         }
  325         /* set output threshold */
value |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT;
bus_space_write_4(iot, ioh, ATI_REG_OUT_DMA_SLOT, value);
  329         /* set output interleaving (precision) */
value  =  bus_space_read_4(iot, ioh, ATI_REG_CMD);
value &= ~ATI_REG_CMD_INTERLEAVE_OUT;
  332         if (params->precision <= 16)
value |= ATI_REG_CMD_INTERLEAVE_OUT;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
  336         /* enable 6 channel reordering */
value  =  bus_space_read_4(iot, ioh, ATI_REG_6CH_REORDER);
value &= ~ATI_REG_6CH_REORDER_EN;
  339         if (params->channels == 6)
value |= ATI_REG_6CH_REORDER_EN;
bus_space_write_4(iot, ioh, ATI_REG_6CH_REORDER, value);
  343         if (sc->has_spdif) {
  344                 /* 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 */
  349                 /* XXX this is probably not necessary unless splitted XXX */
value &= ~ATI_REG_CMD_INTERLEAVE_SPDF;
  351                 if (params->precision <= 16)
value |= ATI_REG_CMD_INTERLEAVE_SPDF;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
  354         }
  356         return 0;
  357 }
  360 /* set audio properties in desired setting */
  361 int
auixp_set_params(void *hdl, int setmode, int usemode,
  363     struct audio_params *play, struct audio_params *rec)
  364 {
  365         struct auixp_codec *co;
  366         struct auixp_softc *sc;
  367         int error;
co = (struct auixp_codec *) hdl;
sc = co->sc;
  371         if (setmode & AUMODE_PLAY) {
play->factor = 1;
play->sw_code = NULL;
  374                 switch(play->encoding) {
  375                 case AUDIO_ENCODING_ULAW:
  376                         switch (play->channels) {
  377                         case 1:
play->factor = 4;
play->sw_code = mulaw_to_slinear16_mts;
  380                                 break;
  381                         case 2:
play->factor = 2;
play->sw_code = mulaw_to_slinear16;
  384                                 break;
  385                         default:
  386                                 return (EINVAL);
  387                         }
  388                         break;
  389                 case AUDIO_ENCODING_SLINEAR_LE:
  390                         switch (play->precision) {
  391                         case 8:
  392                                 switch (play->channels) {
  393                                 case 1:
play->factor = 4;
play->sw_code = linear8_to_linear16_mts;
  396                                         break;
  397                                 case 2:
play->factor = 2;
play->sw_code = linear8_to_linear16;
  400                                         break;
  401                                 default:
  402                                         return (EINVAL);
  403                                 }
  404                                 break;
  405                         case 16:
  406                                 switch (play->channels) {
  407                                 case 1:
play->factor = 2;
play->sw_code = noswap_bytes_mts;
  410                                         break;
  411                                 case 2:
  412                                         break;
  413                                 default:
  414                                         return (EINVAL);
  415                                 }
  416                                 break;
  417                         default:
  418                                 return (EINVAL);
  419                         }
  420                         break;
  421                 case AUDIO_ENCODING_ULINEAR_LE:
  422                         switch (play->precision) {
  423                         case 8:
  424                                 switch (play->channels) {
  425                                 case 1:
play->factor = 4;
play->sw_code = ulinear8_to_linear16_mts;
  428                                         break;
  429                                 case 2:
play->factor = 2;
play->sw_code = ulinear8_to_linear16;
  432                                         break;
  433                                 default:
  434                                         return (EINVAL);
  435                                 }
  436                                 break;
  437                         case 16:
  438                                 switch (play->channels) {
  439                                 case 1:
play->factor = 2;
play->sw_code = change_sign16_mts;
  442                                         break;
  443                                 case 2:
play->sw_code = change_sign16;
  445                                         break;
  446                                 default:
  447                                         return (EINVAL);
  448                                 }
  449                                 break;
  450                         default:
  451                                 return (EINVAL);
  452                         }
  453                         break;
  454                 case AUDIO_ENCODING_ALAW:
  455                         switch (play->channels) {
  456                         case 1:
play->factor = 4;
play->sw_code = alaw_to_slinear16_mts;
  459                                 break;
  460                         case 2:
play->factor = 2;
play->sw_code = alaw_to_slinear16;
  463                                 break;
  464                         default:
  465                                 return (EINVAL);
  466                         }
  467                         break;
  468                 case AUDIO_ENCODING_SLINEAR_BE:
  469                         switch (play->precision) {
  470                         case 8:
  471                                 switch (play->channels) {
  472                                 case 1:
play->factor = 4;
play->sw_code = linear8_to_linear16_mts;
  475                                         break;
  476                                 case 2:
play->factor = 2;
play->sw_code = linear8_to_linear16;
  479                                         break;
  480                                 default:
  481                                         return (EINVAL);
  482                                 }
  483                                 break;
  484                         case 16:
  485                                 switch (play->channels) {
  486                                 case 1:
play->factor = 2;
play->sw_code = swap_bytes_mts;
  489                                         break;
  490                                 case 2:
play->sw_code = swap_bytes;
  492                                         break;
  493                                 default:
  494                                         return (EINVAL);
  495                                 }
  496                                 break;
  497                         default:
  498                                 return (EINVAL);
  499                         }
  500                         break;
  501                 case AUDIO_ENCODING_ULINEAR_BE:
  502                         switch (play->precision) {
  503                         case 8:
  504                                 switch (play->channels) {
  505                                 case 1:
play->factor = 4;
play->sw_code = ulinear8_to_linear16_mts;
  508                                         break;
  509                                 case 2:
play->factor = 2;
play->sw_code = ulinear8_to_linear16;
  512                                         break;
  513                                 default:
  514                                         return (EINVAL);
  515                                 }
  516                                 break;
  517                         case 16:
  518                                 switch (play->channels) {
  519                                 case 1:
play->factor = 2;
play->sw_code = change_sign16_swap_bytes_mts;
  522                                         break;
  523                                 case 2:
play->sw_code = change_sign16_swap_bytes;
  525                                         break;
  526                                 default:
  527                                         return (EINVAL);
  528                                 }
  529                                 break;
  530                         default:
  531                                 return (EINVAL);
  532                         }
  533                         break;
  534                 default:
  535                         return (EINVAL);
  536                 }
error = ac97_set_rate(co->codec_if, play, AUMODE_PLAY);
  539                 if (error)
  540                         return (error);
  541         }
  543         if (setmode & AUMODE_RECORD) {
rec->factor = 1;
rec->sw_code = 0;
  546                 switch(rec->encoding) {
  547                 case AUDIO_ENCODING_ULAW:
rec->sw_code = ulinear8_to_mulaw;
  549                         break;
  550                 case AUDIO_ENCODING_SLINEAR_LE:
  551                         if (rec->precision == 8)
rec->sw_code = change_sign8;
  553                         break;
  554                 case AUDIO_ENCODING_ULINEAR_LE:
  555                         if (rec->precision == 16)
rec->sw_code = change_sign16;
  557                         break;
  558                 case AUDIO_ENCODING_ALAW:
rec->sw_code = ulinear8_to_alaw;
  560                         break;
  561                 case AUDIO_ENCODING_SLINEAR_BE:
  562                         if (rec->precision == 16)
rec->sw_code = swap_bytes;
  564                         else
rec->sw_code = change_sign8;
  566                         break;
  567                 case AUDIO_ENCODING_ULINEAR_BE:
  568                         if (rec->precision == 16)
rec->sw_code = swap_bytes_change_sign16;
  570                         break;
  571                 default:
  572                         return (EINVAL);
  573                 }
error = ac97_set_rate(co->codec_if, rec, AUMODE_RECORD);
  576                 if (error)
  577                         return (error);
  578         }
  580         return (0);
  581 }
  584 /* called to translate a requested blocksize to a hw-possible one */
  585 int
auixp_round_blocksize(void *v, int blk)
  587 {
blk = (blk + 0x1f) & ~0x1f;
  590         /* Be conservative; align to 32 bytes and maximise it to 64 kb */
  591         if (blk > 0x10000)
blk = 0x10000;
  594         return blk;
  595 }
  598 /*
  599  * allocate dma capable memory and record its information for later retrieval
  600  * when we program the dma chain itself. The trigger routines passes on the
  601  * kernel virtual address we return here as a reference to the mapping.
  602  */
  603 void *
auixp_malloc(void *hdl, int direction, size_t size, int pool, int flags)
  605 {
  606         struct auixp_codec *co;
  607         struct auixp_softc *sc;
  608         struct auixp_dma *dma;
  609         int error;
co = (struct auixp_codec *) hdl;
sc = co->sc;
  613         /* get us a auixp_dma structure */
dma = malloc(sizeof(*dma), pool, flags);
  615         if (!dma)
  616                 return NULL;
  618         /* get us a dma buffer itself */
error = auixp_allocmem(sc, size, 16, dma);
  620         if (error) {
free(dma, pool);
printf("%s: auixp_malloc: not enough memory\n",
sc->sc_dev.dv_xname);
  624                 return NULL;
  625         }
SLIST_INSERT_HEAD(&sc->sc_dma_list, dma, dma_chain);
DPRINTF(("auixp_malloc: returning kern %p,   hw 0x%08x for %d bytes "
  629             "in %d segs\n", KERNADDR(dma), (u_int32_t) DMAADDR(dma), dma->size,
dma->nsegs)
  631         );
  633         return KERNADDR(dma);
  634 }
  636 /*
  637  * free and release dma capable memory we allocated before and remove its
  638  * recording
  639  */
  640 void
auixp_free(void *hdl, void *addr, int pool)
  642 {
  643         struct auixp_codec *co;
  644         struct auixp_softc *sc;
  645         struct auixp_dma *dma;
co = (struct auixp_codec *) hdl;
sc = co->sc;
SLIST_FOREACH(dma, &sc->sc_dma_list, dma_chain) {
  650                 if (KERNADDR(dma) == addr) {
SLIST_REMOVE(&sc->sc_dma_list, dma, auixp_dma,
dma_chain);
auixp_freemem(sc, dma);
free(dma, pool);
  655                         return;
  656                 }
  657         }
  658 }
  660 int
auixp_getdev(void *v, struct audio_device *adp)
  662 {
  663         struct auixp_softc *sc = v;
  664         *adp = sc->sc_audev;
  665         return 0;
  666 }
  668 /* pass request to AC'97 codec code */
  669 int
auixp_set_port(void *hdl, mixer_ctrl_t *mc)
  671 {
  672         struct auixp_codec *co;
co = (struct auixp_codec *) hdl;
  675         return co->codec_if->vtbl->mixer_set_port(co->codec_if, mc);
  676 }
  679 /* pass request to AC'97 codec code */
  680 int
auixp_get_port(void *hdl, mixer_ctrl_t *mc)
  682 {
  683         struct auixp_codec *co;
co = (struct auixp_codec *) hdl;
  686         return co->codec_if->vtbl->mixer_get_port(co->codec_if, mc);
  687 }
  689 /* pass request to AC'97 codec code */
  690 int
auixp_query_devinfo(void *hdl, mixer_devinfo_t *di)
  692 {
  693         struct auixp_codec *co;
co = (struct auixp_codec *) hdl;
  696         return co->codec_if->vtbl->query_devinfo(co->codec_if, di);
  697 }
size_t
auixp_round_buffersize(void *hdl, int direction, size_t bufsize)
  702 {
  704         /* XXX force maximum? i.e. 256 kb? */
  705         return bufsize;
  706 }
  709 int
auixp_get_props(void *hdl)
  711 {
  713         return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
  714 }
  717 /*
  718  * A dma descriptor has dma->nsegs segments defined in dma->segs set up when
  719  * we claimed the memory.
  720  *
  721  * Due to our demand for one contiguous DMA area, we only have one segment. A
  722  * c_dma structure is about 3 kb for the 256 entries we maximally program
  723  * -arbitrary limit AFAIK- so all is most likely to be in one segment/page
  724  * anyway.
  725  *
  726  * XXX ought to implement fragmented dma area XXX
  727  *
  728  * Note that _v variables depict kernel virtual addresses, _p variables depict
  729  * physical addresses.
  730  */
  731 void
auixp_link_daisychain(struct auixp_softc *sc,
  733                 struct auixp_dma *c_dma, struct auixp_dma *s_dma,
  734                 int blksize, int blocks)
  735 {
atiixp_dma_desc_t *caddr_v, *next_caddr_v;
u_int32_t caddr_p, next_caddr_p, saddr_p;
  738         int i;
  740         /* just make sure we are not changing when its running */
auixp_disable_dma(sc, c_dma);
  743         /* setup dma chain start addresses */
caddr_v = KERNADDR(c_dma);
caddr_p = DMAADDR(c_dma);
saddr_p = DMAADDR(s_dma);
  748         /* program the requested number of blocks */
  749         for (i = 0; i < blocks; i++) {
  750                 /* clear the block just in case */
bzero(caddr_v, sizeof(atiixp_dma_desc_t));
  753                 /* 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);
  757                 if (i == blocks-1) {
next_caddr_v = KERNADDR(c_dma);
next_caddr_p = DMAADDR(c_dma);
  760                 }
  762                 /* 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);
  768                 /* advance slot */
saddr_p += blksize;     /* XXX assuming contiguous XXX */
caddr_v  = next_caddr_v;
caddr_p  = next_caddr_p;
  772         }
  773 }
  776 int
auixp_allocate_dma_chain(struct auixp_softc *sc, struct auixp_dma **dmap)
  778 {
  779         struct auixp_dma *dma;
  780         int error;
  782         /* allocate keeper of dma area */
  783         *dmap = NULL;
dma = malloc(sizeof(*dma), M_DEVBUF, M_NOWAIT);
  785         if (!dma)
  786                 return ENOMEM;
bzero(dma, sizeof(*dma));
  789         /* allocate for daisychain of IXP hardware-dma descriptors */
error = auixp_allocmem(sc, DMA_DESC_CHAIN * sizeof(atiixp_dma_desc_t),
  791             16, dma);
  792         if (error) {
printf("%s: can't malloc dma descriptor chain\n",
sc->sc_dev.dv_xname);
free(dma, M_DEVBUF);
  796                 return ENOMEM;
  797         }
  799         /* return info and initialise structure */
dma->intr    = NULL;
dma->intrarg = NULL;
  803         *dmap = dma;
  804         return 0;
  805 }
  808 /* program dma chain in its link address descriptor */
  809 void
auixp_program_dma_chain(struct auixp_softc *sc, struct auixp_dma *dma)
  811 {
bus_space_tag_t    iot;
bus_space_handle_t ioh;
u_int32_t value;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
  818         /* get hardware start address of DMA chain and set valid-flag in it */
  819         /* XXX always at start? XXX */
value = DMAADDR(dma);
value = value | ATI_REG_LINKPTR_EN;
  823         /* reset linkpointer */
bus_space_write_4(iot, ioh, dma->linkptr, 0);
  826         /* reset this DMA engine */
auixp_disable_dma(sc, dma);
auixp_enable_dma(sc, dma);
  830         /* program new DMA linkpointer */
bus_space_write_4(iot, ioh, dma->linkptr, value);
  832 }
  835 /* called from interrupt code to signal end of one dma-slot */
  836 void
auixp_dma_update(struct auixp_softc *sc, struct auixp_dma *dma)
  838 {
  840         /* be very paranoid */
  841         if (!dma)
panic("auixp: update: dma = NULL");
  843         if (!dma->intr)
panic("auixp: update: dma->intr = NULL");
  846         /* request more input from upper layer */
  847         (*dma->intr)(dma->intrarg);
  848 }
  851 /*
  852  * The magic `busbusy' bit that needs to be set when dma is active; allowing
  853  * busmastering?
  854  */
  855 void
auixp_update_busbusy(struct auixp_softc *sc)
  857 {
bus_space_tag_t    iot;
bus_space_handle_t ioh;
u_int32_t value;
  861         int running;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
  865         /* 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));
  870         if (running)
value |= ATI_REG_IER_SET_BUS_BUSY;
bus_space_write_4(iot, ioh, ATI_REG_IER, value);
  875 }
  878 /*
  879  * Called from upper audio layer to request playing audio, only called once;
  880  * audio is refilled by calling the intr() function when space is available
  881  * again.
  882  */
  883 /* XXX almost literally a copy of trigger-input; could be factorised XXX */
  884 int
auixp_trigger_output(void *hdl, void *start, void *end, int blksize,
  886     void (*intr)(void *), void *intrarg, struct audio_params *param)
  887 {
  888         struct auixp_codec *co;
  889         struct auixp_softc *sc;
  890         struct auixp_dma   *chain_dma;
  891         struct auixp_dma   *sound_dma;
u_int32_t blocks;
co = (struct auixp_codec *) hdl;
sc = co->sc;
chain_dma = sc->sc_output_dma;
  897         /* add functions to call back */
chain_dma->intr    = intr;
chain_dma->intrarg = intrarg;
  901         /*
  902          * Program output DMA chain with blocks from [start...end] with
  903          * blksize fragments.
  904          *
  905          * NOTE, we can assume its in one block since we asked for it to be in
  906          * one contiguous blob; XXX change this? XXX
  907          */
blocks = (size_t) (((caddr_t) end) - ((caddr_t) start)) / blksize;
  910         /* lookup `start' address in our list of DMA area's */
SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
  912                 if (KERNADDR(sound_dma) == start)
  913                         break;
  914         }
  916         /* not ours ? then bail out */
  917         if (!sound_dma) {
printf("%s: auixp_trigger_output: bad sound addr %p\n",
sc->sc_dev.dv_xname, start);
  920                 return EINVAL;
  921         }
  923         /* link round-robin daisychain and program hardware */
auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
auixp_program_dma_chain(sc, chain_dma);
  927         /* mark we are now able to run now */
chain_dma->running = 1;
  930         /* update bus-flags; XXX programs more flags XXX */
auixp_update_busbusy(sc);
  933         /* callbacks happen in interrupt routine */
  934         return 0;
  935 }
  938 /* halt output of audio, just disable its dma and update bus state */
  939 int
auixp_halt_output(void *hdl)
  941 {
  942         struct auixp_codec *co;
  943         struct auixp_softc *sc;
  944         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);
  954         return 0;
  955 }
  958 /* XXX almost literally a copy of trigger-output; could be factorised XXX */
  959 int
auixp_trigger_input(void *hdl, void *start, void *end, int blksize,
  961     void (*intr)(void *), void *intrarg, struct audio_params *param)
  962 {
  963         struct auixp_codec *co;
  964         struct auixp_softc *sc;
  965         struct auixp_dma   *chain_dma;
  966         struct auixp_dma   *sound_dma;
u_int32_t blocks;
co = (struct auixp_codec *) hdl;
sc = co->sc;
chain_dma = sc->sc_input_dma;
  972         /* add functions to call back */
chain_dma->intr    = intr;
chain_dma->intrarg = intrarg;
  976         /*
  977          * Program output DMA chain with blocks from [start...end] with
  978          * blksize fragments.
  979          *
  980          * NOTE, we can assume its in one block since we asked for it to be in
  981          * one contiguous blob; XXX change this? XXX
  982          */
blocks = (size_t) (((caddr_t) end) - ((caddr_t) start)) / blksize;
  985         /* lookup `start' address in our list of DMA area's */
SLIST_FOREACH(sound_dma, &sc->sc_dma_list, dma_chain) {
  987                 if (KERNADDR(sound_dma) == start)
  988                         break;
  989         }
  991         /* not ours ? then bail out */
  992         if (!sound_dma) {
printf("%s: auixp_trigger_input: bad sound addr %p\n",
sc->sc_dev.dv_xname, start);
  995                 return EINVAL;
  996         }
  998         /* link round-robin daisychain and program hardware */
auixp_link_daisychain(sc, chain_dma, sound_dma, blksize, blocks);
auixp_program_dma_chain(sc, chain_dma);
 1002         /* mark we are now able to run now */
chain_dma->running = 1;
 1005         /* update bus-flags; XXX programs more flags XXX */
auixp_update_busbusy(sc);
 1008         /* callbacks happen in interrupt routine */
 1009         return 0;
 1010 }
 1013 /* halt sampling audio, just disable its dma and update bus state */
 1014 int
auixp_halt_input(void *hdl)
 1016 {
 1017         struct auixp_codec *co;
 1018         struct auixp_softc *sc;
 1019         struct auixp_dma   *dma;
co = (struct auixp_codec *) hdl;
sc = co->sc;
dma = sc->sc_input_dma;
auixp_disable_dma(sc, dma);
dma->running = 0;
auixp_update_busbusy(sc);
 1029         return 0;
 1030 }
 1033 /*
 1034  * IXP audio interrupt handler
 1035  *
 1036  * note that we return the number of bits handled; the return value is not
 1037  * documented but I saw it implemented in other drivers. Probably returning a
 1038  * value > 0 means "I've dealt with it"
 1039  *
 1040  */
 1041 int
auixp_intr(void *softc)
 1043 {
 1044         struct auixp_softc *sc;
bus_space_tag_t    iot;
bus_space_handle_t ioh;
u_int32_t status, enable, detected_codecs;
 1048         int ret;
sc = softc;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
ret = 0;
 1054         /* get status from the interrupt status register */
status = bus_space_read_4(iot, ioh, ATI_REG_ISR);
 1057         if (status == 0)
 1058                 return 0;
DPRINTF(("%s: (status = %x)\n", sc->sc_dev.dv_xname, status));
 1062         /* check DMA UPDATE flags for input & output */
 1063         if (status & ATI_REG_ISR_IN_STATUS) {
ret++; DPRINTF(("IN_STATUS\n"));
auixp_dma_update(sc, sc->sc_input_dma);
 1066         }
 1067         if (status & ATI_REG_ISR_OUT_STATUS) {
ret++; DPRINTF(("OUT_STATUS\n"));
auixp_dma_update(sc, sc->sc_output_dma);
 1070         }
 1072         /* XXX XRUN flags not used/needed yet; should i implement it? XXX */
 1073         /* acknowledge the interrupts nevertheless */
 1074         if (status & ATI_REG_ISR_IN_XRUN) {
ret++; DPRINTF(("IN_XRUN\n"));
 1076                 /* auixp_dma_xrun(sc, sc->sc_input_dma);  */
 1077         }
 1078         if (status & ATI_REG_ISR_OUT_XRUN) {
ret++; DPRINTF(("OUT_XRUN\n"));
 1080                 /* auixp_dma_xrun(sc, sc->sc_output_dma); */
 1081         }
 1083         /* check if we are looking for codec detection */
 1084         if (status & CODEC_CHECK_BITS) {
ret++;
 1086                 /* mark missing codecs as not ready */
detected_codecs = status & CODEC_CHECK_BITS;
sc->sc_codec_not_ready_bits |= detected_codecs;
 1090                 /* disable detected interrupt sources */
enable  = bus_space_read_4(iot, ioh, ATI_REG_IER);
enable &= ~detected_codecs;
bus_space_write_4(iot, ioh, ATI_REG_IER, enable);
 1094         }
 1096         /* acknowledge interrupt sources */
bus_space_write_4(iot, ioh, ATI_REG_ISR, status);
 1099         return ret;
 1100 }
 1103 /* allocate memory for dma purposes; on failure of any of the steps, roll back */
 1104 int
auixp_allocmem(struct auixp_softc *sc, size_t size,
size_t align, struct auixp_dma *dma)
 1107 {
 1108         int error;
 1110         /* remember size */
dma->size = size;
 1113         /* 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);
 1117         if (error)
 1118                 return error;
 1120         /*
 1121          * map allocated memory into kernel virtual address space and keep it
 1122          * coherent with the CPU.
 1123          */
error = bus_dmamem_map(sc->sc_dmat, dma->segs, dma->nsegs, dma->size,
 1125                                 &dma->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
 1126         if (error)
 1127                 goto free;
 1129         /* 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);
 1132         if (error)
 1133                 goto unmap;
 1135         /*
 1136          * load the dma handle with mappings for a dma transfer; all pages
 1137          * need to be wired.
 1138          */
error = bus_dmamap_load(sc->sc_dmat, dma->map, dma->addr, dma->size, NULL,
BUS_DMA_NOWAIT);
 1141         if (error)
 1142                 goto destroy;
 1144         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);
 1153         return error;
 1154 }
 1157 /* undo dma mapping and release memory allocated */
 1158 int
auixp_freemem(struct auixp_softc *sc, struct auixp_dma *p)
 1160 {
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);
 1167         return 0;
 1168 }
 1171 /* memory map dma memory */
paddr_t
auixp_mappage(void *hdl, void *mem, off_t off, int prot)
 1174 {
 1175         struct auixp_codec *co;
 1176         struct auixp_softc *sc;
 1177         struct auixp_dma *p;
co = (struct auixp_codec *) hdl;
sc  = co->sc;
 1181         /* for sanity */
 1182         if (off < 0)
 1183                 return -1;
 1185         /* look up allocated DMA area */
SLIST_FOREACH(p, &sc->sc_dma_list, dma_chain) {
 1187                 if (KERNADDR(p) == mem)
 1188                         break;
 1189         }
 1191         /* have we found it ? */
 1192         if (!p)
 1193                 return -1;
 1195         /* return mmap'd region */
 1196         return bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nsegs,
off, prot, BUS_DMA_WAITOK);
 1198 }
 1200 int
auixp_match(struct device *dev, void *match, void *aux)
 1202 {
 1203         return (pci_matchbyid((struct pci_attach_args *)aux, auixp_pci_devices,
 1204             sizeof(auixp_pci_devices)/sizeof(auixp_pci_devices[0])));
 1205 }
 1207 void
auixp_attach(struct device *parent, struct device *self, void *aux)
 1209 {
 1210         struct auixp_softc *sc;
 1211         struct pci_attach_args *pa;
pcitag_t tag;
pci_chipset_tag_t pc;
pci_intr_handle_t ih;
 1215         const char *intrstr;
 1216         int len;
sc = (struct auixp_softc *)self;
pa = (struct pci_attach_args *)aux;
tag = pa->pa_tag;
pc = pa->pa_pc;
 1223         /* map memory; its not sized -> what is the size? max PCI slot size? */
 1224         if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_MEM, 0,
 1225             &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios, 0)) {
printf(": can't map memory space\n");
 1227                 return;
 1228         }
 1230         /* Initialize softc */
sc->sc_tag = tag;
sc->sc_pct = pc;
sc->sc_dmat = pa->pa_dmat;
SLIST_INIT(&sc->sc_dma_list);
 1236         /* get us the auixp_dma structures */
auixp_allocate_dma_chain(sc, &sc->sc_output_dma);
auixp_allocate_dma_chain(sc, &sc->sc_input_dma);
 1240         /* when that fails we are dead in the water */
 1241         if (!sc->sc_output_dma || !sc->sc_input_dma)
 1242                 return;
 1244         /* fill in the missing details about the dma channels. */
 1246         /* 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;
 1250         /* have spdif? then this too! XXX not seeing LED yet! XXX */
 1251         if (sc->has_spdif)
sc->sc_output_dma->dma_enable_bit |= ATI_REG_CMD_SPDF_OUT_EN;
 1254         /* 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;
 1259 #if 0
 1260         /* could preliminary program DMA chain */
auixp_program_dma_chain(sc, sc->sc_output_dma);
auixp_program_dma_chain(sc, sc->sc_input_dma);
 1263 #endif
 1265         if (pci_intr_map(pa, &ih)) {
printf(": can't map interrupt\n");
 1267                 return;
 1268         }
intrstr = pci_intr_string(pc, ih);
sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, auixp_intr, sc,
sc->sc_dev.dv_xname);
 1272         if (sc->sc_ih == NULL) {
printf(": can't establish interrupt");
 1274                 if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
 1277                 return;
 1278         }
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,
 1285             sizeof sc->sc_audev.config);
 1287         /* power up chip */
auixp_power(sc, PCI_PMCSR_STATE_D0);
 1290         /* init chip */
 1291         if (auixp_init(sc) == -1) {
printf("%s: auixp_attach: unable to initialize the card\n",
sc->sc_dev.dv_xname);
 1294                 return;
 1295         }
 1297         /* XXX set up power hooks; not implemented yet XXX */
len = 1;        /* shut up gcc */
 1300 #ifdef notyet
 1301         /* create suspend save area */
len = sizeof(u_int16_t) * (ESA_REV_B_CODE_MEMORY_LENGTH
 1303             + ESA_REV_B_DATA_MEMORY_LENGTH + 1);
sc->savemem = (u_int16_t *)malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
 1305         if (sc->savemem == NULL) {
printf("%s: unable to allocate suspend buffer\n",
sc->sc_dev.dv_xname);
 1308                 return;
 1309         }
sc->powerhook = powerhook_establish(auixp_powerhook, sc);
 1312         if (sc->powerhook == NULL)
printf("%s: WARNING: unable to establish powerhook\n",
sc->sc_dev.dv_xname);
 1316 #endif
 1318         /*
 1319          * delay further configuration of codecs and audio after interrupts
 1320          * are enabled.
 1321          */
mountroothook_establish(auixp_post_config, self);
 1323 }
 1325 /* called from autoconfigure system when interrupts are enabled */
 1326 void
auixp_post_config(void *self)
 1328 {
 1329         struct auixp_softc *sc;
 1330         struct auixp_codec *codec;
 1331         int codec_nr;
sc = (struct auixp_softc *)self;
 1334         /* detect the AC97 codecs */
auixp_autodetect_codecs(sc);
 1337 #if notyet
 1338         /* 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);
 1343 #endif
 1345         /* attach audio devices for all detected codecs */
 1346         for (codec_nr = 0; codec_nr < ATI_IXP_CODECS; codec_nr++) {
codec = &sc->sc_codec[codec_nr];
 1348                 if (codec->present)
audio_attach_mi(&auixp_hw_if, codec, &sc->sc_dev);
 1350         }
 1352         /* done! now enable all interrupts we can service */
auixp_enable_interrupts(sc);
 1354 }
 1356 void
auixp_enable_interrupts(struct auixp_softc *sc)
 1358 {
bus_space_tag_t     iot;
bus_space_handle_t  ioh;
u_int32_t value;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1365         /* clear all pending */
bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
 1368         /* 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;
 1372 #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;
 1378 #endif
bus_space_write_4(iot, ioh, ATI_REG_IER, value);
 1381 }
 1383 void
auixp_disable_interrupts(struct auixp_softc *sc)
 1385 {
bus_space_tag_t     iot;
bus_space_handle_t  ioh;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1391         /* disable all interrupt sources */
bus_space_write_4(iot, ioh, ATI_REG_IER, 0);
 1394         /* clear all pending */
bus_space_write_4(iot, ioh, ATI_REG_ISR, 0xffffffff);
 1396 }
 1398 /* dismantle what we've set up by undoing setup */
 1399 int
auixp_detach(struct device *self, int flags)
 1401 {
 1402         struct auixp_softc *sc;
sc = (struct auixp_softc *)self;
 1405         /* XXX shouldn't we just reset the chip? XXX */
 1406         /*
 1407          * should we explicitly disable interrupt generation and acknowledge
 1408          * what's left on? better be safe than sorry.
 1409          */
auixp_disable_interrupts(sc);
 1412         /* tear down .... */
config_detach(&sc->sc_dev, flags);      /* XXX OK? XXX */
 1415         if (sc->sc_ih != NULL)
pci_intr_disestablish(sc->sc_pct, sc->sc_ih);
 1417         if (sc->sc_ios)
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
 1420         if (sc->savemem)
free(sc->savemem, M_DEVBUF);
 1423         return 0;
 1424 }
 1427 /*
 1428  * codec handling
 1429  *
 1430  * IXP audio support can have upto 3 codecs! are they chained ? or
 1431  * alternative outlets with the same audio feed i.e. with different mixer
 1432  * settings? XXX does NetBSD support more than one audio codec? XXX
 1433  */
 1436 int
auixp_attach_codec(void *aux, struct ac97_codec_if *codec_if)
 1438 {
 1439         struct auixp_codec *ixp_codec;
ixp_codec = aux;
ixp_codec->codec_if = codec_if;
ixp_codec->present  = 1;
 1445         return 0;
 1446 }
 1448 int
auixp_read_codec(void *aux, u_int8_t reg, u_int16_t *result)
 1450 {
 1451         struct auixp_codec *co;
 1452         struct auixp_softc *sc;
bus_space_tag_t     iot;
bus_space_handle_t  ioh;
u_int32_t data;
 1456         int timeout;
co  = aux;
sc  = co->sc;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1462         if (auixp_wait_for_codecs(sc, "read_codec"))
 1463                 return 0xffff;
 1465         /* 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);
 1473         if (auixp_wait_for_codecs(sc, "read_codec"))
 1474                 return 0xffff;
 1476         /* wait until codec info is clocked in */
timeout = 500;          /* 500*2 usec -> 0.001 sec */
 1478         do {
data = bus_space_read_4(iot, ioh, ATI_REG_PHYS_IN_ADDR);
 1480                 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));
 1483                         *result = data >> ATI_REG_PHYS_IN_DATA_SHIFT;
 1484                         return 0;
 1485                 }
DELAY(2);
timeout--;
 1488         } while (timeout > 0);
 1490         if (reg < 0x7c)
printf("%s: codec read timeout! (reg %x)\n",
sc->sc_dev.dv_xname, reg);
 1494         return 0xffff;
 1495 }
 1497 int
auixp_write_codec(void *aux, u_int8_t reg, u_int16_t data)
 1499 {
 1500         struct auixp_codec *co;
 1501         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;
 1511         if (auixp_wait_for_codecs(sc, "write_codec"))
 1512                 return -1;
 1514         /* build up command for writing codec register */
value = (((u_int32_t) data) << ATI_REG_PHYS_OUT_DATA_SHIFT) |
 1516                 (((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);
 1522         return 0;
 1523 }
 1525 void
auixp_reset_codec(void *aux)
 1527 {
 1529         /* nothing to be done? */
 1530 }
 1532 enum ac97_host_flags
auixp_flags_codec(void *aux)
 1534 {
 1535         struct auixp_codec *ixp_codec;
ixp_codec = aux;
 1538         return ixp_codec->codec_flags;
 1539 }
 1541 int
auixp_wait_for_codecs(struct auixp_softc *sc, const char *func)
 1543 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
u_int32_t value;
 1547         int timeout;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1551         /* wait until all codec transfers are done */
timeout = 500;          /* 500*2 usec -> 0.001 sec */
 1553         do {
value = bus_space_read_4(iot, ioh, ATI_REG_PHYS_OUT_ADDR);
 1555                 if ((value & ATI_REG_PHYS_OUT_ADDR_EN) == 0)
 1556                         return 0;
DELAY(2);
timeout--;
 1560         } while (timeout > 0);
printf("%s: %s: timed out\n", func, sc->sc_dev.dv_xname);
 1563         return -1;
 1564 }
 1566 void
auixp_autodetect_codecs(struct auixp_softc *sc)
 1568 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
pcireg_t subdev;
 1572         struct auixp_codec  *codec;
 1573         int timeout, codec_nr;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
subdev = pci_conf_read(sc->sc_pct, sc->sc_tag, PCI_SUBSYS_ID_REG);
 1579         /* 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;
 1583         /* enable all codecs to interrupt as well as the new frame interrupt */
bus_space_write_4(iot, ioh, ATI_REG_IER, CODEC_CHECK_BITS);
 1586         /* wait for the interrupts to happen */
timeout = 100;          /* 100.000 usec -> 0.1 sec */
 1589         while (timeout > 0) {
DELAY(1000);
 1591                 if (sc->sc_codec_not_ready_bits)
 1592                         break;
timeout--;
 1594         }
 1596         if (timeout == 0)
printf("%s: WARNING: timeout during codec detection; "
 1598                         "codecs might be present but haven't interrupted\n",
sc->sc_dev.dv_xname);
 1601         /* disable all interrupts for now */
auixp_disable_interrupts(sc);
 1604         /* Attach AC97 host interfaces */
 1605         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;
 1619                 switch (subdev) {
 1620                 case 0x1311462: /* MSI S270 */
codec->codec_flags = AC97_HOST_DONT_ENABLE_SPDIF;
 1622                         break;
 1623                 }
 1624         }
 1626         if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC0_NOT_READY)) {
 1627                 /* codec 0 present */
DPRINTF(("auixp : YAY! codec 0 present!\n"));
 1629                 if (ac97_attach(&sc->sc_codec[0].host_if) == 0)
sc->sc_num_codecs++;
 1631         }
 1633 #ifdef notyet
 1634         if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC1_NOT_READY)) {
 1635                 /* codec 1 present */
DPRINTF(("auixp : YAY! codec 1 present!\n"));
 1637                 if (ac97_attach(&sc->sc_codec[1].host_if, &sc->sc_dev) == 0)
sc->sc_num_codecs++;
 1639         }
 1641         if (!(sc->sc_codec_not_ready_bits & ATI_REG_ISR_CODEC2_NOT_READY)) {
 1642                 /* codec 2 present */
DPRINTF(("auixp : YAY! codec 2 present!\n"));
 1644                 if (ac97_attach(&sc->sc_codec[2].host_if, &sc->sc_dev) == 0)
sc->sc_num_codecs++;
 1646         }
 1647 #endif
 1649         if (sc->sc_num_codecs == 0) {
printf("%s: no codecs detected or initialised\n",
sc->sc_dev.dv_xname);
 1652                 return;
 1653         }
 1654 }
 1656 void
auixp_disable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
 1658 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
u_int32_t value;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1665         /* lets not stress the DMA engine more than necessary */
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
 1667         if (value & dma->dma_enable_bit) {
value &= ~dma->dma_enable_bit;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
 1670         }
 1671 }
 1673 void
auixp_enable_dma(struct auixp_softc *sc, struct auixp_dma *dma)
 1675 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
u_int32_t value;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1682         /* lets not stress the DMA engine more than necesssary */
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
 1684         if (!(value & dma->dma_enable_bit)) {
value |= dma->dma_enable_bit;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
 1687         }
 1688 }
 1690 void
auixp_reset_aclink(struct auixp_softc *sc)
 1692 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
u_int32_t value, timeout;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1700         /* if power is down, power it up */
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
 1702         if (value & ATI_REG_CMD_POWERDOWN) {
printf("%s: powering up\n", sc->sc_dev.dv_xname);
 1705                 /* explicitly enable power */
value &= ~ATI_REG_CMD_POWERDOWN;
bus_space_write_4(iot, ioh, ATI_REG_CMD, value);
 1709                 /* have to wait at least 10 usec for it to initialise */
DELAY(20);
 1711         };
printf("%s: soft resetting aclink\n", sc->sc_dev.dv_xname);
 1715         /* 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);
 1720         /* 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);
 1724         /* 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);
 1729         /* check if the ac-link is working; reset device otherwise */
timeout = 10;
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
 1732         while (!(value & ATI_REG_CMD_ACLINK_ACTIVE)) {
printf("%s: not up; resetting aclink hardware\n",
sc->sc_dev.dv_xname);
 1736                 /* 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);
 1741                 /* need to read CMD again and wait again (clocking in issue?) */
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
DELAY(20);
 1745                 /* 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);
 1750                 /* check if its active now */
value = bus_space_read_4(iot, ioh, ATI_REG_CMD);
timeout--;
 1754                 if (timeout == 0) break;
 1755         };
 1757         if (timeout == 0) {
printf("%s: giving up aclink reset\n", sc->sc_dev.dv_xname);
 1759         };
 1760         if (timeout != 10) {
printf("%s: aclink hardware reset successful\n",
sc->sc_dev.dv_xname);
 1763         };
 1765         /* 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);
 1769 }
 1771 /* chip hard init */
 1772 int
auixp_init(struct auixp_softc *sc)
 1774 {
bus_space_tag_t      iot;
bus_space_handle_t   ioh;
u_int32_t value;
iot = sc->sc_iot;
ioh = sc->sc_ioh;
 1781         /* disable all interrupts and clear all sources */
auixp_disable_interrupts(sc);
 1784         /* 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);
 1791         /* Reset AC-link */
auixp_reset_aclink(sc);
 1794         /*
 1795          * codecs get auto-detected later
 1796          *
 1797          * note: we are NOT enabling interrupts yet, no codecs have been
 1798          * detected yet nor is anything else set up
 1799          */
 1801         return 0;
 1802 }
 1804 /*
 1805  * TODO power saving and suspend / resume support
 1806  */
 1807 int
auixp_power(struct auixp_softc *sc, int state)
 1809 {
pcitag_t tag;
pci_chipset_tag_t pc;
pcireg_t data;
 1813         int pmcapreg;
tag = sc->sc_tag;
pc = sc->sc_pct;
 1817         if (pci_get_capability(pc, tag, PCI_CAP_PWRMGMT, &pmcapreg, 0)) {
data = pci_conf_read(pc, tag, pmcapreg + PCI_PMCSR);
 1819                 if ((data & PCI_PMCSR_STATE_MASK) != state)
pci_conf_write(pc, tag, pmcapreg + PCI_PMCSR, state);
 1821         }
 1823         return 0;
 1824 }
 1826 #if 0
 1827 void
auixp_powerhook(int why, void *hdl)
 1829 {
 1830         struct auixp_softc *sc;
sc = (struct auixp_softc *)hdl;
 1833         switch (why) {
 1834         case PWR_SUSPEND:
 1835         case PWR_STANDBY:
auixp_suspend(sc);
 1837                 break;
 1838         case PWR_RESUME:
auixp_resume(sc);
 1840 /* XXX fix me XXX */
 1841                 (sc->codec_if->vtbl->restore_ports)(sc->codec_if);
 1842                 break;
 1843         }
 1844 }
 1846 int
auixp_suspend(struct auixp_softc *sc)
 1848 {
 1850         /* XXX no power functions yet XXX */
 1851         return 0;
 1852 }
 1854 int
auixp_resume(struct auixp_softc *sc)
 1856 {
 1858         /* XXX no power functions yet XXX */
 1859         return 0;
 1860 }
 1861 #endif /* 0 */