sound/isa/opl3sa2.c

   1 /*
   2  *  Driver for Yamaha OPL3-SA[2,3] soundcards
   3  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   4  *
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  *
  20  */
  21
  22 #include <sound/driver.h>
  23 #include <linux/init.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/pm.h>
  26 #include <linux/slab.h>
  27 #include <linux/pnp.h>
  28 #include <linux/moduleparam.h>
  29 #include <sound/core.h>
  30 #include <sound/cs4231.h>
  31 #include <sound/mpu401.h>
  32 #include <sound/opl3.h>
  33 #include <sound/initval.h>
  34
  35 #include <asm/io.h>
  36
  37 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  38 MODULE_DESCRIPTION("Yamaha OPL3SA2+");
  39 MODULE_LICENSE("GPL");
  40 MODULE_CLASSES("{sound}");
  41 MODULE_DEVICES("{{Yamaha,YMF719E-S},"
  42                 "{Genius,Sound Maker 3DX},"
  43                 "{Yamaha,OPL3SA3},"
  44                 "{Intel,AL440LX sound},"
  45                 "{NeoMagic,MagicWave 3DX}}");
  46
  47 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  48 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  49 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
  50 #ifdef CONFIG_PNP
  51 static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
  52 #endif
  53 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0xf86,0x370,0x100 */
  54 static long sb_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* 0x220,0x240,0x260 */
  55 static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* 0x530,0xe80,0xf40,0x604 */
  56 static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* 0x388 */
  57 static long midi_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* 0x330,0x300 */
  58 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 0,1,3,5,9,11,12,15 */
  59 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 1,3,5,6,7 */
  60 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 1,3,5,6,7 */
  61 static int opl3sa3_ymode[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 };   /* 0,1,2,3 */ /*SL Added*/
  62 static int boot_devs;
  63
  64 module_param_array(index, int, boot_devs, 0444);
  65 MODULE_PARM_DESC(index, "Index value for OPL3-SA soundcard.");
  66 MODULE_PARM_SYNTAX(index, SNDRV_INDEX_DESC);
  67 module_param_array(id, charp, boot_devs, 0444);
  68 MODULE_PARM_DESC(id, "ID string for OPL3-SA soundcard.");
  69 MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
  70 module_param_array(enable, bool, boot_devs, 0444);
  71 MODULE_PARM_DESC(enable, "Enable OPL3-SA soundcard.");
  72 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
  73 #ifdef CONFIG_PNP
  74 module_param_array(isapnp, bool, boot_devs, 0444);
  75 MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
  76 MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
  77 #endif
  78 module_param_array(port, long, boot_devs, 0444);
  79 MODULE_PARM_DESC(port, "Port # for OPL3-SA driver.");
  80 MODULE_PARM_SYNTAX(port, SNDRV_ENABLED ",allows:{{0xf86},{0x370},{0x100}},dialog:list");
  81 module_param_array(sb_port, long, boot_devs, 0444);
  82 MODULE_PARM_DESC(sb_port, "SB port # for OPL3-SA driver.");
  83 MODULE_PARM_SYNTAX(sb_port, SNDRV_ENABLED ",allows:{{0x220},{0x240},{0x260}},dialog:list");
  84 module_param_array(wss_port, long, boot_devs, 0444);
  85 MODULE_PARM_DESC(wss_port, "WSS port # for OPL3-SA driver.");
  86 MODULE_PARM_SYNTAX(wss_port, SNDRV_ENABLED ",allows:{{0x530},{0xe80},{0xf40},{0x604}},dialog:list");
  87 module_param_array(fm_port, long, boot_devs, 0444);
  88 MODULE_PARM_DESC(fm_port, "FM port # for OPL3-SA driver.");
  89 MODULE_PARM_SYNTAX(fm_port, SNDRV_ENABLED ",allows:{{0x388}},dialog:list");
  90 module_param_array(midi_port, long, boot_devs, 0444);
  91 MODULE_PARM_DESC(midi_port, "MIDI port # for OPL3-SA driver.");
  92 MODULE_PARM_SYNTAX(midi_port, SNDRV_ENABLED ",allows:{{0x330},{0x300}},dialog:list");
  93 module_param_array(irq, int, boot_devs, 0444);
  94 MODULE_PARM_DESC(irq, "IRQ # for OPL3-SA driver.");
  95 MODULE_PARM_SYNTAX(irq, SNDRV_ENABLED ",allows:{{0},{1},{3},{5},{9},{11},{12},{15}},dialog:list");
  96 module_param_array(dma1, int, boot_devs, 0444);
  97 MODULE_PARM_DESC(dma1, "DMA1 # for OPL3-SA driver.");
  98 MODULE_PARM_SYNTAX(dma1, SNDRV_ENABLED ",allows:{{1},{3},{5},{6},{7}},dialog:list");
  99 module_param_array(dma2, int, boot_devs, 0444);
 100 MODULE_PARM_DESC(dma2, "DMA2 # for OPL3-SA driver.");
 101 MODULE_PARM_SYNTAX(dma2, SNDRV_ENABLED ",allows:{{1},{3},{5},{6},{7}},dialog:list");
 102 module_param_array(opl3sa3_ymode, int, boot_devs, 0444);
 103 MODULE_PARM_DESC(opl3sa3_ymode, "Speaker size selection for 3D Enhancement mode: Desktop/Large Notebook/Small Notebook/HiFi.");
 104 MODULE_PARM_SYNTAX(opl3sa3_ymode, SNDRV_ENABLED ",allows:{{0,3}},dialog:list");  /* SL Added */
 105
 106 /* control ports */
 107 #define OPL3SA2_PM_CTRL         0x01
 108 #define OPL3SA2_SYS_CTRL                0x02
 109 #define OPL3SA2_IRQ_CONFIG      0x03
 110 #define OPL3SA2_IRQ_STATUS      0x04
 111 #define OPL3SA2_DMA_CONFIG      0x06
 112 #define OPL3SA2_MASTER_LEFT     0x07
 113 #define OPL3SA2_MASTER_RIGHT    0x08
 114 #define OPL3SA2_MIC             0x09
 115 #define OPL3SA2_MISC            0x0A
 116
 117 /* opl3sa3 only */
 118 #define OPL3SA3_DGTL_DOWN       0x12
 119 #define OPL3SA3_ANLG_DOWN       0x13
 120 #define OPL3SA3_WIDE            0x14
 121 #define OPL3SA3_BASS            0x15
 122 #define OPL3SA3_TREBLE          0x16
 123
 124 /* power management bits */
 125 #define OPL3SA2_PM_ADOWN                0x20
 126 #define OPL3SA2_PM_PSV          0x04
 127 #define OPL3SA2_PM_PDN          0x02
 128 #define OPL3SA2_PM_PDX          0x01
 129
 130 #define OPL3SA2_PM_D0   0x00
 131 #define OPL3SA2_PM_D3   (OPL3SA2_PM_ADOWN|OPL3SA2_PM_PSV|OPL3SA2_PM_PDN|OPL3SA2_PM_PDX)
 132
 133 typedef struct snd_opl3sa2 opl3sa2_t;
 134 #define chip_t opl3sa2_t
 135
 136 struct snd_opl3sa2 {
 137         snd_card_t *card;
 138         int version;            /* 2 or 3 */
 139         unsigned long port;     /* control port */
 140         struct resource *res_port; /* control port resource */
 141         int irq;
 142         int single_dma;
 143         spinlock_t reg_lock;
 144         snd_hwdep_t *synth;
 145         snd_rawmidi_t *rmidi;
 146         cs4231_t *cs4231;
 147 #ifdef CONFIG_PNP
 148         struct pnp_dev *dev;
 149 #endif
 150         unsigned char ctlregs[0x20];
 151         int ymode;              /* SL added */
 152         snd_kcontrol_t *master_switch;
 153         snd_kcontrol_t *master_volume;
 154 #ifdef CONFIG_PM
 155         void (*cs4231_suspend)(cs4231_t *);
 156         void (*cs4231_resume)(cs4231_t *);
 157 #endif
 158 };
 159
 160 static snd_card_t *snd_opl3sa2_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
 161
 162 #ifdef CONFIG_PNP
 163
 164 static struct pnp_card_device_id snd_opl3sa2_pnpids[] = {
 165         /* Yamaha YMF719E-S (Genius Sound Maker 3DX) */
 166         { .id = "YMH0020", .devs = { { "YMH0021" } } },
 167         /* Yamaha OPL3-SA3 (integrated on Intel's Pentium II AL440LX motherboard) */
 168         { .id = "YMH0030", .devs = { { "YMH0021" } } },
 169         /* Yamaha OPL3-SA2 */
 170         { .id = "YMH0800", .devs = { { "YMH0021" } } },
 171         /* Yamaha OPL3-SA2 */
 172         { .id = "YMH0801", .devs = { { "YMH0021" } } },
 173         /* NeoMagic MagicWave 3DX */
 174         { .id = "NMX2200", .devs = { { "YMH2210" } } },
 175         /* --- */
 176         { .id = "" }    /* end */
 177 };
 178
 179 MODULE_DEVICE_TABLE(pnp_card, snd_opl3sa2_pnpids);
 180
 181 #endif /* CONFIG_PNP */
 182
 183
 184 /* read control port (w/o spinlock) */
 185 static unsigned char __snd_opl3sa2_read(opl3sa2_t *chip, unsigned char reg)
 186 {
 187         unsigned char result;
 188 #if 0
 189         outb(0x1d, port);       /* password */
 190         printk("read [0x%lx] = 0x%x\n", port, inb(port));
 191 #endif
 192         outb(reg, chip->port);  /* register */
 193         result = inb(chip->port + 1);
 194 #if 0
 195         printk("read [0x%lx] = 0x%x [0x%x]\n", port, result, inb(port));
 196 #endif
 197         return result;
 198 }
 199
 200 /* read control port (with spinlock) */
 201 static unsigned char snd_opl3sa2_read(opl3sa2_t *chip, unsigned char reg)
 202 {
 203         unsigned long flags;
 204         unsigned char result;
 205
 206         spin_lock_irqsave(&chip->reg_lock, flags);
 207         result = __snd_opl3sa2_read(chip, reg);
 208         spin_unlock_irqrestore(&chip->reg_lock, flags);
 209         return result;
 210 }
 211
 212 /* write control port (w/o spinlock) */
 213 static void __snd_opl3sa2_write(opl3sa2_t *chip, unsigned char reg, unsigned char value)
 214 {
 215 #if 0
 216         outb(0x1d, port);       /* password */
 217 #endif
 218         outb(reg, chip->port);  /* register */
 219         outb(value, chip->port + 1);
 220         chip->ctlregs[reg] = value;
 221 }
 222
 223 /* write control port (with spinlock) */
 224 static void snd_opl3sa2_write(opl3sa2_t *chip, unsigned char reg, unsigned char value)
 225 {
 226         unsigned long flags;
 227         spin_lock_irqsave(&chip->reg_lock, flags);
 228         __snd_opl3sa2_write(chip, reg, value);
 229         spin_unlock_irqrestore(&chip->reg_lock, flags);
 230 }
 231
 232 static int __init snd_opl3sa2_detect(opl3sa2_t *chip)
 233 {
 234         snd_card_t *card;
 235         unsigned long port;
 236         unsigned char tmp, tmp1;
 237         char str[2];
 238
 239         card = chip->card;
 240         port = chip->port;
 241         if ((chip->res_port = request_region(port, 2, "OPL3-SA control")) == NULL) {
 242                 snd_printk(KERN_ERR "opl3sa2: can't grab port 0x%lx\n", port);
 243                 return -EBUSY;
 244         }
 245         // snd_printk("REG 0A = 0x%x\n", snd_opl3sa2_read(chip, 0x0a));
 246         chip->version = 0;
 247         tmp = snd_opl3sa2_read(chip, OPL3SA2_MISC);
 248         if (tmp == 0xff) {
 249                 snd_printd("OPL3-SA [0x%lx] detect = 0x%x\n", port, tmp);
 250                 return -ENODEV;
 251         }
 252         switch (tmp & 0x07) {
 253         case 0x01:
 254                 chip->version = 2; /* YMF711 */
 255                 break;
 256         default:
 257                 chip->version = 3;
 258                 /* 0x02 - standard */
 259                 /* 0x03 - YM715B */
 260                 /* 0x04 - YM719 - OPL-SA4? */
 261                 /* 0x05 - OPL3-SA3 - Libretto 100 */
 262                 break;
 263         }
 264         str[0] = chip->version + '0';
 265         str[1] = 0;
 266         strcat(card->shortname, str);
 267         snd_opl3sa2_write(chip, OPL3SA2_MISC, tmp ^ 7);
 268         if ((tmp1 = snd_opl3sa2_read(chip, OPL3SA2_MISC)) != tmp) {
 269                 snd_printd("OPL3-SA [0x%lx] detect (1) = 0x%x (0x%x)\n", port, tmp, tmp1);
 270                 return -ENODEV;
 271         }
 272         /* try if the MIC register is accesible */
 273         tmp = snd_opl3sa2_read(chip, OPL3SA2_MIC);
 274         snd_opl3sa2_write(chip, OPL3SA2_MIC, 0x8a);
 275         if (((tmp1 = snd_opl3sa2_read(chip, OPL3SA2_MIC)) & 0x9f) != 0x8a) {
 276                 snd_printd("OPL3-SA [0x%lx] detect (2) = 0x%x (0x%x)\n", port, tmp, tmp1);
 277                 return -ENODEV;
 278         }
 279         snd_opl3sa2_write(chip, OPL3SA2_MIC, 0x9f);
 280         /* initialization */
 281         /* Power Management - full on */
 282         snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D0);
 283         if (chip->version > 2) {
 284                 /* ymode is bits 4&5 (of 0 to 7) on all but opl3sa2 versions */
 285                 snd_opl3sa2_write(chip, OPL3SA2_SYS_CTRL, (chip->ymode << 4));
 286         } else {
 287                 /* default for opl3sa2 versions */
 288                 snd_opl3sa2_write(chip, OPL3SA2_SYS_CTRL, 0x00);
 289         }
 290         snd_opl3sa2_write(chip, OPL3SA2_IRQ_CONFIG, 0x0d);      /* Interrupt Channel Configuration - IRQ A = OPL3 + MPU + WSS */
 291         if (chip->single_dma) {
 292                 snd_opl3sa2_write(chip, OPL3SA2_DMA_CONFIG, 0x03);      /* DMA Configuration - DMA A = WSS-R + WSS-P */
 293         } else {
 294                 snd_opl3sa2_write(chip, OPL3SA2_DMA_CONFIG, 0x21);      /* DMA Configuration - DMA B = WSS-R, DMA A = WSS-P */
 295         }
 296         snd_opl3sa2_write(chip, OPL3SA2_MISC, 0x80 | (tmp & 7));        /* Miscellaneous - default */
 297         if (chip->version > 2) {
 298                 snd_opl3sa2_write(chip, OPL3SA3_DGTL_DOWN, 0x00);       /* Digital Block Partial Power Down - default */
 299                 snd_opl3sa2_write(chip, OPL3SA3_ANLG_DOWN, 0x00);       /* Analog Block Partial Power Down - default */
 300         }
 301         return 0;
 302 }
 303
 304 static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 305 {
 306         unsigned short status;
 307         opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, dev_id, return IRQ_NONE);
 308         int handled = 0;
 309
 310         if (chip == NULL || chip->card == NULL)
 311                 return IRQ_NONE;
 312
 313         status = snd_opl3sa2_read(chip, OPL3SA2_IRQ_STATUS);
 314
 315         if (status & 0x20) {
 316                 handled = 1;
 317                 snd_opl3_interrupt(chip->synth);
 318         }
 319
 320         if ((status & 0x10) && chip->rmidi != NULL) {
 321                 handled = 1;
 322                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
 323         }
 324
 325         if (status & 0x07) {    /* TI,CI,PI */
 326                 handled = 1;
 327                 snd_cs4231_interrupt(irq, chip->cs4231, regs);
 328         }
 329
 330         if (status & 0x40) { /* hardware volume change */
 331                 handled = 1;
 332                 /* reading from Master Lch register at 0x07 clears this bit */
 333                 snd_opl3sa2_read(chip, OPL3SA2_MASTER_RIGHT);
 334                 snd_opl3sa2_read(chip, OPL3SA2_MASTER_LEFT);
 335                 if (chip->master_switch && chip->master_volume) {
 336                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
 337                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
 338                 }
 339         }
 340         return IRQ_RETVAL(handled);
 341 }
 342
 343 #define OPL3SA2_SINGLE(xname, xindex, reg, shift, mask, invert) \
 344 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
 345   .info = snd_opl3sa2_info_single, \
 346   .get = snd_opl3sa2_get_single, .put = snd_opl3sa2_put_single, \
 347   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
 348
 349 static int snd_opl3sa2_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 350 {
 351         int mask = (kcontrol->private_value >> 16) & 0xff;
 352
 353         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 354         uinfo->count = 1;
 355         uinfo->value.integer.min = 0;
 356         uinfo->value.integer.max = mask;
 357         return 0;
 358 }
 359
 360 int snd_opl3sa2_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 361 {
 362         opl3sa2_t *chip = snd_kcontrol_chip(kcontrol);
 363         unsigned long flags;
 364         int reg = kcontrol->private_value & 0xff;
 365         int shift = (kcontrol->private_value >> 8) & 0xff;
 366         int mask = (kcontrol->private_value >> 16) & 0xff;
 367         int invert = (kcontrol->private_value >> 24) & 0xff;
 368
 369         spin_lock_irqsave(&chip->reg_lock, flags);
 370         ucontrol->value.integer.value[0] = (chip->ctlregs[reg] >> shift) & mask;
 371         spin_unlock_irqrestore(&chip->reg_lock, flags);
 372         if (invert)
 373                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 374         return 0;
 375 }
 376
 377 int snd_opl3sa2_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 378 {
 379         opl3sa2_t *chip = snd_kcontrol_chip(kcontrol);
 380         unsigned long flags;
 381         int reg = kcontrol->private_value & 0xff;
 382         int shift = (kcontrol->private_value >> 8) & 0xff;
 383         int mask = (kcontrol->private_value >> 16) & 0xff;
 384         int invert = (kcontrol->private_value >> 24) & 0xff;
 385         int change;
 386         unsigned short val, oval;
 387
 388         val = (ucontrol->value.integer.value[0] & mask);
 389         if (invert)
 390                 val = mask - val;
 391         val <<= shift;
 392         spin_lock_irqsave(&chip->reg_lock, flags);
 393         oval = chip->ctlregs[reg];
 394         val = (oval & ~(mask << shift)) | val;
 395         change = val != oval;
 396         __snd_opl3sa2_write(chip, reg, val);
 397         spin_unlock_irqrestore(&chip->reg_lock, flags);
 398         return change;
 399 }
 400
 401 #define OPL3SA2_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
 402 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
 403   .info = snd_opl3sa2_info_double, \
 404   .get = snd_opl3sa2_get_double, .put = snd_opl3sa2_put_double, \
 405   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
 406
 407 int snd_opl3sa2_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 408 {
 409         int mask = (kcontrol->private_value >> 24) & 0xff;
 410
 411         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 412         uinfo->count = 2;
 413         uinfo->value.integer.min = 0;
 414         uinfo->value.integer.max = mask;
 415         return 0;
 416 }
 417
 418 int snd_opl3sa2_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 419 {
 420         opl3sa2_t *chip = snd_kcontrol_chip(kcontrol);
 421         unsigned long flags;
 422         int left_reg = kcontrol->private_value & 0xff;
 423         int right_reg = (kcontrol->private_value >> 8) & 0xff;
 424         int shift_left = (kcontrol->private_value >> 16) & 0x07;
 425         int shift_right = (kcontrol->private_value >> 19) & 0x07;
 426         int mask = (kcontrol->private_value >> 24) & 0xff;
 427         int invert = (kcontrol->private_value >> 22) & 1;
 428
 429         spin_lock_irqsave(&chip->reg_lock, flags);
 430         ucontrol->value.integer.value[0] = (chip->ctlregs[left_reg] >> shift_left) & mask;
 431         ucontrol->value.integer.value[1] = (chip->ctlregs[right_reg] >> shift_right) & mask;
 432         spin_unlock_irqrestore(&chip->reg_lock, flags);
 433         if (invert) {
 434                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 435                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
 436         }
 437         return 0;
 438 }
 439
 440 int snd_opl3sa2_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 441 {
 442         opl3sa2_t *chip = snd_kcontrol_chip(kcontrol);
 443         unsigned long flags;
 444         int left_reg = kcontrol->private_value & 0xff;
 445         int right_reg = (kcontrol->private_value >> 8) & 0xff;
 446         int shift_left = (kcontrol->private_value >> 16) & 0x07;
 447         int shift_right = (kcontrol->private_value >> 19) & 0x07;
 448         int mask = (kcontrol->private_value >> 24) & 0xff;
 449         int invert = (kcontrol->private_value >> 22) & 1;
 450         int change;
 451         unsigned short val1, val2, oval1, oval2;
 452
 453         val1 = ucontrol->value.integer.value[0] & mask;
 454         val2 = ucontrol->value.integer.value[1] & mask;
 455         if (invert) {
 456                 val1 = mask - val1;
 457                 val2 = mask - val2;
 458         }
 459         val1 <<= shift_left;
 460         val2 <<= shift_right;
 461         spin_lock_irqsave(&chip->reg_lock, flags);
 462         if (left_reg != right_reg) {
 463                 oval1 = chip->ctlregs[left_reg];
 464                 oval2 = chip->ctlregs[right_reg];
 465                 val1 = (oval1 & ~(mask << shift_left)) | val1;
 466                 val2 = (oval2 & ~(mask << shift_right)) | val2;
 467                 change = val1 != oval1 || val2 != oval2;
 468                 __snd_opl3sa2_write(chip, left_reg, val1);
 469                 __snd_opl3sa2_write(chip, right_reg, val2);
 470         } else {
 471                 oval1 = chip->ctlregs[left_reg];
 472                 val1 = (oval1 & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
 473                 change = val1 != oval1;
 474                 __snd_opl3sa2_write(chip, left_reg, val1);
 475         }
 476         spin_unlock_irqrestore(&chip->reg_lock, flags);
 477         return change;
 478 }
 479
 480 #define OPL3SA2_CONTROLS (sizeof(snd_opl3sa2_controls)/sizeof(snd_kcontrol_new_t))
 481
 482 static snd_kcontrol_new_t snd_opl3sa2_controls[] = {
 483 OPL3SA2_DOUBLE("Master Playback Switch", 0, 0x07, 0x08, 7, 7, 1, 1),
 484 OPL3SA2_DOUBLE("Master Playback Volume", 0, 0x07, 0x08, 0, 0, 15, 1),
 485 OPL3SA2_SINGLE("Mic Playback Switch", 0, 0x09, 7, 1, 1),
 486 OPL3SA2_SINGLE("Mic Playback Volume", 0, 0x09, 0, 31, 1)
 487 };
 488
 489 #define OPL3SA2_TONE_CONTROLS (sizeof(snd_opl3sa2_tone_controls)/sizeof(snd_kcontrol_new_t))
 490
 491 static snd_kcontrol_new_t snd_opl3sa2_tone_controls[] = {
 492 OPL3SA2_DOUBLE("3D Control - Wide", 0, 0x14, 0x14, 4, 0, 7, 0),
 493 OPL3SA2_DOUBLE("Tone Control - Bass", 0, 0x15, 0x15, 4, 0, 7, 0),
 494 OPL3SA2_DOUBLE("Tone Control - Treble", 0, 0x16, 0x16, 4, 0, 7, 0)
 495 };
 496
 497 static void snd_opl3sa2_master_free(snd_kcontrol_t *kcontrol)
 498 {
 499         opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, _snd_kcontrol_chip(kcontrol), return);
 500         chip->master_switch = NULL;
 501         chip->master_volume = NULL;
 502 }
 503
 504 static int __init snd_opl3sa2_mixer(opl3sa2_t *chip)
 505 {
 506         snd_card_t *card = chip->card;
 507         snd_ctl_elem_id_t id1, id2;
 508         snd_kcontrol_t *kctl;
 509         unsigned int idx;
 510         int err;
 511
 512         memset(&id1, 0, sizeof(id1));
 513         memset(&id2, 0, sizeof(id2));
 514         id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 515         /* reassign AUX0 to CD */
 516         strcpy(id1.name, "Aux Playback Switch");
 517         strcpy(id2.name, "CD Playback Switch");
 518         if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
 519                 return err;
 520         strcpy(id1.name, "Aux Playback Volume");
 521         strcpy(id2.name, "CD Playback Volume");
 522         if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
 523                 return err;
 524         /* reassign AUX1 to FM */
 525         strcpy(id1.name, "Aux Playback Switch"); id1.index = 1;
 526         strcpy(id2.name, "FM Playback Switch");
 527         if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
 528                 return err;
 529         strcpy(id1.name, "Aux Playback Volume");
 530         strcpy(id2.name, "FM Playback Volume");
 531         if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
 532                 return err;
 533         /* add OPL3SA2 controls */
 534         for (idx = 0; idx < OPL3SA2_CONTROLS; idx++) {
 535                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_opl3sa2_controls[idx], chip))) < 0)
 536                         return err;
 537                 switch (idx) {
 538                 case 0: chip->master_switch = kctl; kctl->private_free = snd_opl3sa2_master_free; break;
 539                 case 1: chip->master_volume = kctl; kctl->private_free = snd_opl3sa2_master_free; break;
 540                 }
 541         }
 542         if (chip->version > 2) {
 543                 for (idx = 0; idx < OPL3SA2_TONE_CONTROLS; idx++)
 544                         if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_opl3sa2_tone_controls[idx], chip))) < 0)
 545                                 return err;
 546         }
 547         return 0;
 548 }
 549
 550 /* Power Management support functions */
 551 #ifdef CONFIG_PM
 552 static int snd_opl3sa2_suspend(snd_card_t *card, unsigned int state)
 553 {
 554         opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, card->pm_private_data, return -EINVAL);
 555
 556         snd_pcm_suspend_all(chip->cs4231->pcm); /* stop before saving regs */
 557         chip->cs4231_suspend(chip->cs4231);
 558
 559         /* power down */
 560         snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D3);
 561
 562         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 563         return 0;
 564 }
 565
 566 static int snd_opl3sa2_resume(snd_card_t *card, unsigned int state)
 567 {
 568         opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, card->pm_private_data, return -EINVAL);
 569         int i;
 570
 571         /* power up */
 572         snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D0);
 573
 574         /* restore registers */
 575         for (i = 2; i <= 0x0a; i++) {
 576                 if (i != OPL3SA2_IRQ_STATUS)
 577                         snd_opl3sa2_write(chip, i, chip->ctlregs[i]);
 578         }
 579         if (chip->version > 2) {
 580                 for (i = 0x12; i <= 0x16; i++)
 581                         snd_opl3sa2_write(chip, i, chip->ctlregs[i]);
 582         }
 583         /* restore cs4231 */
 584         chip->cs4231_resume(chip->cs4231);
 585
 586         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 587         return 0;
 588 }
 589 #endif /* CONFIG_PM */
 590
 591 #ifdef CONFIG_PNP
 592 static int __init snd_opl3sa2_pnp(int dev, opl3sa2_t *chip,
 593                                   struct pnp_card_link *card,
 594                                   const struct pnp_card_device_id *id)
 595 {
 596         struct pnp_dev *pdev;
 597         struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
 598         int err;
 599
 600         if (!cfg)
 601                 return -ENOMEM;
 602         pdev = chip->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
 603         if (chip->dev == NULL) {
 604                 kfree(cfg);
 605                 return -EBUSY;
 606         }
 607         /* PnP initialization */
 608         pnp_init_resource_table(cfg);
 609         if (sb_port[dev] != SNDRV_AUTO_PORT)
 610                 pnp_resource_change(&cfg->port_resource[0], sb_port[dev], 16);
 611         if (wss_port[dev] != SNDRV_AUTO_PORT)
 612                 pnp_resource_change(&cfg->port_resource[1], wss_port[dev], 8);
 613         if (fm_port[dev] != SNDRV_AUTO_PORT)
 614                 pnp_resource_change(&cfg->port_resource[2], fm_port[dev], 4);
 615         if (midi_port[dev] != SNDRV_AUTO_PORT)
 616                 pnp_resource_change(&cfg->port_resource[3], midi_port[dev], 2);
 617         if (port[dev] != SNDRV_AUTO_PORT)
 618                 pnp_resource_change(&cfg->port_resource[4], port[dev], 2);
 619         if (dma1[dev] != SNDRV_AUTO_DMA)
 620                 pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
 621         if (dma2[dev] != SNDRV_AUTO_DMA)
 622                 pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
 623         if (irq[dev] != SNDRV_AUTO_IRQ)
 624                 pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
 625         err = pnp_manual_config_dev(pdev, cfg, 0);
 626         if (err < 0)
 627                 snd_printk(KERN_ERR "PnP manual resources are invalid, using auto config\n");
 628         err = pnp_activate_dev(pdev);
 629         if (err < 0) {
 630                 kfree(cfg);
 631                 snd_printk(KERN_ERR "PnP configure failure (out of resources?) err = %d\n", err);
 632                 return -EBUSY;
 633         }
 634         sb_port[dev] = pnp_port_start(pdev, 0);
 635         wss_port[dev] = pnp_port_start(pdev, 1);
 636         fm_port[dev] = pnp_port_start(pdev, 2);
 637         midi_port[dev] = pnp_port_start(pdev, 3);
 638         port[dev] = pnp_port_start(pdev, 4);
 639         dma1[dev] = pnp_dma(pdev, 0);
 640         dma2[dev] = pnp_dma(pdev, 1);
 641         irq[dev] = pnp_irq(pdev, 0);
 642         snd_printdd("PnP OPL3-SA: sb port=0x%lx, wss port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
 643                 sb_port[dev], wss_port[dev], fm_port[dev], midi_port[dev]);
 644         snd_printdd("PnP OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n",
 645                 port[dev], dma1[dev], dma2[dev], irq[dev]);
 646         kfree(cfg);
 647         return 0;
 648 }
 649 #endif /* CONFIG_PNP */
 650
 651 static int snd_opl3sa2_free(opl3sa2_t *chip)
 652 {
 653         if (chip->irq >= 0)
 654                 free_irq(chip->irq, (void *)chip);
 655         if (chip->res_port) {
 656                 release_resource(chip->res_port);
 657                 kfree_nocheck(chip->res_port);
 658         }
 659         snd_magic_kfree(chip);
 660         return 0;
 661 }
 662
 663 static int snd_opl3sa2_dev_free(snd_device_t *device)
 664 {
 665         opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, device->device_data, return -ENXIO);
 666         return snd_opl3sa2_free(chip);
 667 }
 668
 669 static int __devinit snd_opl3sa2_probe(int dev,
 670                                        struct pnp_card_link *pcard,
 671                                        const struct pnp_card_device_id *pid)
 672 {
 673         int xirq, xdma1, xdma2;
 674         snd_card_t *card;
 675         struct snd_opl3sa2 *chip;
 676         cs4231_t *cs4231;
 677         opl3_t *opl3;
 678         static snd_device_ops_t ops = {
 679                 .dev_free =     snd_opl3sa2_dev_free,
 680         };
 681         int err;
 682
 683 #ifdef CONFIG_PNP
 684         if (!isapnp[dev]) {
 685 #endif
 686                 if (port[dev] == SNDRV_AUTO_PORT) {
 687                         snd_printk("specify port\n");
 688                         return -EINVAL;
 689                 }
 690                 if (wss_port[dev] == SNDRV_AUTO_PORT) {
 691                         snd_printk("specify wss_port\n");
 692                         return -EINVAL;
 693                 }
 694                 if (fm_port[dev] == SNDRV_AUTO_PORT) {
 695                         snd_printk("specify fm_port\n");
 696                         return -EINVAL;
 697                 }
 698                 if (midi_port[dev] == SNDRV_AUTO_PORT) {
 699                         snd_printk("specify midi_port\n");
 700                         return -EINVAL;
 701                 }
 702 #ifdef CONFIG_PNP
 703         }
 704 #endif
 705         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
 706         if (card == NULL)
 707                 return -ENOMEM;
 708         strcpy(card->driver, "OPL3SA2");
 709         strcpy(card->shortname, "Yamaha OPL3-SA2");
 710         chip = snd_magic_kcalloc(opl3sa2_t, 0, GFP_KERNEL);
 711         if (chip == NULL) {
 712                 err = -ENOMEM;
 713                 goto __error;
 714         }
 715         spin_lock_init(&chip->reg_lock);
 716         chip->irq = -1;
 717         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0)
 718                 goto __error;
 719 #ifdef CONFIG_PNP
 720         if (isapnp[dev]) {
 721                 if ((err = snd_opl3sa2_pnp(dev, chip, pcard, pid)) < 0)
 722                         goto __error;
 723                 snd_card_set_dev(card, &pcard->card->dev);
 724         }
 725 #endif
 726         chip->ymode = opl3sa3_ymode[dev] & 0x03 ; /* initialise this card from supplied (or default) parameter*/
 727         chip->card = card;
 728         chip->port = port[dev];
 729         xirq = irq[dev];
 730         xdma1 = dma1[dev];
 731         xdma2 = dma2[dev];
 732         if (xdma2 < 0)
 733                 chip->single_dma = 1;
 734         if ((err = snd_opl3sa2_detect(chip)) < 0)
 735                 goto __error;
 736         if (request_irq(xirq, snd_opl3sa2_interrupt, SA_INTERRUPT, "OPL3-SA2/3", (void *)chip)) {
 737                 snd_printk(KERN_ERR "opl3sa2: can't grab IRQ %d\n", xirq);
 738                 err = -ENODEV;
 739                 goto __error;
 740         }
 741         chip->irq = xirq;
 742         if ((err = snd_cs4231_create(card,
 743                                      wss_port[dev] + 4, -1,
 744                                      xirq, xdma1, xdma2,
 745                                      CS4231_HW_OPL3SA2,
 746                                      CS4231_HWSHARE_IRQ,
 747                                      &cs4231)) < 0) {
 748                 snd_printd("Oops, WSS not detected at 0x%lx\n", wss_port[dev] + 4);
 749                 goto __error;
 750         }
 751         chip->cs4231 = cs4231;
 752         if ((err = snd_cs4231_pcm(cs4231, 0, NULL)) < 0)
 753                 goto __error;
 754         if ((err = snd_cs4231_mixer(cs4231)) < 0)
 755                 goto __error;
 756         if ((err = snd_opl3sa2_mixer(chip)) < 0)
 757                 goto __error;
 758         if ((err = snd_cs4231_timer(cs4231, 0, NULL)) < 0)
 759                 goto __error;
 760         if (fm_port[dev] >= 0x340 && fm_port[dev] < 0x400) {
 761                 if ((err = snd_opl3_create(card, fm_port[dev],
 762                                            fm_port[dev] + 2,
 763                                            OPL3_HW_OPL3, 0, &opl3)) < 0)
 764                         goto __error;
 765                 if ((err = snd_opl3_timer_new(opl3, 1, 2)) < 0)
 766                         goto __error;
 767                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, &chip->synth)) < 0)
 768                         goto __error;
 769         }
 770         if (midi_port[dev] >= 0x300 && midi_port[dev] < 0x340) {
 771                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_OPL3SA2,
 772                                                midi_port[dev], 0,
 773                                                xirq, 0, &chip->rmidi)) < 0)
 774                         goto __error;
 775         }
 776 #ifdef CONFIG_PM
 777         chip->cs4231_suspend = chip->cs4231->suspend;
 778         chip->cs4231_resume = chip->cs4231->resume;
 779         /* now clear callbacks for cs4231 */
 780         chip->cs4231->suspend = NULL;
 781         chip->cs4231->resume = NULL;
 782         snd_card_set_isa_pm_callback(card, snd_opl3sa2_suspend, snd_opl3sa2_resume, chip);
 783 #endif
 784
 785         sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
 786                 card->shortname, chip->port, xirq, xdma1);
 787         if (dma2 >= 0)
 788                 sprintf(card->longname + strlen(card->longname), "&%d", xdma2);
 789
 790         if ((err = snd_card_register(card)) < 0)
 791                 goto __error;
 792
 793         if (pcard)
 794                 pnp_set_card_drvdata(pcard, card);
 795         else
 796                 snd_opl3sa2_legacy[dev] = card;
 797         return 0;
 798
 799  __error:
 800         snd_card_free(card);
 801         return err;
 802 }
 803
 804 #ifdef CONFIG_PNP
 805 static int __devinit snd_opl3sa2_pnp_detect(struct pnp_card_link *card,
 806                                             const struct pnp_card_device_id *id)
 807 {
 808         static int dev;
 809         int res;
 810
 811         for ( ; dev < SNDRV_CARDS; dev++) {
 812                 if (!enable[dev] && !isapnp[dev])
 813                         continue;
 814                 res = snd_opl3sa2_probe(dev, card, id);
 815                 if (res < 0)
 816                         return res;
 817                 dev++;
 818                 return 0;
 819         }
 820         return -ENODEV;
 821 }
 822
 823 static void __devexit snd_opl3sa2_pnp_remove(struct pnp_card_link * pcard)
 824 {
 825         snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
 826
 827         snd_card_disconnect(card);
 828         snd_card_free_in_thread(card);
 829 }
 830
 831 static struct pnp_card_driver opl3sa2_pnpc_driver = {
 832         .flags = PNP_DRIVER_RES_DISABLE,
 833         .name = "opl3sa2",
 834         .id_table = snd_opl3sa2_pnpids,
 835         .probe = snd_opl3sa2_pnp_detect,
 836         .remove = __devexit_p(snd_opl3sa2_pnp_remove),
 837 };
 838 #endif /* CONFIG_PNP */
 839
 840 static int __init alsa_card_opl3sa2_init(void)
 841 {
 842         int dev, cards = 0;
 843
 844         for (dev = 0; dev < SNDRV_CARDS; dev++) {
 845                 if (!enable[dev])
 846                         continue;
 847 #ifdef CONFIG_PNP
 848                 if (isapnp[dev])
 849                         continue;
 850 #endif
 851                 if (snd_opl3sa2_probe(dev, NULL, NULL) >= 0)
 852                         cards++;
 853         }
 854 #ifdef CONFIG_PNP
 855         cards += pnp_register_card_driver(&opl3sa2_pnpc_driver);
 856 #endif
 857         if (!cards) {
 858 #ifdef MODULE
 859                 snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
 860 #endif
 861 #ifdef CONFIG_PNP
 862                 pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
 863 #endif
 864                 return -ENODEV;
 865         }
 866         return 0;
 867 }
 868
 869 static void __exit alsa_card_opl3sa2_exit(void)
 870 {
 871         int idx;
 872
 873 #ifdef CONFIG_PNP
 874         /* PnP cards first */
 875         pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
 876 #endif
 877         for (idx = 0; idx < SNDRV_CARDS; idx++)
 878                 snd_card_free(snd_opl3sa2_legacy[idx]);
 879 }
 880
 881 module_init(alsa_card_opl3sa2_init)
 882 module_exit(alsa_card_opl3sa2_exit)