The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/pci/fms.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: fms.c,v 1.18.4.1 2004/09/22 20:58:23 jmc Exp $ */
    2 
    3 /*-
    4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Witold J. Wnuk.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by the NetBSD
   21  *      Foundation, Inc. and its contributors.
   22  * 4. Neither the name of The NetBSD Foundation nor the names of its
   23  *    contributors may be used to endorse or promote products derived
   24  *    from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   36  * POSSIBILITY OF SUCH DAMAGE.
   37  */
   38 
   39 /*
   40  * Forte Media FM801 Audio Device Driver
   41  */
   42 
   43 #include <sys/cdefs.h>
   44 __KERNEL_RCSID(0, "$NetBSD: fms.c,v 1.18.4.1 2004/09/22 20:58:23 jmc Exp $");
   45 
   46 #include "mpu.h"
   47 
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/kernel.h>
   51 #include <sys/malloc.h>
   52 #include <sys/device.h>
   53 #include <sys/audioio.h>
   54 
   55 #include <uvm/uvm_extern.h>
   56 
   57 #include <machine/bus.h>
   58 #include <machine/cpu.h>
   59 
   60 #include <dev/pci/pcidevs.h>
   61 #include <dev/pci/pcivar.h>
   62 
   63 #include <dev/audio_if.h>
   64 #include <dev/mulaw.h>
   65 #include <dev/auconv.h>
   66 
   67 #include <dev/ic/ac97var.h>
   68 #include <dev/ic/mpuvar.h>
   69 
   70 #include <dev/pci/fmsvar.h>
   71 
   72 
   73 struct fms_dma {
   74         struct fms_dma *next;
   75         caddr_t addr;
   76         size_t size;
   77         bus_dmamap_t map;
   78         bus_dma_segment_t seg;
   79 };
   80 
   81 
   82 
   83 int     fms_match __P((struct device *, struct cfdata *, void *));
   84 void    fms_attach __P((struct device *, struct device *, void *));
   85 int     fms_intr __P((void *));
   86 
   87 int     fms_open __P((void *, int));
   88 void    fms_close __P((void *));
   89 int     fms_query_encoding __P((void *, struct audio_encoding *));
   90 int     fms_set_params __P((void *, int, int, struct audio_params *, 
   91                             struct audio_params *));
   92 int     fms_round_blocksize __P((void *, int));
   93 int     fms_halt_output __P((void *));
   94 int     fms_halt_input __P((void *));
   95 int     fms_getdev __P((void *, struct audio_device *));
   96 int     fms_set_port __P((void *, mixer_ctrl_t *));
   97 int     fms_get_port __P((void *, mixer_ctrl_t *));
   98 int     fms_query_devinfo __P((void *, mixer_devinfo_t *));
   99 void    *fms_malloc __P((void *, int, size_t, struct malloc_type *, int));
  100 void    fms_free __P((void *, void *, struct malloc_type *));
  101 size_t  fms_round_buffersize __P((void *, int, size_t));
  102 paddr_t fms_mappage __P((void *, void *, off_t, int));
  103 int     fms_get_props __P((void *));
  104 int     fms_trigger_output __P((void *, void *, void *, int, void (*)(void *),
  105                                 void *, struct audio_params *));
  106 int     fms_trigger_input __P((void *, void *, void *, int, void (*)(void *),
  107                                void *, struct audio_params *));
  108 
  109 CFATTACH_DECL(fms, sizeof (struct fms_softc),
  110     fms_match, fms_attach, NULL, NULL);
  111 
  112 struct audio_device fms_device = {
  113         "Forte Media 801",
  114         "1.0",
  115         "fms"
  116 };
  117 
  118 
  119 struct audio_hw_if fms_hw_if = {
  120         fms_open,
  121         fms_close,
  122         NULL,
  123         fms_query_encoding,
  124         fms_set_params,
  125         fms_round_blocksize,
  126         NULL,
  127         NULL,
  128         NULL,
  129         NULL,
  130         NULL,
  131         fms_halt_output,
  132         fms_halt_input,
  133         NULL,
  134         fms_getdev,
  135         NULL,
  136         fms_set_port,
  137         fms_get_port,
  138         fms_query_devinfo,
  139         fms_malloc,
  140         fms_free,
  141         fms_round_buffersize,
  142         fms_mappage,
  143         fms_get_props,
  144         fms_trigger_output,
  145         fms_trigger_input,
  146         NULL,
  147 };
  148 
  149 int     fms_attach_codec __P((void *, struct ac97_codec_if *));
  150 int     fms_read_codec __P((void *, u_int8_t, u_int16_t *));
  151 int     fms_write_codec __P((void *, u_int8_t, u_int16_t));
  152 int     fms_reset_codec __P((void *));
  153 
  154 int     fms_allocmem __P((struct fms_softc *, size_t, size_t,
  155                           struct fms_dma *));
  156 int     fms_freemem __P((struct fms_softc *, struct fms_dma *));
  157 
  158 #define FM_PCM_VOLUME           0x00
  159 #define FM_FM_VOLUME            0x02
  160 #define FM_I2S_VOLUME           0x04
  161 #define FM_RECORD_SOURCE        0x06
  162 
  163 #define FM_PLAY_CTL             0x08
  164 #define  FM_PLAY_RATE_MASK              0x0f00
  165 #define  FM_PLAY_BUF1_LAST              0x0001
  166 #define  FM_PLAY_BUF2_LAST              0x0002
  167 #define  FM_PLAY_START                  0x0020
  168 #define  FM_PLAY_PAUSE                  0x0040
  169 #define  FM_PLAY_STOPNOW                0x0080
  170 #define  FM_PLAY_16BIT                  0x4000
  171 #define  FM_PLAY_STEREO                 0x8000
  172 
  173 #define FM_PLAY_DMALEN          0x0a
  174 #define FM_PLAY_DMABUF1         0x0c
  175 #define FM_PLAY_DMABUF2         0x10
  176 
  177 
  178 #define FM_REC_CTL              0x14
  179 #define  FM_REC_RATE_MASK               0x0f00
  180 #define  FM_REC_BUF1_LAST               0x0001
  181 #define  FM_REC_BUF2_LAST               0x0002
  182 #define  FM_REC_START                   0x0020
  183 #define  FM_REC_PAUSE                   0x0040
  184 #define  FM_REC_STOPNOW                 0x0080
  185 #define  FM_REC_16BIT                   0x4000
  186 #define  FM_REC_STEREO                  0x8000
  187 
  188 
  189 #define FM_REC_DMALEN           0x16
  190 #define FM_REC_DMABUF1          0x18
  191 #define FM_REC_DMABUF2          0x1c
  192 
  193 #define FM_CODEC_CTL            0x22
  194 #define FM_VOLUME               0x26
  195 #define  FM_VOLUME_MUTE                 0x8000
  196 
  197 #define FM_CODEC_CMD            0x2a
  198 #define  FM_CODEC_CMD_READ              0x0080
  199 #define  FM_CODEC_CMD_VALID             0x0100
  200 #define  FM_CODEC_CMD_BUSY              0x0200
  201 
  202 #define FM_CODEC_DATA           0x2c
  203 
  204 #define FM_IO_CTL               0x52
  205 #define FM_CARD_CTL             0x54
  206 
  207 #define FM_INTMASK              0x56
  208 #define  FM_INTMASK_PLAY                0x0001
  209 #define  FM_INTMASK_REC                 0x0002
  210 #define  FM_INTMASK_VOL                 0x0040
  211 #define  FM_INTMASK_MPU                 0x0080
  212 
  213 #define FM_INTSTATUS            0x5a
  214 #define  FM_INTSTATUS_PLAY              0x0100
  215 #define  FM_INTSTATUS_REC               0x0200
  216 #define  FM_INTSTATUS_VOL               0x4000
  217 #define  FM_INTSTATUS_MPU               0x8000
  218 
  219 
  220 
  221 int
  222 fms_match(parent, match, aux)
  223         struct device *parent;
  224         struct cfdata *match;
  225         void *aux;
  226 {
  227         struct pci_attach_args *pa = (struct pci_attach_args *) aux;
  228 
  229         if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_FORTEMEDIA)
  230                 return 0;
  231         if (PCI_PRODUCT(pa->pa_id) != PCI_PRODUCT_FORTEMEDIA_FM801)
  232                 return 0;
  233         
  234         return 1;
  235 }
  236 
  237 void
  238 fms_attach(parent, self, aux)
  239         struct device *parent;
  240         struct device *self;
  241         void *aux;
  242 {
  243         struct pci_attach_args *pa = aux;
  244         struct fms_softc *sc = (struct fms_softc *) self;
  245         struct audio_attach_args aa;
  246         const char *intrstr = NULL;
  247         pci_chipset_tag_t pc = pa->pa_pc;
  248         pcitag_t pt = pa->pa_tag;
  249         pci_intr_handle_t ih;
  250         int i;
  251         
  252         u_int16_t k1;
  253 
  254         aprint_naive(": Audio controller\n");
  255         aprint_normal(": Forte Media FM-801\n");
  256         
  257         if (pci_intr_map(pa, &ih)) {
  258                 aprint_error("%s: couldn't map interrupt\n",
  259                     sc->sc_dev.dv_xname);
  260                 return;
  261         }
  262         intrstr = pci_intr_string(pc, ih);
  263         
  264         sc->sc_ih = pci_intr_establish(pc, ih, IPL_AUDIO, fms_intr, sc);
  265         if (sc->sc_ih == NULL) {
  266                 aprint_error("%s: couldn't establish interrupt",
  267                     sc->sc_dev.dv_xname);
  268                 if (intrstr != NULL)
  269                         aprint_normal(" at %s", intrstr);
  270                 aprint_normal("\n");
  271                 return;
  272         }
  273         
  274         sc->sc_dmat = pa->pa_dmat;
  275         
  276         aprint_normal("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr);
  277         
  278         if (pci_mapreg_map(pa, 0x10, PCI_MAPREG_TYPE_IO, 0, &sc->sc_iot,
  279                            &sc->sc_ioh, &sc->sc_ioaddr, &sc->sc_iosize)) {
  280                 aprint_error("%s: can't map i/o space\n", sc->sc_dev.dv_xname);
  281                 return;
  282         }
  283         
  284         if (bus_space_subregion(sc->sc_iot, sc->sc_ioh, 0x30, 2, 
  285                                 &sc->sc_mpu_ioh))
  286                 panic("fms_attach: can't get mpu subregion handle");
  287 
  288         if (bus_space_subregion(sc->sc_iot, sc->sc_ioh, 0x68, 4,
  289                                 &sc->sc_opl_ioh))
  290                 panic("fms_attach: can't get opl subregion handle");
  291 
  292         /* Disable legacy audio (SBPro compatibility) */
  293         pci_conf_write(pc, pt, 0x40, 0);
  294         
  295         /* Reset codec and AC'97 */
  296         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0020);
  297         delay(2);               /* > 1us according to AC'97 documentation */
  298         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0000);
  299         delay(1);               /* > 168.2ns according to AC'97 documentation */
  300         
  301         /* Set up volume */
  302         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PCM_VOLUME, 0x0808);
  303         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_FM_VOLUME, 0x0808);
  304         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_I2S_VOLUME, 0x0808);
  305         
  306         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_RECORD_SOURCE, 0x0000);
  307         
  308         /* Unmask playback, record and mpu interrupts, mask the rest */
  309         k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_INTMASK);
  310         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTMASK, 
  311             (k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
  312              FM_INTMASK_VOL);
  313         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS, 
  314             FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU | 
  315             FM_INTSTATUS_VOL);
  316         
  317         sc->host_if.arg = sc;
  318         sc->host_if.attach = fms_attach_codec;
  319         sc->host_if.read = fms_read_codec;
  320         sc->host_if.write = fms_write_codec;
  321         sc->host_if.reset = fms_reset_codec;
  322 
  323         if (ac97_attach(&sc->host_if) != 0)
  324                 return;
  325         
  326         /* Turn mute off */
  327         for (i = 0; i < 3; i++) {
  328                 static struct {
  329                         char *class, *device;
  330                 } d[] = {
  331                         { AudioCoutputs, AudioNmaster },
  332                         { AudioCinputs, AudioNdac },
  333                         { AudioCrecord, AudioNvolume }
  334                 };
  335                 struct mixer_ctrl ctl;
  336                 
  337                 ctl.type = AUDIO_MIXER_ENUM;
  338                 ctl.un.ord = 0;
  339                 ctl.dev = sc->codec_if->vtbl->get_portnum_by_name(sc->codec_if,
  340                         d[i].class, d[i].device, AudioNmute);
  341                 fms_set_port(sc, &ctl);
  342         }
  343 
  344         audio_attach_mi(&fms_hw_if, sc, &sc->sc_dev);
  345 
  346         aa.type = AUDIODEV_TYPE_OPL;
  347         aa.hwif = NULL;
  348         aa.hdl = NULL;
  349         config_found(&sc->sc_dev, &aa, audioprint);
  350 
  351         aa.type = AUDIODEV_TYPE_MPU;
  352         aa.hwif = NULL;
  353         aa.hdl = NULL;
  354         sc->sc_mpu_dev = config_found(&sc->sc_dev, &aa, audioprint);
  355 }
  356 
  357 /*
  358  * Each AC-link frame takes 20.8us, data should be ready in next frame,
  359  * we allow more than two.
  360  */
  361 #define TIMO 50
  362 int
  363 fms_read_codec(addr, reg, val)
  364         void *addr;
  365         u_int8_t reg;
  366         u_int16_t *val;
  367 {
  368         struct fms_softc *sc = addr;
  369         int i;
  370 
  371         /* Poll until codec is ready */
  372         for (i = 0; i < TIMO && bus_space_read_2(sc->sc_iot, sc->sc_ioh, 
  373                  FM_CODEC_CMD) & FM_CODEC_CMD_BUSY; i++)
  374                 delay(1);
  375         if (i >= TIMO) {
  376                 printf("fms: codec busy\n");
  377                 return 1;
  378         }
  379 
  380         /* Write register index, read access */
  381         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CMD, 
  382                           reg | FM_CODEC_CMD_READ);
  383         
  384         /* Poll until we have valid data */
  385         for (i = 0; i < TIMO && !(bus_space_read_2(sc->sc_iot, sc->sc_ioh, 
  386                  FM_CODEC_CMD) & FM_CODEC_CMD_VALID); i++)
  387                 delay(1);
  388         if (i >= TIMO) {
  389                 printf("fms: no data from codec\n");
  390                 return 1;
  391         }
  392         
  393         /* Read data */
  394         *val = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_DATA);
  395         return 0;
  396 }
  397 
  398 int
  399 fms_write_codec(addr, reg, val)
  400         void *addr;
  401         u_int8_t reg;
  402         u_int16_t val;
  403 {
  404         struct fms_softc *sc = addr;
  405         int i;
  406         
  407         /* Poll until codec is ready */
  408         for (i = 0; i < TIMO && bus_space_read_2(sc->sc_iot, sc->sc_ioh, 
  409                  FM_CODEC_CMD) & FM_CODEC_CMD_BUSY; i++)
  410                 delay(1);
  411         if (i >= TIMO) {
  412                 printf("fms: codec busy\n");
  413                 return 1;
  414         }
  415 
  416         /* Write data */
  417         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_DATA, val);
  418         /* Write index register, write access */
  419         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CMD, reg);
  420         return 0;
  421 }
  422 #undef TIMO
  423 
  424 int
  425 fms_attach_codec(addr, cif)
  426         void *addr;
  427         struct ac97_codec_if *cif;
  428 {
  429         struct fms_softc *sc = addr;
  430 
  431         sc->codec_if = cif;
  432         return 0;
  433 }
  434 
  435 /* Cold Reset */
  436 int
  437 fms_reset_codec(addr)
  438         void *addr;
  439 {
  440         struct fms_softc *sc = addr;
  441         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0020);
  442         delay(2);
  443         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_CODEC_CTL, 0x0000);
  444         delay(1);
  445         return 0;
  446 }
  447 
  448 int
  449 fms_intr(arg)
  450         void *arg;
  451 {
  452         struct fms_softc *sc = arg;
  453         u_int16_t istat;
  454         
  455         istat = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS);
  456 
  457         if (istat & FM_INTSTATUS_PLAY) {
  458                 if ((sc->sc_play_nextblk += sc->sc_play_blksize) >= 
  459                      sc->sc_play_end)
  460                         sc->sc_play_nextblk = sc->sc_play_start;
  461 
  462                 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 
  463                     sc->sc_play_flip++ & 1 ? 
  464                     FM_PLAY_DMABUF2 : FM_PLAY_DMABUF1, sc->sc_play_nextblk);
  465 
  466                 if (sc->sc_pintr)
  467                         sc->sc_pintr(sc->sc_parg);
  468                 else
  469                         printf("unexpected play intr\n");
  470         }
  471 
  472         if (istat & FM_INTSTATUS_REC) {
  473                 if ((sc->sc_rec_nextblk += sc->sc_rec_blksize) >= 
  474                      sc->sc_rec_end)
  475                         sc->sc_rec_nextblk = sc->sc_rec_start;
  476 
  477                 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 
  478                     sc->sc_rec_flip++ & 1 ? 
  479                     FM_REC_DMABUF2 : FM_REC_DMABUF1, sc->sc_rec_nextblk);
  480 
  481                 if (sc->sc_rintr)
  482                         sc->sc_rintr(sc->sc_rarg);
  483                 else
  484                         printf("unexpected rec intr\n");
  485         }
  486         
  487 #if NMPU > 0
  488         if (istat & FM_INTSTATUS_MPU)
  489                 mpu_intr(sc->sc_mpu_dev);
  490 #endif
  491 
  492         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_INTSTATUS, 
  493                           istat & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC));
  494         
  495         return 1;
  496 }
  497 
  498 int
  499 fms_open(addr, flags)
  500         void *addr;
  501         int flags;      
  502 {
  503         /* UNUSED struct fms_softc *sc = addr;*/
  504         
  505         return 0;
  506 }
  507 
  508 void
  509 fms_close(addr)
  510         void *addr;
  511 {
  512         /* UNUSED struct fms_softc *sc = addr;*/
  513 }
  514 
  515 int
  516 fms_query_encoding(addr, fp)
  517         void *addr;
  518         struct audio_encoding *fp;
  519 {
  520 
  521         switch (fp->index) {
  522         case 0:
  523                 strcpy(fp->name, AudioEmulaw);
  524                 fp->encoding = AUDIO_ENCODING_ULAW;
  525                 fp->precision = 8;
  526                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  527                 return 0; 
  528         case 1:
  529                 strcpy(fp->name, AudioEslinear_le);
  530                 fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
  531                 fp->precision = 16;
  532                 fp->flags = 0;
  533                 return 0;
  534         case 2:
  535                 strcpy(fp->name, AudioEulinear);
  536                 fp->encoding = AUDIO_ENCODING_ULINEAR;
  537                 fp->precision = 8;
  538                 fp->flags = 0;
  539                 return 0;
  540         case 3:
  541                 strcpy(fp->name, AudioEalaw);
  542                 fp->encoding = AUDIO_ENCODING_ALAW;
  543                 fp->precision = 8;
  544                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  545                 return 0;
  546         case 4:
  547                 strcpy(fp->name, AudioEulinear_le);
  548                 fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
  549                 fp->precision = 16;
  550                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  551                 return 0;
  552         case 5:
  553                 strcpy(fp->name, AudioEslinear);
  554                 fp->encoding = AUDIO_ENCODING_SLINEAR;
  555                 fp->precision = 8;
  556                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  557                 return 0;
  558         case 6:
  559                 strcpy(fp->name, AudioEulinear_be);
  560                 fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
  561                 fp->precision = 16;
  562                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  563                 return 0;
  564         case 7:
  565                 strcpy(fp->name, AudioEslinear_be);
  566                 fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
  567                 fp->precision = 16;
  568                 fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
  569                 return 0;
  570         default:
  571                 return EINVAL;
  572         }
  573 }
  574 
  575 /*
  576  * Range below -limit- is set to -rate-
  577  * What a pity FM801 does not have 24000
  578  * 24000 -> 22050 sounds rather poor
  579  */
  580 struct {
  581         int limit;
  582         int rate;
  583 } fms_rates[11] = {
  584         {  6600,  5500 },
  585         {  8750,  8000 },
  586         { 10250,  9600 },
  587         { 13200, 11025 },
  588         { 17500, 16000 },
  589         { 20500, 19200 },
  590         { 26500, 22050 },
  591         { 35000, 32000 },
  592         { 41000, 38400 },
  593         { 46000, 44100 },
  594         { 48000, 48000 },
  595         /* anything above -> 48000 */
  596 };
  597 
  598 int
  599 fms_set_params(addr, setmode, usemode, play, rec)
  600         void *addr;
  601         int setmode, usemode;
  602         struct audio_params *play, *rec;
  603 {
  604         struct fms_softc *sc = addr;
  605         int i;
  606 
  607         if (setmode & AUMODE_PLAY) {
  608                 play->factor = 1;
  609                 play->sw_code = 0;
  610                 switch(play->encoding) {
  611                 case AUDIO_ENCODING_ULAW:
  612                         play->factor = 2;
  613                         play->sw_code = mulaw_to_slinear16_le;
  614                         break;
  615                 case AUDIO_ENCODING_SLINEAR_LE:
  616                         if (play->precision == 8)
  617                                 play->sw_code = change_sign8;
  618                         break;
  619                 case AUDIO_ENCODING_ULINEAR_LE:
  620                         if (play->precision == 16)
  621                                 play->sw_code = change_sign16_le;
  622                         break;
  623                 case AUDIO_ENCODING_ALAW:
  624                         play->factor = 2;
  625                         play->sw_code = alaw_to_slinear16_le;
  626                         break;
  627                 case AUDIO_ENCODING_SLINEAR_BE:
  628                         if (play->precision == 16)
  629                                 play->sw_code = swap_bytes;
  630                         else
  631                                 play->sw_code = change_sign8;
  632                         break;
  633                 case AUDIO_ENCODING_ULINEAR_BE:
  634                         if (play->precision == 16)
  635                                 play->sw_code = change_sign16_swap_bytes_le;
  636                         break;
  637                 default:
  638                         return EINVAL;
  639                 }
  640                 for (i = 0; i < 10 && play->sample_rate > fms_rates[i].limit;
  641                      i++)
  642                         ;
  643                 play->sample_rate = fms_rates[i].rate;
  644                 sc->sc_play_reg = (play->channels == 2 ? FM_PLAY_STEREO : 0) |
  645                     (play->precision * play->factor == 16 ? FM_PLAY_16BIT : 0) |
  646                     (i << 8);
  647         }
  648 
  649         if (setmode & AUMODE_RECORD) {
  650 
  651                 rec->factor = 1;
  652                 rec->sw_code = 0;
  653                 switch(rec->encoding) {
  654                 case AUDIO_ENCODING_ULAW:
  655                         rec->sw_code = ulinear8_to_mulaw;
  656                         break;
  657                 case AUDIO_ENCODING_SLINEAR_LE:
  658                         if (rec->precision == 8)
  659                                 rec->sw_code = change_sign8;
  660                         break;
  661                 case AUDIO_ENCODING_ULINEAR_LE:
  662                         if (rec->precision == 16)
  663                                 rec->sw_code = change_sign16_le;
  664                         break;
  665                 case AUDIO_ENCODING_ALAW:
  666                         rec->sw_code = ulinear8_to_alaw;
  667                         break;
  668                 case AUDIO_ENCODING_SLINEAR_BE:
  669                         if (play->precision == 16)
  670                                 play->sw_code = swap_bytes;
  671                         else
  672                                 play->sw_code = change_sign8;
  673                         break;
  674                 case AUDIO_ENCODING_ULINEAR_BE:
  675                         if (play->precision == 16)
  676                                 play->sw_code = swap_bytes_change_sign16_le;
  677                         break;
  678                 default:
  679                         return EINVAL;
  680                 }
  681                 for (i = 0; i < 10 && rec->sample_rate > fms_rates[i].limit; 
  682                      i++)
  683                         ;
  684                 rec->sample_rate = fms_rates[i].rate;
  685                 sc->sc_rec_reg = 
  686                     (rec->channels == 2 ? FM_REC_STEREO : 0) | 
  687                     (rec->precision * rec->factor == 16 ? FM_REC_16BIT : 0) |
  688                     (i << 8);
  689         }
  690         
  691         return 0;
  692 }
  693 
  694 int
  695 fms_round_blocksize(addr, blk)
  696         void *addr;
  697         int blk;
  698 {
  699         return blk & ~0xf;
  700 }
  701 
  702 int
  703 fms_halt_output(addr)
  704         void *addr;
  705 {
  706         struct fms_softc *sc = addr;
  707         u_int16_t k1;
  708         
  709         k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL);
  710         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL, 
  711                           (k1 & ~(FM_PLAY_STOPNOW | FM_PLAY_START)) | 
  712                           FM_PLAY_BUF1_LAST | FM_PLAY_BUF2_LAST);
  713         
  714         return 0;
  715 }
  716 
  717 int
  718 fms_halt_input(addr)
  719         void *addr;
  720 {
  721         struct fms_softc *sc = addr;
  722         u_int16_t k1;
  723         
  724         k1 = bus_space_read_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL);
  725         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL, 
  726                           (k1 & ~(FM_REC_STOPNOW | FM_REC_START)) |
  727                           FM_REC_BUF1_LAST | FM_REC_BUF2_LAST);
  728         
  729         return 0;
  730 }
  731 
  732 int
  733 fms_getdev(addr, retp)
  734         void *addr;
  735         struct audio_device *retp;
  736 {
  737         *retp = fms_device;
  738         return 0;
  739 }
  740 
  741 int
  742 fms_set_port(addr, cp)
  743         void *addr;
  744         mixer_ctrl_t *cp;
  745 {
  746         struct fms_softc *sc = addr;
  747 
  748         return (sc->codec_if->vtbl->mixer_set_port(sc->codec_if, cp));
  749 }
  750 
  751 int
  752 fms_get_port(addr, cp)
  753         void *addr;
  754         mixer_ctrl_t *cp;
  755 {
  756         struct fms_softc *sc = addr;
  757         
  758         return (sc->codec_if->vtbl->mixer_get_port(sc->codec_if, cp));
  759 }
  760 
  761 void *
  762 fms_malloc(addr, direction, size, pool, flags)
  763         void *addr;
  764         int direction;
  765         size_t size;
  766         struct malloc_type *pool;
  767         int flags;
  768 {
  769         struct fms_softc *sc = addr;
  770         struct fms_dma *p;
  771         int error;
  772         int rseg;
  773         
  774         p = malloc(sizeof(*p), pool, flags);
  775         if (!p)
  776                 return 0;
  777         
  778         p->size = size;
  779         if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &p->seg,
  780                                       1, &rseg, BUS_DMA_NOWAIT)) != 0) {
  781                 printf("%s: unable to allocate DMA, error = %d\n", 
  782                        sc->sc_dev.dv_xname, error);
  783                 goto fail_alloc;
  784         }
  785         
  786         if ((error = bus_dmamem_map(sc->sc_dmat, &p->seg, rseg, size, &p->addr,
  787                                     BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
  788                 printf("%s: unable to map DMA, error = %d\n", 
  789                        sc->sc_dev.dv_xname, error);
  790                 goto fail_map;
  791         }
  792         
  793         if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0, 
  794                                        BUS_DMA_NOWAIT, &p->map)) != 0) {
  795                 printf("%s: unable to create DMA map, error = %d\n",
  796                        sc->sc_dev.dv_xname, error);
  797                 goto fail_create;
  798         }
  799         
  800         if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, size, NULL,
  801                                      BUS_DMA_NOWAIT)) != 0) {
  802                 printf("%s: unable to load DMA map, error = %d\n",
  803                        sc->sc_dev.dv_xname, error);
  804                 goto fail_load;
  805         }
  806         
  807         p->next = sc->sc_dmas;
  808         sc->sc_dmas = p;
  809 
  810         return p->addr;
  811 
  812 
  813 fail_load:
  814         bus_dmamap_destroy(sc->sc_dmat, p->map);
  815 fail_create:
  816         bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
  817 fail_map:
  818         bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
  819 fail_alloc:
  820         free(p, pool);
  821         return 0;
  822 }
  823 
  824 void
  825 fms_free(addr, ptr, pool)
  826         void *addr;
  827         void *ptr;
  828         struct malloc_type *pool;
  829 {
  830         struct fms_softc *sc = addr;
  831         struct fms_dma **pp, *p;
  832 
  833         for (pp = &(sc->sc_dmas); (p = *pp) != NULL; pp = &p->next)
  834                 if (p->addr == ptr) {
  835                         bus_dmamap_unload(sc->sc_dmat, p->map);
  836                         bus_dmamap_destroy(sc->sc_dmat, p->map);
  837                         bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
  838                         bus_dmamem_free(sc->sc_dmat, &p->seg, 1);
  839                         
  840                         *pp = p->next;
  841                         free(p, pool);
  842                         return;
  843                 }
  844 
  845         panic("fms_free: trying to free unallocated memory");
  846 }
  847 
  848 size_t
  849 fms_round_buffersize(addr, direction, size)
  850         void *addr;
  851         int direction;
  852         size_t size;
  853 {
  854         return size;
  855 }
  856 
  857 paddr_t
  858 fms_mappage(addr, mem, off, prot)
  859         void *addr;
  860         void *mem;
  861         off_t off;
  862         int prot;
  863 {
  864         struct fms_softc *sc = addr;
  865         struct fms_dma *p;
  866         
  867         if (off < 0)
  868                 return -1;
  869         
  870         for (p = sc->sc_dmas; p && p->addr != mem; p = p->next)
  871                 ;
  872         if (!p)
  873                 return -1;
  874         
  875         return bus_dmamem_mmap(sc->sc_dmat, &p->seg, 1, off, prot, 
  876                                BUS_DMA_WAITOK);
  877 }
  878 
  879 int
  880 fms_get_props(addr)
  881         void *addr;
  882 {
  883         return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | 
  884                AUDIO_PROP_FULLDUPLEX;
  885 }
  886 
  887 int
  888 fms_query_devinfo(addr, dip)
  889         void *addr;
  890         mixer_devinfo_t *dip;
  891 {
  892         struct fms_softc *sc = addr;
  893 
  894         return (sc->codec_if->vtbl->query_devinfo(sc->codec_if, dip));
  895 }
  896 
  897 int
  898 fms_trigger_output(addr, start, end, blksize, intr, arg, param)
  899         void *addr;
  900         void *start, *end;
  901         int blksize;
  902         void (*intr) __P((void *));
  903         void *arg;
  904         struct audio_params *param;
  905 {
  906         struct fms_softc *sc = addr;
  907         struct fms_dma *p;
  908         
  909         sc->sc_pintr = intr;
  910         sc->sc_parg = arg;
  911         
  912         for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
  913                 ;
  914         
  915         if (!p)
  916                 panic("fms_trigger_output: request with bad start "
  917                       "address (%p)", start);
  918 
  919         sc->sc_play_start = p->map->dm_segs[0].ds_addr;
  920         sc->sc_play_end = sc->sc_play_start + ((char *)end - (char *)start);
  921         sc->sc_play_blksize = blksize;
  922         sc->sc_play_nextblk = sc->sc_play_start + sc->sc_play_blksize;  
  923         sc->sc_play_flip = 0;
  924         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMALEN, blksize - 1);
  925         bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMABUF1, 
  926                           sc->sc_play_start);
  927         bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_PLAY_DMABUF2, 
  928                           sc->sc_play_nextblk);
  929         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_PLAY_CTL, 
  930                           FM_PLAY_START | FM_PLAY_STOPNOW | sc->sc_play_reg);
  931         return 0;
  932 }
  933 
  934 
  935 int
  936 fms_trigger_input(addr, start, end, blksize, intr, arg, param)
  937         void *addr;
  938         void *start, *end;
  939         int blksize;
  940         void (*intr) __P((void *));
  941         void *arg;
  942         struct audio_params *param;
  943 {
  944         struct fms_softc *sc = addr;
  945         struct fms_dma *p;
  946         
  947         sc->sc_rintr = intr;
  948         sc->sc_rarg = arg;
  949         
  950         for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
  951                 ;
  952         
  953         if (!p)
  954                 panic("fms_trigger_input: request with bad start "
  955                       "address (%p)", start);
  956 
  957         sc->sc_rec_start = p->map->dm_segs[0].ds_addr;
  958         sc->sc_rec_end = sc->sc_rec_start + ((char *)end - (char *)start);
  959         sc->sc_rec_blksize = blksize;
  960         sc->sc_rec_nextblk = sc->sc_rec_start + sc->sc_rec_blksize;     
  961         sc->sc_rec_flip = 0;
  962         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_DMALEN, blksize - 1);
  963         bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_REC_DMABUF1, 
  964                           sc->sc_rec_start);
  965         bus_space_write_4(sc->sc_iot, sc->sc_ioh, FM_REC_DMABUF2, 
  966                           sc->sc_rec_nextblk);
  967         bus_space_write_2(sc->sc_iot, sc->sc_ioh, FM_REC_CTL, 
  968                           FM_REC_START | FM_REC_STOPNOW | sc->sc_rec_reg);
  969         return 0;
  970 }
  971 
  972 

Cache object: dbc2a0192ef9e9fdebfaa585444a7a4c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.