sound/isa/sb/sb_common.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *                   Uros Bizjak <uros@kss-loka.si>
   5  *
   6  *  Lowlevel routines for control of Sound Blaster cards
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/init.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/slab.h>
  13 #include <linux/ioport.h>
  14 #include <linux/module.h>
  15 #include <linux/io.h>
  16 #include <sound/core.h>
  17 #include <sound/sb.h>
  18 #include <sound/initval.h>
  19
  20 #include <asm/dma.h>
  21
  22 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  23 MODULE_DESCRIPTION("ALSA lowlevel driver for Sound Blaster cards");
  24 MODULE_LICENSE("GPL");
  25
  26 #define BUSY_LOOPS 100000
  27
  28 #undef IO_DEBUG
  29
  30 int snd_sbdsp_command(struct snd_sb *chip, unsigned char val)
  31 {
  32         int i;
  33 #ifdef IO_DEBUG
  34         snd_printk(KERN_DEBUG "command 0x%x\n", val);
  35 #endif
  36         for (i = BUSY_LOOPS; i; i--)
  37                 if ((inb(SBP(chip, STATUS)) & 0x80) == 0) {
  38                         outb(val, SBP(chip, COMMAND));
  39                         return 1;
  40                 }
  41         snd_printd("%s [0x%lx]: timeout (0x%x)\n", __func__, chip->port, val);
  42         return 0;
  43 }
  44
  45 int snd_sbdsp_get_byte(struct snd_sb *chip)
  46 {
  47         int val;
  48         int i;
  49         for (i = BUSY_LOOPS; i; i--) {
  50                 if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
  51                         val = inb(SBP(chip, READ));
  52 #ifdef IO_DEBUG
  53                         snd_printk(KERN_DEBUG "get_byte 0x%x\n", val);
  54 #endif
  55                         return val;
  56                 }
  57         }
  58         snd_printd("%s [0x%lx]: timeout\n", __func__, chip->port);
  59         return -ENODEV;
  60 }
  61
  62 int snd_sbdsp_reset(struct snd_sb *chip)
  63 {
  64         int i;
  65
  66         outb(1, SBP(chip, RESET));
  67         udelay(10);
  68         outb(0, SBP(chip, RESET));
  69         udelay(30);
  70         for (i = BUSY_LOOPS; i; i--)
  71                 if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
  72                         if (inb(SBP(chip, READ)) == 0xaa)
  73                                 return 0;
  74                         else
  75                                 break;
  76                 }
  77         snd_printdd("%s [0x%lx] failed...\n", __func__, chip->port);
  78         return -ENODEV;
  79 }
  80
  81 static int snd_sbdsp_version(struct snd_sb * chip)
  82 {
  83         unsigned int result;
  84
  85         snd_sbdsp_command(chip, SB_DSP_GET_VERSION);
  86         result = (short) snd_sbdsp_get_byte(chip) << 8;
  87         result |= (short) snd_sbdsp_get_byte(chip);
  88         return result;
  89 }
  90
  91 static int snd_sbdsp_probe(struct snd_sb * chip)
  92 {
  93         int version;
  94         int major, minor;
  95         char *str;
  96         unsigned long flags;
  97
  98         /*
  99          *  initialization sequence
 100          */
 101
 102         spin_lock_irqsave(&chip->reg_lock, flags);
 103         if (snd_sbdsp_reset(chip) < 0) {
 104                 spin_unlock_irqrestore(&chip->reg_lock, flags);
 105                 return -ENODEV;
 106         }
 107         version = snd_sbdsp_version(chip);
 108         if (version < 0) {
 109                 spin_unlock_irqrestore(&chip->reg_lock, flags);
 110                 return -ENODEV;
 111         }
 112         spin_unlock_irqrestore(&chip->reg_lock, flags);
 113         major = version >> 8;
 114         minor = version & 0xff;
 115         snd_printdd("SB [0x%lx]: DSP chip found, version = %i.%i\n",
 116                     chip->port, major, minor);
 117
 118         switch (chip->hardware) {
 119         case SB_HW_AUTO:
 120                 switch (major) {
 121                 case 1:
 122                         chip->hardware = SB_HW_10;
 123                         str = "1.0";
 124                         break;
 125                 case 2:
 126                         if (minor) {
 127                                 chip->hardware = SB_HW_201;
 128                                 str = "2.01+";
 129                         } else {
 130                                 chip->hardware = SB_HW_20;
 131                                 str = "2.0";
 132                         }
 133                         break;
 134                 case 3:
 135                         chip->hardware = SB_HW_PRO;
 136                         str = "Pro";
 137                         break;
 138                 case 4:
 139                         chip->hardware = SB_HW_16;
 140                         str = "16";
 141                         break;
 142                 default:
 143                         snd_printk(KERN_INFO "SB [0x%lx]: unknown DSP chip version %i.%i\n",
 144                                    chip->port, major, minor);
 145                         return -ENODEV;
 146                 }
 147                 break;
 148         case SB_HW_ALS100:
 149                 str = "16 (ALS-100)";
 150                 break;
 151         case SB_HW_ALS4000:
 152                 str = "16 (ALS-4000)";
 153                 break;
 154         case SB_HW_DT019X:
 155                 str = "(DT019X/ALS007)";
 156                 break;
 157         case SB_HW_CS5530:
 158                 str = "16 (CS5530)";
 159                 break;
 160         case SB_HW_JAZZ16:
 161                 str = "Pro (Jazz16)";
 162                 break;
 163         default:
 164                 return -ENODEV;
 165         }
 166         sprintf(chip->name, "Sound Blaster %s", str);
 167         chip->version = (major << 8) | minor;
 168         return 0;
 169 }
 170
 171 static int snd_sbdsp_free(struct snd_sb *chip)
 172 {
 173         release_and_free_resource(chip->res_port);
 174         if (chip->irq >= 0)
 175                 free_irq(chip->irq, (void *) chip);
 176 #ifdef CONFIG_ISA
 177         if (chip->dma8 >= 0) {
 178                 disable_dma(chip->dma8);
 179                 free_dma(chip->dma8);
 180         }
 181         if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
 182                 disable_dma(chip->dma16);
 183                 free_dma(chip->dma16);
 184         }
 185 #endif
 186         kfree(chip);
 187         return 0;
 188 }
 189
 190 static int snd_sbdsp_dev_free(struct snd_device *device)
 191 {
 192         struct snd_sb *chip = device->device_data;
 193         return snd_sbdsp_free(chip);
 194 }
 195
 196 int snd_sbdsp_create(struct snd_card *card,
 197                      unsigned long port,
 198                      int irq,
 199                      irq_handler_t irq_handler,
 200                      int dma8,
 201                      int dma16,
 202                      unsigned short hardware,
 203                      struct snd_sb **r_chip)
 204 {
 205         struct snd_sb *chip;
 206         int err;
 207         static const struct snd_device_ops ops = {
 208                 .dev_free =     snd_sbdsp_dev_free,
 209         };
 210
 211         if (snd_BUG_ON(!r_chip))
 212                 return -EINVAL;
 213         *r_chip = NULL;
 214         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 215         if (chip == NULL)
 216                 return -ENOMEM;
 217         spin_lock_init(&chip->reg_lock);
 218         spin_lock_init(&chip->open_lock);
 219         spin_lock_init(&chip->midi_input_lock);
 220         spin_lock_init(&chip->mixer_lock);
 221         chip->irq = -1;
 222         chip->dma8 = -1;
 223         chip->dma16 = -1;
 224         chip->port = port;
 225
 226         if (request_irq(irq, irq_handler,
 227                         (hardware == SB_HW_ALS4000 ||
 228                          hardware == SB_HW_CS5530) ?
 229                         IRQF_SHARED : 0,
 230                         "SoundBlaster", (void *) chip)) {
 231                 snd_printk(KERN_ERR "sb: can't grab irq %d\n", irq);
 232                 snd_sbdsp_free(chip);
 233                 return -EBUSY;
 234         }
 235         chip->irq = irq;
 236         card->sync_irq = chip->irq;
 237
 238         if (hardware == SB_HW_ALS4000)
 239                 goto __skip_allocation;
 240
 241         if ((chip->res_port = request_region(port, 16, "SoundBlaster")) == NULL) {
 242                 snd_printk(KERN_ERR "sb: can't grab port 0x%lx\n", port);
 243                 snd_sbdsp_free(chip);
 244                 return -EBUSY;
 245         }
 246
 247 #ifdef CONFIG_ISA
 248         if (dma8 >= 0 && request_dma(dma8, "SoundBlaster - 8bit")) {
 249                 snd_printk(KERN_ERR "sb: can't grab DMA8 %d\n", dma8);
 250                 snd_sbdsp_free(chip);
 251                 return -EBUSY;
 252         }
 253         chip->dma8 = dma8;
 254         if (dma16 >= 0) {
 255                 if (hardware != SB_HW_ALS100 && (dma16 < 5 || dma16 > 7)) {
 256                         /* no duplex */
 257                         dma16 = -1;
 258                 } else if (request_dma(dma16, "SoundBlaster - 16bit")) {
 259                         snd_printk(KERN_ERR "sb: can't grab DMA16 %d\n", dma16);
 260                         snd_sbdsp_free(chip);
 261                         return -EBUSY;
 262                 }
 263         }
 264         chip->dma16 = dma16;
 265 #endif
 266
 267       __skip_allocation:
 268         chip->card = card;
 269         chip->hardware = hardware;
 270         if ((err = snd_sbdsp_probe(chip)) < 0) {
 271                 snd_sbdsp_free(chip);
 272                 return err;
 273         }
 274         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
 275                 snd_sbdsp_free(chip);
 276                 return err;
 277         }
 278         *r_chip = chip;
 279         return 0;
 280 }
 281
 282 EXPORT_SYMBOL(snd_sbdsp_command);
 283 EXPORT_SYMBOL(snd_sbdsp_get_byte);
 284 EXPORT_SYMBOL(snd_sbdsp_reset);
 285 EXPORT_SYMBOL(snd_sbdsp_create);
 286 /* sb_mixer.c */
 287 EXPORT_SYMBOL(snd_sbmixer_write);
 288 EXPORT_SYMBOL(snd_sbmixer_read);
 289 EXPORT_SYMBOL(snd_sbmixer_new);
 290 EXPORT_SYMBOL(snd_sbmixer_add_ctl);
 291 #ifdef CONFIG_PM
 292 EXPORT_SYMBOL(snd_sbmixer_suspend);
 293 EXPORT_SYMBOL(snd_sbmixer_resume);
 294 #endif