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/sound/isa/gusc.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 1999 Seigo Tanimura
    5  * Copyright (c) 1999 Ville-Pertti Keinonen
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/kernel.h>
   33 #include <sys/bus.h>
   34 #include <sys/malloc.h>
   35 #include <sys/module.h>
   36 #include <machine/resource.h>
   37 #include <machine/bus.h>
   38 #include <sys/rman.h>
   39 
   40 #ifdef HAVE_KERNEL_OPTION_HEADERS
   41 #include "opt_snd.h"
   42 #endif
   43 
   44 #include <dev/sound/pcm/sound.h>
   45 #include <dev/sound/chip.h>
   46 #include "bus_if.h"
   47 
   48 #include <isa/isavar.h>
   49 #include <isa/isa_common.h>
   50 
   51 SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/isa/gusc.c 328524 2018-01-29 00:22:30Z imp $");
   52 
   53 #define LOGICALID_NOPNP 0
   54 #define LOGICALID_PCM   0x0000561e
   55 #define LOGICALID_OPL   0x0300561e
   56 #define LOGICALID_MIDI  0x0400561e
   57 
   58 /* PnP IDs */
   59 static struct isa_pnp_id gusc_ids[] = {
   60         {LOGICALID_PCM,  "GRV0000 Gravis UltraSound PnP PCM"},  /* GRV0000 */
   61         {LOGICALID_OPL,  "GRV0003 Gravis UltraSound PnP OPL"},  /* GRV0003 */
   62         {LOGICALID_MIDI, "GRV0004 Gravis UltraSound PnP MIDI"}, /* GRV0004 */
   63 };
   64 
   65 /* Interrupt handler.  */
   66 struct gusc_ihandler {
   67         void (*intr)(void *);
   68         void *arg;
   69 };
   70 
   71 /* Here is the parameter structure per a device. */
   72 struct gusc_softc {
   73         device_t dev; /* device */
   74         int io_rid[3]; /* io port rids */
   75         struct resource *io[3]; /* io port resources */
   76         int io_alloced[3]; /* io port alloc flag */
   77         int irq_rid; /* irq rids */
   78         struct resource *irq; /* irq resources */
   79         int irq_alloced; /* irq alloc flag */
   80         int drq_rid[2]; /* drq rids */
   81         struct resource *drq[2]; /* drq resources */
   82         int drq_alloced[2]; /* drq alloc flag */
   83 
   84         /* Interrupts are shared (XXX non-PnP only?) */
   85         struct gusc_ihandler midi_intr;
   86         struct gusc_ihandler pcm_intr;
   87 };
   88 
   89 typedef struct gusc_softc *sc_p;
   90 
   91 static int gusc_probe(device_t dev);
   92 static int gusc_attach(device_t dev);
   93 static int gusisa_probe(device_t dev);
   94 static void gusc_intr(void *);
   95 static struct resource *gusc_alloc_resource(device_t bus, device_t child, int type, int *rid,
   96                                             rman_res_t start, rman_res_t end, rman_res_t count, u_int flags);
   97 static int gusc_release_resource(device_t bus, device_t child, int type, int rid,
   98                                    struct resource *r);
   99 
  100 static device_t find_masterdev(sc_p scp);
  101 static int alloc_resource(sc_p scp);
  102 static int release_resource(sc_p scp);
  103 
  104 static devclass_t gusc_devclass;
  105 
  106 static int
  107 gusc_probe(device_t dev)
  108 {
  109         device_t child;
  110         u_int32_t logical_id;
  111         char *s;
  112         struct sndcard_func *func;
  113         int ret;
  114 
  115         logical_id = isa_get_logicalid(dev);
  116         s = NULL;
  117 
  118         /* Check isapnp ids */
  119         if (logical_id != 0 && (ret = ISA_PNP_PROBE(device_get_parent(dev), dev, gusc_ids)) != 0)
  120                 return (ret);
  121         else {
  122                 if (logical_id == 0)
  123                         return gusisa_probe(dev);
  124         }
  125 
  126         switch (logical_id) {
  127         case LOGICALID_PCM:
  128                 s = "Gravis UltraSound Plug & Play PCM";
  129                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
  130                 if (func == NULL)
  131                         return (ENOMEM);
  132                 func->func = SCF_PCM;
  133                 child = device_add_child(dev, "pcm", -1);
  134                 device_set_ivars(child, func);
  135                 break;
  136         case LOGICALID_OPL:
  137                 s = "Gravis UltraSound Plug & Play OPL";
  138                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
  139                 if (func == NULL)
  140                         return (ENOMEM);
  141                 func->func = SCF_SYNTH;
  142                 child = device_add_child(dev, "midi", -1);
  143                 device_set_ivars(child, func);
  144                 break;
  145         case LOGICALID_MIDI:
  146                 s = "Gravis UltraSound Plug & Play MIDI";
  147                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
  148                 if (func == NULL)
  149                         return (ENOMEM);
  150                 func->func = SCF_MIDI;
  151                 child = device_add_child(dev, "midi", -1);
  152                 device_set_ivars(child, func);
  153                 break;
  154         }
  155 
  156         if (s != NULL) {
  157                 device_set_desc(dev, s);
  158                 return (0);
  159         }
  160 
  161         return (ENXIO);
  162 }
  163 
  164 static void
  165 port_wr(struct resource *r, int i, unsigned char v)
  166 {
  167         bus_space_write_1(rman_get_bustag(r), rman_get_bushandle(r), i, v);
  168 }
  169 
  170 static int
  171 port_rd(struct resource *r, int i)
  172 {
  173         return bus_space_read_1(rman_get_bustag(r), rman_get_bushandle(r), i);
  174 }
  175 
  176 /*
  177  * Probe for an old (non-PnP) GUS card on the ISA bus.
  178  */
  179 
  180 static int
  181 gusisa_probe(device_t dev)
  182 {
  183         device_t child;
  184         struct resource *res, *res2;
  185         int base, rid, rid2, s, flags;
  186         unsigned char val;
  187 
  188         base = isa_get_port(dev);
  189         flags = device_get_flags(dev);
  190         rid = 1;
  191         res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, base + 0x100,
  192                                  base + 0x107, 8, RF_ACTIVE);
  193 
  194         if (res == NULL)
  195                 return ENXIO;
  196 
  197         res2 = NULL;
  198 
  199         /*
  200          * Check for the presence of some GUS card.  Reset the card,
  201          * then see if we can access the memory on it.
  202          */
  203 
  204         port_wr(res, 3, 0x4c);
  205         port_wr(res, 5, 0);
  206         DELAY(30 * 1000);
  207 
  208         port_wr(res, 3, 0x4c);
  209         port_wr(res, 5, 1);
  210         DELAY(30 * 1000);
  211 
  212         s = splhigh();
  213 
  214         /* Write to DRAM.  */
  215 
  216         port_wr(res, 3, 0x43);          /* Register select */
  217         port_wr(res, 4, 0);             /* Low addr */
  218         port_wr(res, 5, 0);             /* Med addr */
  219 
  220         port_wr(res, 3, 0x44);          /* Register select */
  221         port_wr(res, 4, 0);             /* High addr */
  222         port_wr(res, 7, 0x55);          /* DRAM */
  223 
  224         /* Read from DRAM.  */
  225 
  226         port_wr(res, 3, 0x43);          /* Register select */
  227         port_wr(res, 4, 0);             /* Low addr */
  228         port_wr(res, 5, 0);             /* Med addr */
  229 
  230         port_wr(res, 3, 0x44);          /* Register select */
  231         port_wr(res, 4, 0);             /* High addr */
  232         val = port_rd(res, 7);          /* DRAM */
  233 
  234         splx(s);
  235 
  236         if (val != 0x55)
  237                 goto fail;
  238 
  239         rid2 = 0;
  240         res2 = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid2, base, base, 1,
  241                                   RF_ACTIVE);
  242 
  243         if (res2 == NULL)
  244                 goto fail;
  245 
  246         s = splhigh();
  247         port_wr(res2, 0x0f, 0x20);
  248         val = port_rd(res2, 0x0f);
  249         splx(s);
  250 
  251         if (val == 0xff || (val & 0x06) == 0)
  252                 val = 0;
  253         else {
  254                 val = port_rd(res2, 0x506);     /* XXX Out of range.  */
  255                 if (val == 0xff)
  256                         val = 0;
  257         }
  258 
  259         bus_release_resource(dev, SYS_RES_IOPORT, rid2, res2);
  260         bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
  261 
  262         if (val >= 10) {
  263                 struct sndcard_func *func;
  264 
  265                 /* Looks like a GUS MAX.  Set the rest of the resources.  */
  266 
  267                 bus_set_resource(dev, SYS_RES_IOPORT, 2, base + 0x10c, 8);
  268 
  269                 if (flags & DV_F_DUAL_DMA)
  270                         bus_set_resource(dev, SYS_RES_DRQ, 1,
  271                                          flags & DV_F_DRQ_MASK, 1);
  272 
  273                 /* We can support the CS4231 and MIDI devices.  */
  274 
  275                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
  276                 if (func == NULL)
  277                         return ENOMEM;
  278                 func->func = SCF_MIDI;
  279                 child = device_add_child(dev, "midi", -1);
  280                 device_set_ivars(child, func);
  281 
  282                 func = malloc(sizeof(struct sndcard_func), M_DEVBUF, M_NOWAIT | M_ZERO);
  283                 if (func == NULL)
  284                         printf("xxx: gus pcm not attached, out of memory\n");
  285                 else {
  286                         func->func = SCF_PCM;
  287                         child = device_add_child(dev, "pcm", -1);
  288                         device_set_ivars(child, func);
  289                 }
  290                 device_set_desc(dev, "Gravis UltraSound MAX");
  291                 return 0;
  292         } else {
  293 
  294                 /*
  295                  * TODO: Support even older GUS cards.  MIDI should work on
  296                  * all models.
  297                  */
  298                 return ENXIO;
  299         }
  300 
  301 fail:
  302         bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
  303         return ENXIO;
  304 }
  305 
  306 static int
  307 gusc_attach(device_t dev)
  308 {
  309         sc_p scp;
  310         void *ih;
  311 
  312         scp = device_get_softc(dev);
  313 
  314         bzero(scp, sizeof(*scp));
  315 
  316         scp->dev = dev;
  317         if (alloc_resource(scp)) {
  318                 release_resource(scp);
  319                 return (ENXIO);
  320         }
  321 
  322         if (scp->irq != NULL)
  323                 snd_setup_intr(dev, scp->irq, 0, gusc_intr, scp, &ih);
  324         bus_generic_attach(dev);
  325 
  326         return (0);
  327 }
  328 
  329 /*
  330  * Handle interrupts on GUS devices until there aren't any left.
  331  */
  332 static void
  333 gusc_intr(void *arg)
  334 {
  335         sc_p scp = (sc_p)arg;
  336         int did_something;
  337 
  338         do {
  339                 did_something = 0;
  340                 if (scp->pcm_intr.intr != NULL &&
  341                     (port_rd(scp->io[2], 2) & 1)) {
  342                         (*scp->pcm_intr.intr)(scp->pcm_intr.arg);
  343                         did_something = 1;
  344                 }
  345                 if (scp->midi_intr.intr != NULL &&
  346                     (port_rd(scp->io[1], 0) & 0x80)) {
  347                         (*scp->midi_intr.intr)(scp->midi_intr.arg);
  348                         did_something = 1;
  349                 }
  350         } while (did_something != 0);
  351 }
  352 
  353 static struct resource *
  354 gusc_alloc_resource(device_t bus, device_t child, int type, int *rid,
  355                     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
  356 {
  357         sc_p scp;
  358         int *alloced, rid_max, alloced_max;
  359         struct resource **res;
  360 
  361         scp = device_get_softc(bus);
  362         switch (type) {
  363         case SYS_RES_IOPORT:
  364                 alloced = scp->io_alloced;
  365                 res = scp->io;
  366                 rid_max = 2;
  367                 alloced_max = 2; /* pcm + midi (more to include synth) */
  368                 break;
  369         case SYS_RES_IRQ:
  370                 alloced = &scp->irq_alloced;
  371                 res = &scp->irq;
  372                 rid_max = 0;
  373                 alloced_max = 2; /* pcm and midi share the single irq. */
  374                 break;
  375         case SYS_RES_DRQ:
  376                 alloced = scp->drq_alloced;
  377                 res = scp->drq;
  378                 rid_max = 1;
  379                 alloced_max = 1;
  380                 break;
  381         default:
  382                 return (NULL);
  383         }
  384 
  385         if (*rid > rid_max || alloced[*rid] == alloced_max)
  386                 return (NULL);
  387 
  388         alloced[*rid]++;
  389         return (res[*rid]);
  390 }
  391 
  392 static int
  393 gusc_release_resource(device_t bus, device_t child, int type, int rid,
  394                         struct resource *r)
  395 {
  396         sc_p scp;
  397         int *alloced, rid_max;
  398 
  399         scp = device_get_softc(bus);
  400         switch (type) {
  401         case SYS_RES_IOPORT:
  402                 alloced = scp->io_alloced;
  403                 rid_max = 2;
  404                 break;
  405         case SYS_RES_IRQ:
  406                 alloced = &scp->irq_alloced;
  407                 rid_max = 0;
  408                 break;
  409         case SYS_RES_DRQ:
  410                 alloced = scp->drq_alloced;
  411                 rid_max = 1;
  412                 break;
  413         default:
  414                 return (1);
  415         }
  416 
  417         if (rid > rid_max || alloced[rid] == 0)
  418                 return (1);
  419 
  420         alloced[rid]--;
  421         return (0);
  422 }
  423 
  424 static int
  425 gusc_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
  426                 driver_filter_t *filter,
  427                 driver_intr_t *intr, void *arg, void **cookiep)
  428 {
  429         sc_p scp = (sc_p)device_get_softc(dev);
  430         devclass_t devclass;
  431 
  432         if (filter != NULL) {
  433                 printf("gusc.c: we cannot use a filter here\n");
  434                 return (EINVAL);
  435         }
  436         devclass = device_get_devclass(child);
  437         if (strcmp(devclass_get_name(devclass), "midi") == 0) {
  438                 scp->midi_intr.intr = intr;
  439                 scp->midi_intr.arg = arg;
  440                 return 0;
  441         } else if (strcmp(devclass_get_name(devclass), "pcm") == 0) {
  442                 scp->pcm_intr.intr = intr;
  443                 scp->pcm_intr.arg = arg;
  444                 return 0;
  445         }
  446         return bus_generic_setup_intr(dev, child, irq, flags,
  447                                 filter,
  448                                 intr, arg, cookiep);
  449 }
  450 
  451 static device_t
  452 find_masterdev(sc_p scp)
  453 {
  454         int i, units;
  455         devclass_t devclass;
  456         device_t dev;
  457 
  458         devclass = device_get_devclass(scp->dev);
  459         units = devclass_get_maxunit(devclass);
  460         dev = NULL;
  461         for (i = 0 ; i < units ; i++) {
  462                 dev = devclass_get_device(devclass, i);
  463                 if (isa_get_vendorid(dev) == isa_get_vendorid(scp->dev)
  464                     && isa_get_logicalid(dev) == LOGICALID_PCM
  465                     && isa_get_serial(dev) == isa_get_serial(scp->dev))
  466                         break;
  467         }
  468         if (i == units)
  469                 return (NULL);
  470 
  471         return (dev);
  472 }
  473 
  474 static int io_range[3]  = {0x10, 0x8  , 0x4  };
  475 static int io_offset[3] = {0x0 , 0x100, 0x10c};
  476 static int
  477 alloc_resource(sc_p scp)
  478 {
  479         int i, base, lid, flags;
  480         device_t dev;
  481 
  482         flags = 0;
  483         if (isa_get_vendorid(scp->dev))
  484                 lid = isa_get_logicalid(scp->dev);
  485         else {
  486                 lid = LOGICALID_NOPNP;
  487                 flags = device_get_flags(scp->dev);
  488         }
  489         switch(lid) {
  490         case LOGICALID_PCM:
  491         case LOGICALID_NOPNP:           /* XXX Non-PnP */
  492                 if (lid == LOGICALID_NOPNP)
  493                         base = isa_get_port(scp->dev);
  494                 else
  495                         base = 0;
  496                 for (i = 0 ; i < nitems(scp->io); i++) {
  497                         if (scp->io[i] == NULL) {
  498                                 scp->io_rid[i] = i;
  499                                 if (base == 0)
  500                                         scp->io[i] =
  501                                             bus_alloc_resource_anywhere(scp->dev,
  502                                                                         SYS_RES_IOPORT,
  503                                                                         &scp->io_rid[i],
  504                                                                         io_range[i],
  505                                                                         RF_ACTIVE);
  506                                 else
  507                                         scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
  508                                                                         base + io_offset[i],
  509                                                                         base + io_offset[i] + io_range[i] - 1
  510                                                                         , io_range[i], RF_ACTIVE);
  511                                 if (scp->io[i] == NULL)
  512                                         return (1);
  513                                 scp->io_alloced[i] = 0;
  514                         }
  515                 }
  516                 if (scp->irq == NULL) {
  517                         scp->irq_rid = 0;
  518                         scp->irq = 
  519                                 bus_alloc_resource_any(scp->dev, SYS_RES_IRQ, 
  520                                                        &scp->irq_rid,
  521                                                        RF_ACTIVE|RF_SHAREABLE);
  522                         if (scp->irq == NULL)
  523                                 return (1);
  524                         scp->irq_alloced = 0;
  525                 }
  526                 for (i = 0 ; i < nitems(scp->drq); i++) {
  527                         if (scp->drq[i] == NULL) {
  528                                 scp->drq_rid[i] = i;
  529                                 if (base == 0 || i == 0)
  530                                         scp->drq[i] = 
  531                                                 bus_alloc_resource_any(
  532                                                         scp->dev, SYS_RES_DRQ,
  533                                                         &scp->drq_rid[i],
  534                                                         RF_ACTIVE);
  535                                 else if ((flags & DV_F_DUAL_DMA) != 0)
  536                                         /* XXX The secondary drq is specified in the flag. */
  537                                         scp->drq[i] = bus_alloc_resource(scp->dev, SYS_RES_DRQ, &scp->drq_rid[i],
  538                                                                          flags & DV_F_DRQ_MASK,
  539                                                                          flags & DV_F_DRQ_MASK, 1, RF_ACTIVE);
  540                                 if (scp->drq[i] == NULL)
  541                                         return (1);
  542                                 scp->drq_alloced[i] = 0;
  543                         }
  544                 }
  545                 break;
  546         case LOGICALID_OPL:
  547                 if (scp->io[0] == NULL) {
  548                         scp->io_rid[0] = 0;
  549                         scp->io[0] = bus_alloc_resource_anywhere(scp->dev,
  550                                                                  SYS_RES_IOPORT,
  551                                                                  &scp->io_rid[0],
  552                                                                  io_range[0],
  553                                                                  RF_ACTIVE);
  554                         if (scp->io[0] == NULL)
  555                                 return (1);
  556                         scp->io_alloced[0] = 0;
  557                 }
  558                 break;
  559         case LOGICALID_MIDI:
  560                 if (scp->io[0] == NULL) {
  561                         scp->io_rid[0] = 0;
  562                         scp->io[0] = bus_alloc_resource_anywhere(scp->dev,
  563                                                                  SYS_RES_IOPORT,
  564                                                                  &scp->io_rid[0],
  565                                                                  io_range[0],
  566                                                                  RF_ACTIVE);
  567                         if (scp->io[0] == NULL)
  568                                 return (1);
  569                         scp->io_alloced[0] = 0;
  570                 }
  571                 if (scp->irq == NULL) {
  572                         /* The irq is shared with pcm audio. */
  573                         dev = find_masterdev(scp);
  574                         if (dev == NULL)
  575                                 return (1);
  576                         scp->irq_rid = 0;
  577                         scp->irq = BUS_ALLOC_RESOURCE(dev, NULL, SYS_RES_IRQ, &scp->irq_rid,
  578                                                       0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
  579                         if (scp->irq == NULL)
  580                                 return (1);
  581                         scp->irq_alloced = 0;
  582                 }
  583                 break;
  584         }
  585         return (0);
  586 }
  587 
  588 static int
  589 release_resource(sc_p scp)
  590 {
  591         int i, lid;
  592         device_t dev;
  593 
  594         if (isa_get_vendorid(scp->dev))
  595                 lid = isa_get_logicalid(scp->dev);
  596         else
  597                 lid = LOGICALID_NOPNP;
  598 
  599         switch(lid) {
  600         case LOGICALID_PCM:
  601         case LOGICALID_NOPNP:           /* XXX Non-PnP */
  602                 for (i = 0 ; i < nitems(scp->io); i++) {
  603                         if (scp->io[i] != NULL) {
  604                                 bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
  605                                 scp->io[i] = NULL;
  606                         }
  607                 }
  608                 if (scp->irq != NULL) {
  609                         bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid, scp->irq);
  610                         scp->irq = NULL;
  611                 }
  612                 for (i = 0 ; i < nitems(scp->drq); i++) {
  613                         if (scp->drq[i] != NULL) {
  614                                 bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
  615                                 scp->drq[i] = NULL;
  616                         }
  617                 }
  618                 break;
  619         case LOGICALID_OPL:
  620                 if (scp->io[0] != NULL) {
  621                         bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
  622                         scp->io[0] = NULL;
  623                 }
  624                 break;
  625         case LOGICALID_MIDI:
  626                 if (scp->io[0] != NULL) {
  627                         bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
  628                         scp->io[0] = NULL;
  629                 }
  630                 if (scp->irq != NULL) {
  631                         /* The irq is shared with pcm audio. */
  632                         dev = find_masterdev(scp);
  633                         if (dev == NULL)
  634                                 return (1);
  635                         BUS_RELEASE_RESOURCE(dev, NULL, SYS_RES_IOPORT, scp->irq_rid, scp->irq);
  636                         scp->irq = NULL;
  637                 }
  638                 break;
  639         }
  640         return (0);
  641 }
  642 
  643 static device_method_t gusc_methods[] = {
  644         /* Device interface */
  645         DEVMETHOD(device_probe,         gusc_probe),
  646         DEVMETHOD(device_attach,        gusc_attach),
  647         DEVMETHOD(device_detach,        bus_generic_detach),
  648         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  649         DEVMETHOD(device_suspend,       bus_generic_suspend),
  650         DEVMETHOD(device_resume,        bus_generic_resume),
  651 
  652         /* Bus interface */
  653         DEVMETHOD(bus_alloc_resource,   gusc_alloc_resource),
  654         DEVMETHOD(bus_release_resource, gusc_release_resource),
  655         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
  656         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
  657         DEVMETHOD(bus_setup_intr,       gusc_setup_intr),
  658         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
  659 
  660         DEVMETHOD_END
  661 };
  662 
  663 static driver_t gusc_driver = {
  664         "gusc",
  665         gusc_methods,
  666         sizeof(struct gusc_softc),
  667 };
  668 
  669 /*
  670  * gusc can be attached to an isa bus.
  671  */
  672 DRIVER_MODULE(snd_gusc, isa, gusc_driver, gusc_devclass, 0, 0);
  673 DRIVER_MODULE(snd_gusc, acpi, gusc_driver, gusc_devclass, 0, 0);
  674 MODULE_DEPEND(snd_gusc, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
  675 MODULE_VERSION(snd_gusc, 1);
  676 ISA_PNP_INFO(gusc_ids);

Cache object: 78b4f01b00710c4c32bb19488b54ffa1


[ 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.