sys/dev/sound/isa/gusc.c

   1 /*
   2  * Copyright (c) 1999 Seigo Tanimura
   3  * Copyright (c) 1999 Ville-Pertti Keinonen
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/sound/isa/gusc.c,v 1.5.2.6 2002/04/22 15:49:30 cg Exp $
  28  * $DragonFly: src/sys/dev/sound/isa/gusc.c,v 1.4 2005/05/24 20:59:04 dillon Exp $
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/kernel.h>
  34 #include <sys/bus.h>
  35 #include <sys/malloc.h>
  36 #include <sys/module.h>
  37 #include <machine/resource.h>
  38 #include <machine/bus.h>
  39 #include <sys/rman.h>
  40 #include <sys/soundcard.h>
  41 #include <dev/sound/pcm/sound.h>
  42 #include <dev/sound/chip.h>
  43 #include "bus_if.h"
  44
  45 #include <bus/isa/isavar.h>
  46 #include <bus/isa/isa_common.h>
  47 #ifdef __alpha__                /* XXX workaround a stupid warning */
  48 #include <alpha/isa/isavar.h>
  49 #endif
  50
  51 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/isa/gusc.c,v 1.4 2005/05/24 20:59:04 dillon Exp $");
  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                                               u_long start, u_long end, u_long 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         int unit;
 311         void *ih;
 312
 313         scp = device_get_softc(dev);
 314         unit = device_get_unit(dev);
 315
 316         bzero(scp, sizeof(*scp));
 317
 318         scp->dev = dev;
 319         if (alloc_resource(scp)) {
 320                 release_resource(scp);
 321                 return (ENXIO);
 322         }
 323
 324         if (scp->irq != NULL) {
 325                 bus_setup_intr(dev, scp->irq, INTR_TYPE_AV, gusc_intr, scp,
 326                                &ih, NULL);
 327         }
 328         bus_generic_attach(dev);
 329
 330         return (0);
 331 }
 332
 333 /*
 334  * Handle interrupts on GUS devices until there aren't any left.
 335  */
 336 static void
 337 gusc_intr(void *arg)
 338 {
 339         sc_p scp = (sc_p)arg;
 340         int did_something;
 341
 342         do {
 343                 did_something = 0;
 344                 if (scp->pcm_intr.intr != NULL &&
 345                     (port_rd(scp->io[2], 2) & 1)) {
 346                         (*scp->pcm_intr.intr)(scp->pcm_intr.arg);
 347                         did_something = 1;
 348                 }
 349                 if (scp->midi_intr.intr != NULL &&
 350                     (port_rd(scp->io[1], 0) & 0x80)) {
 351                         (*scp->midi_intr.intr)(scp->midi_intr.arg);
 352                         did_something = 1;
 353                 }
 354         } while (did_something != 0);
 355 }
 356
 357 static struct resource *
 358 gusc_alloc_resource(device_t bus, device_t child, int type, int *rid,
 359                       u_long start, u_long end, u_long count, u_int flags)
 360 {
 361         sc_p scp;
 362         int *alloced, rid_max, alloced_max;
 363         struct resource **res;
 364
 365         scp = device_get_softc(bus);
 366         switch (type) {
 367         case SYS_RES_IOPORT:
 368                 alloced = scp->io_alloced;
 369                 res = scp->io;
 370                 rid_max = 2;
 371                 alloced_max = 2; /* pcm + midi (more to include synth) */
 372                 break;
 373         case SYS_RES_IRQ:
 374                 alloced = &scp->irq_alloced;
 375                 res = &scp->irq;
 376                 rid_max = 0;
 377                 alloced_max = 2; /* pcm and midi share the single irq. */
 378                 break;
 379         case SYS_RES_DRQ:
 380                 alloced = scp->drq_alloced;
 381                 res = scp->drq;
 382                 rid_max = 1;
 383                 alloced_max = 1;
 384                 break;
 385         default:
 386                 return (NULL);
 387         }
 388
 389         if (*rid > rid_max || alloced[*rid] == alloced_max)
 390                 return (NULL);
 391
 392         alloced[*rid]++;
 393         return (res[*rid]);
 394 }
 395
 396 static int
 397 gusc_release_resource(device_t bus, device_t child, int type, int rid,
 398                         struct resource *r)
 399 {
 400         sc_p scp;
 401         int *alloced, rid_max;
 402
 403         scp = device_get_softc(bus);
 404         switch (type) {
 405         case SYS_RES_IOPORT:
 406                 alloced = scp->io_alloced;
 407                 rid_max = 2;
 408                 break;
 409         case SYS_RES_IRQ:
 410                 alloced = &scp->irq_alloced;
 411                 rid_max = 0;
 412                 break;
 413         case SYS_RES_DRQ:
 414                 alloced = scp->drq_alloced;
 415                 rid_max = 1;
 416                 break;
 417         default:
 418                 return (1);
 419         }
 420
 421         if (rid > rid_max || alloced[rid] == 0)
 422                 return (1);
 423
 424         alloced[rid]--;
 425         return (0);
 426 }
 427
 428 static int
 429 gusc_setup_intr(device_t dev, device_t child, struct resource *irq,
 430                 int flags, driver_intr_t *intr, void *arg,
 431                 void **cookiep, lwkt_serialize_t serializer)
 432 {
 433         sc_p scp = (sc_p)device_get_softc(dev);
 434         devclass_t devclass;
 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, intr,
 447                                       arg, cookiep, serializer);
 448 }
 449
 450 static device_t
 451 find_masterdev(sc_p scp)
 452 {
 453         int i, units;
 454         devclass_t devclass;
 455         device_t dev;
 456
 457         devclass = device_get_devclass(scp->dev);
 458         units = devclass_get_maxunit(devclass);
 459         dev = NULL;
 460         for (i = 0 ; i < units ; i++) {
 461                 dev = devclass_get_device(devclass, i);
 462                 if (isa_get_vendorid(dev) == isa_get_vendorid(scp->dev)
 463                     && isa_get_logicalid(dev) == LOGICALID_PCM
 464                     && isa_get_serial(dev) == isa_get_serial(scp->dev))
 465                         break;
 466         }
 467         if (i == units)
 468                 return (NULL);
 469
 470         return (dev);
 471 }
 472
 473 static int io_range[3]  = {0x10, 0x8  , 0x4  };
 474 static int io_offset[3] = {0x0 , 0x100, 0x10c};
 475 static int
 476 alloc_resource(sc_p scp)
 477 {
 478         int i, base, lid, flags;
 479         device_t dev;
 480
 481         flags = 0;
 482         if (isa_get_vendorid(scp->dev))
 483                 lid = isa_get_logicalid(scp->dev);
 484         else {
 485                 lid = LOGICALID_NOPNP;
 486                 flags = device_get_flags(scp->dev);
 487         }
 488         switch(lid) {
 489         case LOGICALID_PCM:
 490         case LOGICALID_NOPNP:           /* XXX Non-PnP */
 491                 if (lid == LOGICALID_NOPNP)
 492                         base = isa_get_port(scp->dev);
 493                 else
 494                         base = 0;
 495                 for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
 496                         if (scp->io[i] == NULL) {
 497                                 scp->io_rid[i] = i;
 498                                 if (base == 0)
 499                                         scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
 500                                                                         0, ~0, io_range[i], RF_ACTIVE);
 501                                 else
 502                                         scp->io[i] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[i],
 503                                                                         base + io_offset[i],
 504                                                                         base + io_offset[i] + io_range[i] - 1
 505                                                                         , io_range[i], RF_ACTIVE);
 506                                 if (scp->io[i] == NULL)
 507                                         return (1);
 508                                 scp->io_alloced[i] = 0;
 509                         }
 510                 }
 511                 if (scp->irq == NULL) {
 512                         scp->irq_rid = 0;
 513                         scp->irq = bus_alloc_resource(scp->dev, SYS_RES_IRQ, &scp->irq_rid,
 514                                                       0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
 515                         if (scp->irq == NULL)
 516                                 return (1);
 517                         scp->irq_alloced = 0;
 518                 }
 519                 for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
 520                         if (scp->drq[i] == NULL) {
 521                                 scp->drq_rid[i] = i;
 522                                 if (base == 0 || i == 0)
 523                                         scp->drq[i] = bus_alloc_resource(scp->dev, SYS_RES_DRQ, &scp->drq_rid[i],
 524                                                                          0, ~0, 1, RF_ACTIVE);
 525                                 else if ((flags & DV_F_DUAL_DMA) != 0)
 526                                         /* XXX The secondary drq is specified in the flag. */
 527                                         scp->drq[i] = bus_alloc_resource(scp->dev, SYS_RES_DRQ, &scp->drq_rid[i],
 528                                                                          flags & DV_F_DRQ_MASK,
 529                                                                          flags & DV_F_DRQ_MASK, 1, RF_ACTIVE);
 530                                 if (scp->drq[i] == NULL)
 531                                         return (1);
 532                                 scp->drq_alloced[i] = 0;
 533                         }
 534                 }
 535                 break;
 536         case LOGICALID_OPL:
 537                 if (scp->io[0] == NULL) {
 538                         scp->io_rid[0] = 0;
 539                         scp->io[0] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[0],
 540                                                         0, ~0, io_range[0], RF_ACTIVE);
 541                         if (scp->io[0] == NULL)
 542                                 return (1);
 543                         scp->io_alloced[0] = 0;
 544                 }
 545                 break;
 546         case LOGICALID_MIDI:
 547                 if (scp->io[0] == NULL) {
 548                         scp->io_rid[0] = 0;
 549                         scp->io[0] = bus_alloc_resource(scp->dev, SYS_RES_IOPORT, &scp->io_rid[0],
 550                                                         0, ~0, io_range[0], RF_ACTIVE);
 551                         if (scp->io[0] == NULL)
 552                                 return (1);
 553                         scp->io_alloced[0] = 0;
 554                 }
 555                 if (scp->irq == NULL) {
 556                         /* The irq is shared with pcm audio. */
 557                         dev = find_masterdev(scp);
 558                         if (dev == NULL)
 559                                 return (1);
 560                         scp->irq_rid = 0;
 561                         scp->irq = BUS_ALLOC_RESOURCE(dev, NULL, SYS_RES_IRQ, &scp->irq_rid,
 562                                                       0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
 563                         if (scp->irq == NULL)
 564                                 return (1);
 565                         scp->irq_alloced = 0;
 566                 }
 567                 break;
 568         }
 569         return (0);
 570 }
 571
 572 static int
 573 release_resource(sc_p scp)
 574 {
 575         int i, lid, flags;
 576         device_t dev;
 577
 578         flags = 0;
 579         if (isa_get_vendorid(scp->dev))
 580                 lid = isa_get_logicalid(scp->dev);
 581         else {
 582                 lid = LOGICALID_NOPNP;
 583                 flags = device_get_flags(scp->dev);
 584         }
 585         switch(lid) {
 586         case LOGICALID_PCM:
 587         case LOGICALID_NOPNP:           /* XXX Non-PnP */
 588                 for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
 589                         if (scp->io[i] != NULL) {
 590                                 bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
 591                                 scp->io[i] = NULL;
 592                         }
 593                 }
 594                 if (scp->irq != NULL) {
 595                         bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid, scp->irq);
 596                         scp->irq = NULL;
 597                 }
 598                 for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
 599                         if (scp->drq[i] != NULL) {
 600                                 bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
 601                                 scp->drq[i] = NULL;
 602                         }
 603                 }
 604                 break;
 605         case LOGICALID_OPL:
 606                 if (scp->io[0] != NULL) {
 607                         bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
 608                         scp->io[0] = NULL;
 609                 }
 610                 break;
 611         case LOGICALID_MIDI:
 612                 if (scp->io[0] != NULL) {
 613                         bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[0], scp->io[0]);
 614                         scp->io[0] = NULL;
 615                 }
 616                 if (scp->irq != NULL) {
 617                         /* The irq is shared with pcm audio. */
 618                         dev = find_masterdev(scp);
 619                         if (dev == NULL)
 620                                 return (1);
 621                         BUS_RELEASE_RESOURCE(dev, NULL, SYS_RES_IOPORT, scp->irq_rid, scp->irq);
 622                         scp->irq = NULL;
 623                 }
 624                 break;
 625         }
 626         return (0);
 627 }
 628
 629 static device_method_t gusc_methods[] = {
 630         /* Device interface */
 631         DEVMETHOD(device_probe,         gusc_probe),
 632         DEVMETHOD(device_attach,        gusc_attach),
 633         DEVMETHOD(device_detach,        bus_generic_detach),
 634         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 635         DEVMETHOD(device_suspend,       bus_generic_suspend),
 636         DEVMETHOD(device_resume,        bus_generic_resume),
 637
 638         /* Bus interface */
 639         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 640         DEVMETHOD(bus_alloc_resource,   gusc_alloc_resource),
 641         DEVMETHOD(bus_release_resource, gusc_release_resource),
 642         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 643         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 644         DEVMETHOD(bus_setup_intr,       gusc_setup_intr),
 645         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 646
 647         { 0, 0 }
 648 };
 649
 650 static driver_t gusc_driver = {
 651         "gusc",
 652         gusc_methods,
 653         sizeof(struct gusc_softc),
 654 };
 655
 656 /*
 657  * gusc can be attached to an isa bus.
 658  */
 659 DRIVER_MODULE(snd_gusc, isa, gusc_driver, gusc_devclass, 0, 0);
 660 MODULE_DEPEND(snd_gusc, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 661 MODULE_VERSION(snd_gusc, 1);
 662
 663