Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Routines for Gravis UltraSound soundcards
0004  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
0005  */
0006 
0007 #include <linux/init.h>
0008 #include <linux/interrupt.h>
0009 #include <linux/delay.h>
0010 #include <linux/slab.h>
0011 #include <linux/ioport.h>
0012 #include <linux/module.h>
0013 #include <sound/core.h>
0014 #include <sound/gus.h>
0015 #include <sound/control.h>
0016 
0017 #include <asm/dma.h>
0018 
0019 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
0020 MODULE_DESCRIPTION("Routines for Gravis UltraSound soundcards");
0021 MODULE_LICENSE("GPL");
0022 
0023 static int snd_gus_init_dma_irq(struct snd_gus_card * gus, int latches);
0024 
0025 int snd_gus_use_inc(struct snd_gus_card * gus)
0026 {
0027     if (!try_module_get(gus->card->module))
0028         return 0;
0029     return 1;
0030 }
0031 
0032 void snd_gus_use_dec(struct snd_gus_card * gus)
0033 {
0034     module_put(gus->card->module);
0035 }
0036 
0037 static int snd_gus_joystick_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
0038 {
0039     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0040     uinfo->count = 1;
0041     uinfo->value.integer.min = 0;
0042     uinfo->value.integer.max = 31;
0043     return 0;
0044 }
0045 
0046 static int snd_gus_joystick_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
0047 {
0048     struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
0049     
0050     ucontrol->value.integer.value[0] = gus->joystick_dac & 31;
0051     return 0;
0052 }
0053 
0054 static int snd_gus_joystick_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
0055 {
0056     struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol);
0057     unsigned long flags;
0058     int change;
0059     unsigned char nval;
0060     
0061     nval = ucontrol->value.integer.value[0] & 31;
0062     spin_lock_irqsave(&gus->reg_lock, flags);
0063     change = gus->joystick_dac != nval;
0064     gus->joystick_dac = nval;
0065     snd_gf1_write8(gus, SNDRV_GF1_GB_JOYSTICK_DAC_LEVEL, gus->joystick_dac);
0066     spin_unlock_irqrestore(&gus->reg_lock, flags);
0067     return change;
0068 }
0069 
0070 static const struct snd_kcontrol_new snd_gus_joystick_control = {
0071     .iface = SNDRV_CTL_ELEM_IFACE_CARD,
0072     .name = "Joystick Speed",
0073     .info = snd_gus_joystick_info,
0074     .get = snd_gus_joystick_get,
0075     .put = snd_gus_joystick_put
0076 };
0077 
0078 static void snd_gus_init_control(struct snd_gus_card *gus)
0079 {
0080     if (!gus->ace_flag)
0081         snd_ctl_add(gus->card, snd_ctl_new1(&snd_gus_joystick_control, gus));
0082 }
0083 
0084 /*
0085  *
0086  */
0087 
0088 static int snd_gus_free(struct snd_gus_card *gus)
0089 {
0090     if (gus->gf1.res_port2 == NULL)
0091         goto __hw_end;
0092     snd_gf1_stop(gus);
0093     snd_gus_init_dma_irq(gus, 0);
0094       __hw_end:
0095     release_and_free_resource(gus->gf1.res_port1);
0096     release_and_free_resource(gus->gf1.res_port2);
0097     if (gus->gf1.irq >= 0)
0098         free_irq(gus->gf1.irq, (void *) gus);
0099     if (gus->gf1.dma1 >= 0) {
0100         disable_dma(gus->gf1.dma1);
0101         free_dma(gus->gf1.dma1);
0102     }
0103     if (!gus->equal_dma && gus->gf1.dma2 >= 0) {
0104         disable_dma(gus->gf1.dma2);
0105         free_dma(gus->gf1.dma2);
0106     }
0107     kfree(gus);
0108     return 0;
0109 }
0110 
0111 static int snd_gus_dev_free(struct snd_device *device)
0112 {
0113     struct snd_gus_card *gus = device->device_data;
0114     return snd_gus_free(gus);
0115 }
0116 
0117 int snd_gus_create(struct snd_card *card,
0118            unsigned long port,
0119            int irq, int dma1, int dma2,
0120            int timer_dev,
0121            int voices,
0122            int pcm_channels,
0123            int effect,
0124            struct snd_gus_card **rgus)
0125 {
0126     struct snd_gus_card *gus;
0127     int err;
0128     static const struct snd_device_ops ops = {
0129         .dev_free = snd_gus_dev_free,
0130     };
0131 
0132     *rgus = NULL;
0133     gus = kzalloc(sizeof(*gus), GFP_KERNEL);
0134     if (gus == NULL)
0135         return -ENOMEM;
0136     spin_lock_init(&gus->reg_lock);
0137     spin_lock_init(&gus->voice_alloc);
0138     spin_lock_init(&gus->active_voice_lock);
0139     spin_lock_init(&gus->event_lock);
0140     spin_lock_init(&gus->dma_lock);
0141     spin_lock_init(&gus->pcm_volume_level_lock);
0142     spin_lock_init(&gus->uart_cmd_lock);
0143     mutex_init(&gus->dma_mutex);
0144     gus->gf1.irq = -1;
0145     gus->gf1.dma1 = -1;
0146     gus->gf1.dma2 = -1;
0147     gus->card = card;
0148     gus->gf1.port = port;
0149     /* fill register variables for speedup */
0150     gus->gf1.reg_page = GUSP(gus, GF1PAGE);
0151     gus->gf1.reg_regsel = GUSP(gus, GF1REGSEL);
0152     gus->gf1.reg_data8 = GUSP(gus, GF1DATAHIGH);
0153     gus->gf1.reg_data16 = GUSP(gus, GF1DATALOW);
0154     gus->gf1.reg_irqstat = GUSP(gus, IRQSTAT);
0155     gus->gf1.reg_dram = GUSP(gus, DRAM);
0156     gus->gf1.reg_timerctrl = GUSP(gus, TIMERCNTRL);
0157     gus->gf1.reg_timerdata = GUSP(gus, TIMERDATA);
0158     /* allocate resources */
0159     gus->gf1.res_port1 = request_region(port, 16, "GUS GF1 (Adlib/SB)");
0160     if (!gus->gf1.res_port1) {
0161         snd_printk(KERN_ERR "gus: can't grab SB port 0x%lx\n", port);
0162         snd_gus_free(gus);
0163         return -EBUSY;
0164     }
0165     gus->gf1.res_port2 = request_region(port + 0x100, 12, "GUS GF1 (Synth)");
0166     if (!gus->gf1.res_port2) {
0167         snd_printk(KERN_ERR "gus: can't grab synth port 0x%lx\n", port + 0x100);
0168         snd_gus_free(gus);
0169         return -EBUSY;
0170     }
0171     if (irq >= 0 && request_irq(irq, snd_gus_interrupt, 0, "GUS GF1", (void *) gus)) {
0172         snd_printk(KERN_ERR "gus: can't grab irq %d\n", irq);
0173         snd_gus_free(gus);
0174         return -EBUSY;
0175     }
0176     gus->gf1.irq = irq;
0177     card->sync_irq = irq;
0178     if (request_dma(dma1, "GUS - 1")) {
0179         snd_printk(KERN_ERR "gus: can't grab DMA1 %d\n", dma1);
0180         snd_gus_free(gus);
0181         return -EBUSY;
0182     }
0183     gus->gf1.dma1 = dma1;
0184     if (dma2 >= 0 && dma1 != dma2) {
0185         if (request_dma(dma2, "GUS - 2")) {
0186             snd_printk(KERN_ERR "gus: can't grab DMA2 %d\n", dma2);
0187             snd_gus_free(gus);
0188             return -EBUSY;
0189         }
0190         gus->gf1.dma2 = dma2;
0191     } else {
0192         gus->gf1.dma2 = gus->gf1.dma1;
0193         gus->equal_dma = 1;
0194     }
0195     gus->timer_dev = timer_dev;
0196     if (voices < 14)
0197         voices = 14;
0198     if (voices > 32)
0199         voices = 32;
0200     if (pcm_channels < 0)
0201         pcm_channels = 0;
0202     if (pcm_channels > 8)
0203         pcm_channels = 8;
0204     pcm_channels++;
0205     pcm_channels &= ~1;
0206     gus->gf1.effect = effect ? 1 : 0;
0207     gus->gf1.active_voices = voices;
0208     gus->gf1.pcm_channels = pcm_channels;
0209     gus->gf1.volume_ramp = 25;
0210     gus->gf1.smooth_pan = 1;
0211     err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, gus, &ops);
0212     if (err < 0) {
0213         snd_gus_free(gus);
0214         return err;
0215     }
0216     *rgus = gus;
0217     return 0;
0218 }
0219 
0220 /*
0221  *  Memory detection routine for plain GF1 soundcards
0222  */
0223 
0224 static int snd_gus_detect_memory(struct snd_gus_card * gus)
0225 {
0226     int l, idx, local;
0227     unsigned char d;
0228 
0229     snd_gf1_poke(gus, 0L, 0xaa);
0230     snd_gf1_poke(gus, 1L, 0x55);
0231     if (snd_gf1_peek(gus, 0L) != 0xaa || snd_gf1_peek(gus, 1L) != 0x55) {
0232         snd_printk(KERN_ERR "plain GF1 card at 0x%lx without onboard DRAM?\n", gus->gf1.port);
0233         return -ENOMEM;
0234     }
0235     for (idx = 1, d = 0xab; idx < 4; idx++, d++) {
0236         local = idx << 18;
0237         snd_gf1_poke(gus, local, d);
0238         snd_gf1_poke(gus, local + 1, d + 1);
0239         if (snd_gf1_peek(gus, local) != d ||
0240             snd_gf1_peek(gus, local + 1) != d + 1 ||
0241             snd_gf1_peek(gus, 0L) != 0xaa)
0242             break;
0243     }
0244 #if 1
0245     gus->gf1.memory = idx << 18;
0246 #else
0247     gus->gf1.memory = 256 * 1024;
0248 #endif
0249     for (l = 0, local = gus->gf1.memory; l < 4; l++, local -= 256 * 1024) {
0250         gus->gf1.mem_alloc.banks_8[l].address =
0251             gus->gf1.mem_alloc.banks_8[l].size = 0;
0252         gus->gf1.mem_alloc.banks_16[l].address = l << 18;
0253         gus->gf1.mem_alloc.banks_16[l].size = local > 0 ? 256 * 1024 : 0;
0254     }
0255     gus->gf1.mem_alloc.banks_8[0].size = gus->gf1.memory;
0256     return 0;       /* some memory were detected */
0257 }
0258 
0259 static int snd_gus_init_dma_irq(struct snd_gus_card * gus, int latches)
0260 {
0261     struct snd_card *card;
0262     unsigned long flags;
0263     int irq, dma1, dma2;
0264     static const unsigned char irqs[16] =
0265         {0, 0, 1, 3, 0, 2, 0, 4, 0, 1, 0, 5, 6, 0, 0, 7};
0266     static const unsigned char dmas[8] =
0267         {6, 1, 0, 2, 0, 3, 4, 5};
0268 
0269     if (snd_BUG_ON(!gus))
0270         return -EINVAL;
0271     card = gus->card;
0272     if (snd_BUG_ON(!card))
0273         return -EINVAL;
0274 
0275     gus->mix_cntrl_reg &= 0xf8;
0276     gus->mix_cntrl_reg |= 0x01; /* disable MIC, LINE IN, enable LINE OUT */
0277     if (gus->codec_flag || gus->ess_flag) {
0278         gus->mix_cntrl_reg &= ~1;   /* enable LINE IN */
0279         gus->mix_cntrl_reg |= 4;    /* enable MIC */
0280     }
0281     dma1 = gus->gf1.dma1;
0282     dma1 = abs(dma1);
0283     dma1 = dmas[dma1 & 7];
0284     dma2 = gus->gf1.dma2;
0285     dma2 = abs(dma2);
0286     dma2 = dmas[dma2 & 7];
0287     dma1 |= gus->equal_dma ? 0x40 : (dma2 << 3);
0288 
0289     if ((dma1 & 7) == 0 || (dma2 & 7) == 0) {
0290         snd_printk(KERN_ERR "Error! DMA isn't defined.\n");
0291         return -EINVAL;
0292     }
0293     irq = gus->gf1.irq;
0294     irq = abs(irq);
0295     irq = irqs[irq & 0x0f];
0296     if (irq == 0) {
0297         snd_printk(KERN_ERR "Error! IRQ isn't defined.\n");
0298         return -EINVAL;
0299     }
0300     irq |= 0x40;
0301 #if 0
0302     card->mixer.mix_ctrl_reg |= 0x10;
0303 #endif
0304 
0305     spin_lock_irqsave(&gus->reg_lock, flags);
0306     outb(5, GUSP(gus, REGCNTRLS));
0307     outb(gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0308     outb(0x00, GUSP(gus, IRQDMACNTRLREG));
0309     outb(0, GUSP(gus, REGCNTRLS));
0310     spin_unlock_irqrestore(&gus->reg_lock, flags);
0311 
0312     udelay(100);
0313 
0314     spin_lock_irqsave(&gus->reg_lock, flags);
0315     outb(0x00 | gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0316     outb(dma1, GUSP(gus, IRQDMACNTRLREG));
0317     if (latches) {
0318         outb(0x40 | gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0319         outb(irq, GUSP(gus, IRQDMACNTRLREG));
0320     }
0321     spin_unlock_irqrestore(&gus->reg_lock, flags);
0322 
0323     udelay(100);
0324 
0325     spin_lock_irqsave(&gus->reg_lock, flags);
0326     outb(0x00 | gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0327     outb(dma1, GUSP(gus, IRQDMACNTRLREG));
0328     if (latches) {
0329         outb(0x40 | gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0330         outb(irq, GUSP(gus, IRQDMACNTRLREG));
0331     }
0332     spin_unlock_irqrestore(&gus->reg_lock, flags);
0333 
0334     snd_gf1_delay(gus);
0335 
0336     if (latches)
0337         gus->mix_cntrl_reg |= 0x08; /* enable latches */
0338     else
0339         gus->mix_cntrl_reg &= ~0x08;    /* disable latches */
0340     spin_lock_irqsave(&gus->reg_lock, flags);
0341     outb(gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG));
0342     outb(0, GUSP(gus, GF1PAGE));
0343     spin_unlock_irqrestore(&gus->reg_lock, flags);
0344 
0345     return 0;
0346 }
0347 
0348 static int snd_gus_check_version(struct snd_gus_card * gus)
0349 {
0350     unsigned long flags;
0351     unsigned char val, rev;
0352     struct snd_card *card;
0353 
0354     card = gus->card;
0355     spin_lock_irqsave(&gus->reg_lock, flags);
0356     outb(0x20, GUSP(gus, REGCNTRLS));
0357     val = inb(GUSP(gus, REGCNTRLS));
0358     rev = inb(GUSP(gus, BOARDVERSION));
0359     spin_unlock_irqrestore(&gus->reg_lock, flags);
0360     snd_printdd("GF1 [0x%lx] init - val = 0x%x, rev = 0x%x\n", gus->gf1.port, val, rev);
0361     strcpy(card->driver, "GUS");
0362     strcpy(card->longname, "Gravis UltraSound Classic (2.4)");
0363     if ((val != 255 && (val & 0x06)) || (rev >= 5 && rev != 255)) {
0364         if (rev >= 5 && rev <= 9) {
0365             gus->ics_flag = 1;
0366             if (rev == 5)
0367                 gus->ics_flipped = 1;
0368             card->longname[27] = '3';
0369             card->longname[29] = rev == 5 ? '5' : '7';
0370         }
0371         if (rev >= 10 && rev != 255) {
0372             if (rev >= 10 && rev <= 11) {
0373                 strcpy(card->driver, "GUS MAX");
0374                 strcpy(card->longname, "Gravis UltraSound MAX");
0375                 gus->max_flag = 1;
0376             } else if (rev == 0x30) {
0377                 strcpy(card->driver, "GUS ACE");
0378                 strcpy(card->longname, "Gravis UltraSound Ace");
0379                 gus->ace_flag = 1;
0380             } else if (rev == 0x50) {
0381                 strcpy(card->driver, "GUS Extreme");
0382                 strcpy(card->longname, "Gravis UltraSound Extreme");
0383                 gus->ess_flag = 1;
0384             } else {
0385                 snd_printk(KERN_ERR "unknown GF1 revision number at 0x%lx - 0x%x (0x%x)\n", gus->gf1.port, rev, val);
0386                 snd_printk(KERN_ERR "  please - report to <perex@perex.cz>\n");
0387             }
0388         }
0389     }
0390     strscpy(card->shortname, card->longname, sizeof(card->shortname));
0391     gus->uart_enable = 1;   /* standard GUSes doesn't have midi uart trouble */
0392     snd_gus_init_control(gus);
0393     return 0;
0394 }
0395 
0396 int snd_gus_initialize(struct snd_gus_card *gus)
0397 {
0398     int err;
0399 
0400     if (!gus->interwave) {
0401         err = snd_gus_check_version(gus);
0402         if (err < 0) {
0403             snd_printk(KERN_ERR "version check failed\n");
0404             return err;
0405         }
0406         err = snd_gus_detect_memory(gus);
0407         if (err < 0)
0408             return err;
0409     }
0410     err = snd_gus_init_dma_irq(gus, 1);
0411     if (err < 0)
0412         return err;
0413     snd_gf1_start(gus);
0414     gus->initialized = 1;
0415     return 0;
0416 }
0417 
0418   /* gus_io.c */
0419 EXPORT_SYMBOL(snd_gf1_delay);
0420 EXPORT_SYMBOL(snd_gf1_write8);
0421 EXPORT_SYMBOL(snd_gf1_look8);
0422 EXPORT_SYMBOL(snd_gf1_write16);
0423 EXPORT_SYMBOL(snd_gf1_look16);
0424 EXPORT_SYMBOL(snd_gf1_i_write8);
0425 EXPORT_SYMBOL(snd_gf1_i_look8);
0426 EXPORT_SYMBOL(snd_gf1_i_look16);
0427 EXPORT_SYMBOL(snd_gf1_dram_addr);
0428 EXPORT_SYMBOL(snd_gf1_write_addr);
0429 EXPORT_SYMBOL(snd_gf1_poke);
0430 EXPORT_SYMBOL(snd_gf1_peek);
0431   /* gus_reset.c */
0432 EXPORT_SYMBOL(snd_gf1_alloc_voice);
0433 EXPORT_SYMBOL(snd_gf1_free_voice);
0434 EXPORT_SYMBOL(snd_gf1_ctrl_stop);
0435 EXPORT_SYMBOL(snd_gf1_stop_voice);
0436   /* gus_mixer.c */
0437 EXPORT_SYMBOL(snd_gf1_new_mixer);
0438   /* gus_pcm.c */
0439 EXPORT_SYMBOL(snd_gf1_pcm_new);
0440   /* gus.c */
0441 EXPORT_SYMBOL(snd_gus_use_inc);
0442 EXPORT_SYMBOL(snd_gus_use_dec);
0443 EXPORT_SYMBOL(snd_gus_create);
0444 EXPORT_SYMBOL(snd_gus_initialize);
0445   /* gus_irq.c */
0446 EXPORT_SYMBOL(snd_gus_interrupt);
0447   /* gus_uart.c */
0448 EXPORT_SYMBOL(snd_gf1_rawmidi_new);
0449   /* gus_dram.c */
0450 EXPORT_SYMBOL(snd_gus_dram_write);
0451 EXPORT_SYMBOL(snd_gus_dram_read);
0452   /* gus_volume.c */
0453 EXPORT_SYMBOL(snd_gf1_lvol_to_gvol_raw);
0454 EXPORT_SYMBOL(snd_gf1_translate_freq);
0455   /* gus_mem.c */
0456 EXPORT_SYMBOL(snd_gf1_mem_alloc);
0457 EXPORT_SYMBOL(snd_gf1_mem_xfree);
0458 EXPORT_SYMBOL(snd_gf1_mem_free);
0459 EXPORT_SYMBOL(snd_gf1_mem_lock);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!