git.oblomov.eu Git - linux-2.6/blob - sound/oss/opl3sa2.c

   1 /*
   2  * sound/oss/opl3sa2.c
   3  *
   4  * A low level driver for Yamaha OPL3-SA2 and SA3 cards.
   5  * NOTE: All traces of the name OPL3-SAx have now (December 2000) been
   6  *       removed from the driver code, as an email exchange with Yamaha
   7  *       provided the information that the YMF-719 is indeed just a
   8  *       re-badged 715.
   9  *
  10  * Copyright 1998-2001 Scott Murray <scott@spiteful.org>
  11  *
  12  * Originally based on the CS4232 driver (in cs4232.c) by Hannu Savolainen
  13  * and others.  Now incorporates code/ideas from pss.c, also by Hannu
  14  * Savolainen.  Both of those files are distributed with the following
  15  * license:
  16  *
  17  * "Copyright (C) by Hannu Savolainen 1993-1997
  18  *
  19  *  OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  20  *  Version 2 (June 1991). See the "COPYING" file distributed with this software
  21  *  for more info."
  22  *
  23  * As such, in accordance with the above license, this file, opl3sa2.c, is
  24  * distributed under the GNU GENERAL PUBLIC LICENSE (GPL) Version 2 (June 1991).
  25  * See the "COPYING" file distributed with this software for more information.
  26  *
  27  * Change History
  28  * --------------
  29  * Scott Murray            Original driver (Jun 14, 1998)
  30  * Paul J.Y. Lahaie        Changed probing / attach code order
  31  * Scott Murray            Added mixer support (Dec 03, 1998)
  32  * Scott Murray            Changed detection code to be more forgiving,
  33  *                         added force option as last resort,
  34  *                         fixed ioctl return values. (Dec 30, 1998)
  35  * Scott Murray            Simpler detection code should work all the time now
  36  *                         (with thanks to Ben Hutchings for the heuristic),
  37  *                         removed now unnecessary force option. (Jan 5, 1999)
  38  * Christoph Hellwig       Adapted to module_init/module_exit (Mar 4, 2000)
  39  * Scott Murray            Reworked SA2 versus SA3 mixer code, updated chipset
  40  *                         version detection code (again!). (Dec 5, 2000)
  41  * Scott Murray            Adjusted master volume mixer scaling. (Dec 6, 2000)
  42  * Scott Murray            Based on a patch by Joel Yliluoma (aka Bisqwit),
  43  *                         integrated wide mixer and adjusted mic, bass, treble
  44  *                         scaling. (Dec 6, 2000)
  45  * Scott Murray            Based on a patch by Peter Englmaier, integrated
  46  *                         ymode and loopback options. (Dec 6, 2000)
  47  * Scott Murray            Inspired by a patch by Peter Englmaier, and based on
  48  *                         what ALSA does, added initialization code for the
  49  *                         default DMA and IRQ settings. (Dec 6, 2000)
  50  * Scott Murray            Added some more checks to the card detection code,
  51  *                         based on what ALSA does. (Dec 12, 2000)
  52  * Scott Murray            Inspired by similar patches from John Fremlin,
  53  *                         Jim Radford, Mike Rolig, and Ingmar Steen, added 2.4
  54  *                         ISA PnP API support, mainly based on bits from
  55  *                         sb_card.c and awe_wave.c. (Dec 12, 2000)
  56  * Scott Murray            Some small cleanups to the init code output.
  57  *                         (Jan 7, 2001)
  58  * Zwane Mwaikambo         Added PM support. (Dec 4 2001)
  59  *
  60  * Adam Belay              Converted driver to new PnP Layer (Oct 12, 2002)
  61  * Zwane Mwaikambo         Code, data structure cleanups. (Feb 15 2002)
  62  * Zwane Mwaikambo         Free resources during auxiliary device probe
  63  *                         failures (Apr 29 2002)
  64  *
  65  */
  66
  67 #include <linux/pnp.h>
  68 #include <linux/init.h>
  69 #include <linux/module.h>
  70 #include <linux/delay.h>
  71 #include "sound_config.h"
  72
  73 #include "ad1848.h"
  74 #include "mpu401.h"
  75
  76 #define OPL3SA2_MODULE_NAME     "opl3sa2"
  77 #define PFX                     OPL3SA2_MODULE_NAME ": "
  78
  79 /* Useful control port indexes: */
  80 #define OPL3SA2_PM           0x01
  81 #define OPL3SA2_SYS_CTRL     0x02
  82 #define OPL3SA2_IRQ_CONFIG   0x03
  83 #define OPL3SA2_DMA_CONFIG   0x06
  84 #define OPL3SA2_MASTER_LEFT  0x07
  85 #define OPL3SA2_MASTER_RIGHT 0x08
  86 #define OPL3SA2_MIC          0x09
  87 #define OPL3SA2_MISC         0x0A
  88
  89 #define OPL3SA3_WIDE         0x14
  90 #define OPL3SA3_BASS         0x15
  91 #define OPL3SA3_TREBLE       0x16
  92
  93 /* Useful constants: */
  94 #define DEFAULT_VOLUME 50
  95 #define DEFAULT_MIC    50
  96 #define DEFAULT_TIMBRE 0
  97
  98 /* Power saving modes */
  99 #define OPL3SA2_PM_MODE0        0x00
 100 #define OPL3SA2_PM_MODE1        0x04    /* PSV */
 101 #define OPL3SA2_PM_MODE2        0x05    /* PSV | PDX */
 102 #define OPL3SA2_PM_MODE3        0x27    /* ADOWN | PSV | PDN | PDX */
 103
 104
 105 /* For checking against what the card returns: */
 106 #define VERSION_UNKNOWN 0
 107 #define VERSION_YMF711  1
 108 #define VERSION_YMF715  2
 109 #define VERSION_YMF715B 3
 110 #define VERSION_YMF715E 4
 111 /* also assuming that anything > 4 but <= 7 is a 715E */
 112
 113 /* Chipset type constants for use below */
 114 #define CHIPSET_UNKNOWN -1
 115 #define CHIPSET_OPL3SA2 0
 116 #define CHIPSET_OPL3SA3 1
 117 static const char *CHIPSET_TABLE[] = {"OPL3-SA2", "OPL3-SA3"};
 118
 119 #ifdef CONFIG_PNP
 120 #define OPL3SA2_CARDS_MAX 4
 121 #else
 122 #define OPL3SA2_CARDS_MAX 1
 123 #endif
 124
 125 /* This should be pretty obvious */
 126 static int opl3sa2_cards_num;
 127
 128 typedef struct {
 129         /* device resources */
 130         unsigned short cfg_port;
 131         struct address_info cfg;
 132         struct address_info cfg_mss;
 133         struct address_info cfg_mpu;
 134 #ifdef CONFIG_PNP
 135         /* PnP Stuff */
 136         struct pnp_dev* pdev;
 137         int activated;                  /* Whether said devices have been activated */
 138 #endif
 139         unsigned int    card;
 140         int             chipset;        /* What's my version(s)? */
 141         char            *chipset_name;
 142
 143         /* mixer data */
 144         int             mixer;
 145         unsigned int    volume_l;
 146         unsigned int    volume_r;
 147         unsigned int    mic;
 148         unsigned int    bass_l;
 149         unsigned int    bass_r;
 150         unsigned int    treble_l;
 151         unsigned int    treble_r;
 152         unsigned int    wide_l;
 153         unsigned int    wide_r;
 154 } opl3sa2_state_t;
 155 static opl3sa2_state_t opl3sa2_state[OPL3SA2_CARDS_MAX];
 156
 157
 158
 159 /* Our parameters */
 160 static int __initdata io        = -1;
 161 static int __initdata mss_io    = -1;
 162 static int __initdata mpu_io    = -1;
 163 static int __initdata irq       = -1;
 164 static int __initdata dma       = -1;
 165 static int __initdata dma2      = -1;
 166 static int __initdata ymode     = -1;
 167 static int __initdata loopback  = -1;
 168
 169 #ifdef CONFIG_PNP
 170 /* PnP specific parameters */
 171 static int __initdata isapnp = 1;
 172 static int __initdata multiple = 1;
 173
 174 /* Whether said devices have been activated */
 175 static int opl3sa2_activated[OPL3SA2_CARDS_MAX];
 176 #else
 177 static int __initdata isapnp; /* = 0 */
 178 static int __initdata multiple; /* = 0 */
 179 #endif
 180
 181 MODULE_DESCRIPTION("Module for OPL3-SA2 and SA3 sound cards (uses AD1848 MSS driver).");
 182 MODULE_AUTHOR("Scott Murray <scott@spiteful.org>");
 183 MODULE_LICENSE("GPL");
 184
 185
 186 module_param(io, int, 0);
 187 MODULE_PARM_DESC(io, "Set I/O base of OPL3-SA2 or SA3 card (usually 0x370.  Address must be even and must be from 0x100 to 0xFFE)");
 188
 189 module_param(mss_io, int, 0);
 190 MODULE_PARM_DESC(mss_io, "Set MSS (audio) I/O base (0x530, 0xE80, or other. Address must end in 0 or 4 and must be from 0x530 to 0xF48)");
 191
 192 module_param(mpu_io, int, 0);
 193 MODULE_PARM_DESC(mpu_io, "Set MIDI I/O base (0x330 or other. Address must be even and must be from 0x300 to 0x334)");
 194
 195 module_param(irq, int, 0);
 196 MODULE_PARM_DESC(irq, "Set MSS (audio) IRQ (5, 7, 9, 10, 11, 12)");
 197
 198 module_param(dma, int, 0);
 199 MODULE_PARM_DESC(dma, "Set MSS (audio) first DMA channel (0, 1, 3)");
 200
 201 module_param(dma2, int, 0);
 202 MODULE_PARM_DESC(dma2, "Set MSS (audio) second DMA channel (0, 1, 3)");
 203
 204 module_param(ymode, int, 0);
 205 MODULE_PARM_DESC(ymode, "Set Yamaha 3D enhancement mode (0 = Desktop/Normal, 1 = Notebook PC (1), 2 = Notebook PC (2), 3 = Hi-Fi)");
 206
 207 module_param(loopback, int, 0);
 208 MODULE_PARM_DESC(loopback, "Set A/D input source. Useful for echo cancellation (0 = Mic Rch (default), 1 = Mono output loopback)");
 209
 210 #ifdef CONFIG_PNP
 211 module_param(isapnp, bool, 0);
 212 MODULE_PARM_DESC(isapnp, "When set to 0, ISA PnP support will be disabled");
 213
 214 module_param(multiple, bool, 0);
 215 MODULE_PARM_DESC(multiple, "When set to 0, will not search for multiple cards");
 216 #endif
 217
 218
 219 /*
 220  * Standard read and write functions
 221 */
 222
 223 static inline void opl3sa2_write(unsigned short port,
 224                                  unsigned char  index,
 225                                  unsigned char  data)
 226 {
 227         outb_p(index, port);
 228         outb(data, port + 1);
 229 }
 230
 231
 232 static inline void opl3sa2_read(unsigned short port,
 233                                 unsigned char  index,
 234                                 unsigned char* data)
 235 {
 236         outb_p(index, port);
 237         *data = inb(port + 1);
 238 }
 239
 240
 241 /*
 242  * All of the mixer functions...
 243  */
 244
 245 static void opl3sa2_set_volume(opl3sa2_state_t* devc, int left, int right)
 246 {
 247         static unsigned char scale[101] = {
 248                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e,
 249                 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c,
 250                 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b,
 251                 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09,
 252                 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08,
 253                 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
 254                 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
 255                 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
 256                 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01,
 257                 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 258                 0x00
 259         };
 260         unsigned char vol;
 261
 262         vol = scale[left];
 263
 264         /* If level is zero, turn on mute */
 265         if(!left)
 266                 vol |= 0x80;
 267
 268         opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_LEFT, vol);
 269
 270         vol = scale[right];
 271
 272         /* If level is zero, turn on mute */
 273         if(!right)
 274                 vol |= 0x80;
 275
 276         opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_RIGHT, vol);
 277 }
 278
 279
 280 static void opl3sa2_set_mic(opl3sa2_state_t* devc, int level)
 281 {
 282         unsigned char vol = 0x1F;
 283
 284         if((level >= 0) && (level <= 100))
 285                 vol = 0x1F - (unsigned char) (32 * level / 101);
 286
 287         /* If level is zero, turn on mute */
 288         if(!level)
 289                 vol |= 0x80;
 290
 291         opl3sa2_write(devc->cfg_port, OPL3SA2_MIC, vol);
 292 }
 293
 294
 295 static void opl3sa3_set_bass(opl3sa2_state_t* devc, int left, int right)
 296 {
 297         unsigned char bass;
 298
 299         bass = left ? ((unsigned char) (8 * left / 101)) : 0;
 300         bass |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
 301
 302         opl3sa2_write(devc->cfg_port, OPL3SA3_BASS, bass);
 303 }
 304
 305
 306 static void opl3sa3_set_treble(opl3sa2_state_t* devc, int left, int right)
 307 {
 308         unsigned char treble;
 309
 310         treble = left ? ((unsigned char) (8 * left / 101)) : 0;
 311         treble |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
 312
 313         opl3sa2_write(devc->cfg_port, OPL3SA3_TREBLE, treble);
 314 }
 315
 316
 317
 318
 319 static void opl3sa2_mixer_reset(opl3sa2_state_t* devc)
 320 {
 321         if (devc) {
 322                 opl3sa2_set_volume(devc, DEFAULT_VOLUME, DEFAULT_VOLUME);
 323                 devc->volume_l = devc->volume_r = DEFAULT_VOLUME;
 324
 325                 opl3sa2_set_mic(devc, DEFAULT_MIC);
 326                 devc->mic = DEFAULT_MIC;
 327
 328                 if (devc->chipset == CHIPSET_OPL3SA3) {
 329                         opl3sa3_set_bass(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
 330                         devc->bass_l = devc->bass_r = DEFAULT_TIMBRE;
 331                         opl3sa3_set_treble(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
 332                         devc->treble_l = devc->treble_r = DEFAULT_TIMBRE;
 333                 }
 334         }
 335 }
 336
 337 static inline void arg_to_vol_mono(unsigned int vol, int* value)
 338 {
 339         int left;
 340
 341         left = vol & 0x00ff;
 342         if (left > 100)
 343                 left = 100;
 344         *value = left;
 345 }
 346
 347
 348 static inline void arg_to_vol_stereo(unsigned int vol, int* aleft, int* aright)
 349 {
 350         arg_to_vol_mono(vol, aleft);
 351         arg_to_vol_mono(vol >> 8, aright);
 352 }
 353
 354
 355 static inline int ret_vol_mono(int vol)
 356 {
 357         return ((vol << 8) | vol);
 358 }
 359
 360
 361 static inline int ret_vol_stereo(int left, int right)
 362 {
 363         return ((right << 8) | left);
 364 }
 365
 366
 367 static int opl3sa2_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
 368 {
 369         int retval, value, cmdf = cmd & 0xff;
 370         int __user *p = (int __user *)arg;
 371
 372         opl3sa2_state_t* devc = &opl3sa2_state[dev];
 373
 374         switch (cmdf) {
 375                 case SOUND_MIXER_VOLUME:
 376                 case SOUND_MIXER_MIC:
 377                 case SOUND_MIXER_DEVMASK:
 378                 case SOUND_MIXER_STEREODEVS:
 379                 case SOUND_MIXER_RECMASK:
 380                 case SOUND_MIXER_RECSRC:
 381                 case SOUND_MIXER_CAPS:
 382                         break;
 383
 384                 default:
 385                         return -EINVAL;
 386         }
 387
 388         if (((cmd >> 8) & 0xff) != 'M')
 389                 return -EINVAL;
 390
 391         retval = 0;
 392         if (_SIOC_DIR (cmd) & _SIOC_WRITE) {
 393                 switch (cmdf) {
 394                         case SOUND_MIXER_VOLUME:
 395                                 retval = get_user(value, (unsigned __user *) arg);
 396                                 if (retval)
 397                                         break;
 398                                 arg_to_vol_stereo(value, &devc->volume_l, &devc->volume_r);
 399                                 opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r);
 400                                 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
 401                                 retval = put_user(value, p);
 402                                 break;
 403
 404                         case SOUND_MIXER_MIC:
 405                                 retval = get_user(value, (unsigned __user *) arg);
 406                                 if (retval)
 407                                         break;
 408                                 arg_to_vol_mono(value, &devc->mic);
 409                                 opl3sa2_set_mic(devc, devc->mic);
 410                                 value = ret_vol_mono(devc->mic);
 411                                 retval = put_user(value, p);
 412                                 break;
 413
 414                         default:
 415                                 retval = -EINVAL;
 416                 }
 417         }
 418         else {
 419                 /*
 420                  * Return parameters
 421                  */
 422                 switch (cmdf) {
 423                         case SOUND_MIXER_DEVMASK:
 424                                 retval = put_user(SOUND_MASK_VOLUME | SOUND_MASK_MIC, p);
 425                                 break;
 426
 427                         case SOUND_MIXER_STEREODEVS:
 428                                 retval = put_user(SOUND_MASK_VOLUME, p);
 429                                 break;
 430
 431                         case SOUND_MIXER_RECMASK:
 432                                 /* No recording devices */
 433                                 retval = put_user(0, p);
 434                                 break;
 435
 436                         case SOUND_MIXER_CAPS:
 437                                 retval = put_user(SOUND_CAP_EXCL_INPUT, p);
 438                                 break;
 439
 440                         case SOUND_MIXER_RECSRC:
 441                                 /* No recording source */
 442                                 retval = put_user(0, p);
 443                                 break;
 444
 445                         case SOUND_MIXER_VOLUME:
 446                                 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
 447                                 retval = put_user(value, p);
 448                                 break;
 449
 450                         case SOUND_MIXER_MIC:
 451                                 value = ret_vol_mono(devc->mic);
 452                                 put_user(value, p);
 453                                 break;
 454
 455                         default:
 456                                 retval = -EINVAL;
 457                 }
 458         }
 459         return retval;
 460 }
 461 /* opl3sa2_mixer_ioctl end */
 462
 463
 464 static int opl3sa3_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
 465 {
 466         int value, retval, cmdf = cmd & 0xff;
 467
 468         opl3sa2_state_t* devc = &opl3sa2_state[dev];
 469
 470         switch (cmdf) {
 471         case SOUND_MIXER_BASS:
 472                 value = ret_vol_stereo(devc->bass_l, devc->bass_r);
 473                 retval = put_user(value, (int __user *) arg);
 474                 break;
 475
 476         case SOUND_MIXER_TREBLE:
 477                 value = ret_vol_stereo(devc->treble_l, devc->treble_r);
 478                 retval = put_user(value, (int __user *) arg);
 479                 break;
 480
 481         case SOUND_MIXER_DIGITAL1:
 482                 value = ret_vol_stereo(devc->wide_l, devc->wide_r);
 483                 retval = put_user(value, (int __user *) arg);
 484                 break;
 485
 486         default:
 487                 retval = -EINVAL;
 488         }
 489         return retval;
 490 }
 491 /* opl3sa3_mixer_ioctl end */
 492
 493
 494 static struct mixer_operations opl3sa2_mixer_operations =
 495 {
 496         .owner  = THIS_MODULE,
 497         .id     = "OPL3-SA2",
 498         .name   = "Yamaha OPL3-SA2",
 499         .ioctl  = opl3sa2_mixer_ioctl
 500 };
 501
 502 static struct mixer_operations opl3sa3_mixer_operations =
 503 {
 504         .owner  = THIS_MODULE,
 505         .id     = "OPL3-SA3",
 506         .name   = "Yamaha OPL3-SA3",
 507         .ioctl  = opl3sa3_mixer_ioctl
 508 };
 509
 510 /* End of mixer-related stuff */
 511
 512
 513 /*
 514  * Component probe, attach, unload functions
 515  */
 516
 517 static inline void __exit unload_opl3sa2_mpu(struct address_info *hw_config)
 518 {
 519         unload_mpu401(hw_config);
 520 }
 521
 522
 523 static void __init attach_opl3sa2_mss(struct address_info* hw_config, struct resource *ports)
 524 {
 525         int initial_mixers;
 526
 527         initial_mixers = num_mixers;
 528         attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */
 529         if (hw_config->slots[0] != -1) {
 530                 /* Did the MSS driver install? */
 531                 if(num_mixers == (initial_mixers + 1)) {
 532                         /* The MSS mixer is installed, reroute mixers appropriately */
 533                         AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_CD);
 534                         AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_SYNTH);
 535                         AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE);
 536                 }
 537                 else {
 538                         printk(KERN_ERR PFX "MSS mixer not installed?\n");
 539                 }
 540         }
 541 }
 542
 543
 544 static inline void __exit unload_opl3sa2_mss(struct address_info* hw_config)
 545 {
 546         unload_ms_sound(hw_config);
 547 }
 548
 549
 550 static int __init probe_opl3sa2(struct address_info* hw_config, int card)
 551 {
 552         unsigned char misc;
 553         unsigned char tmp;
 554         unsigned char version;
 555
 556         /*
 557          * Try and allocate our I/O port range.
 558          */
 559         if (!request_region(hw_config->io_base, 2, OPL3SA2_MODULE_NAME)) {
 560                 printk(KERN_ERR PFX "Control I/O port %#x not free\n",
 561                        hw_config->io_base);
 562                 goto out_nodev;
 563         }
 564
 565         /*
 566          * Check if writing to the read-only version bits of the miscellaneous
 567          * register succeeds or not (it should not).
 568          */
 569         opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
 570         opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc ^ 0x07);
 571         opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &tmp);
 572         if(tmp != misc) {
 573                 printk(KERN_ERR PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
 574                        hw_config->io_base);
 575                 goto out_region;
 576         }
 577
 578         /*
 579          * Check if the MIC register is accessible.
 580          */
 581         opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
 582         opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, 0x8a);
 583         opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
 584         if((tmp & 0x9f) != 0x8a) {
 585                 printk(KERN_ERR
 586                        PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
 587                        hw_config->io_base);
 588                 goto out_region;
 589         }
 590         opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, tmp);
 591
 592         /*
 593          * Determine chipset type (SA2 or SA3)
 594          *
 595          * This is done by looking at the chipset version in the lower 3 bits
 596          * of the miscellaneous register.
 597          */
 598         version = misc & 0x07;
 599         printk(KERN_DEBUG PFX "Chipset version = %#x\n", version);
 600         switch (version) {
 601                 case 0:
 602                         opl3sa2_state[card].chipset = CHIPSET_UNKNOWN;
 603                         printk(KERN_ERR
 604                                PFX "Unknown Yamaha audio controller version\n");
 605                         break;
 606
 607                 case VERSION_YMF711:
 608                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA2;
 609                         printk(KERN_INFO PFX "Found OPL3-SA2 (YMF711)\n");
 610                         break;
 611
 612                 case VERSION_YMF715:
 613                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
 614                         printk(KERN_INFO
 615                                PFX "Found OPL3-SA3 (YMF715 or YMF719)\n");
 616                         break;
 617
 618                 case VERSION_YMF715B:
 619                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
 620                         printk(KERN_INFO
 621                                PFX "Found OPL3-SA3 (YMF715B or YMF719B)\n");
 622                         break;
 623
 624                 case VERSION_YMF715E:
 625                 default:
 626                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
 627                         printk(KERN_INFO
 628                                PFX "Found OPL3-SA3 (YMF715E or YMF719E)\n");
 629                         break;
 630         }
 631
 632         if (opl3sa2_state[card].chipset != CHIPSET_UNKNOWN) {
 633                 /* Generate a pretty name */
 634                 opl3sa2_state[card].chipset_name = (char *)CHIPSET_TABLE[opl3sa2_state[card].chipset];
 635                 return 0;
 636         }
 637
 638 out_region:
 639         release_region(hw_config->io_base, 2);
 640 out_nodev:
 641         return -ENODEV;
 642 }
 643
 644
 645 static void __init attach_opl3sa2(struct address_info* hw_config, int card)
 646 {
 647         /* Initialize IRQ configuration to IRQ-B: -, IRQ-A: WSS+MPU+OPL3 */
 648         opl3sa2_write(hw_config->io_base, OPL3SA2_IRQ_CONFIG, 0x0d);
 649
 650         /* Initialize DMA configuration */
 651         if(hw_config->dma2 == hw_config->dma) {
 652                 /* Want DMA configuration DMA-B: -, DMA-A: WSS-P+WSS-R */
 653                 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x03);
 654         }
 655         else {
 656                 /* Want DMA configuration DMA-B: WSS-R, DMA-A: WSS-P */
 657                 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x21);
 658         }
 659 }
 660
 661
 662 static void __init attach_opl3sa2_mixer(struct address_info *hw_config, int card)
 663 {
 664         struct mixer_operations* mixer_operations;
 665         opl3sa2_state_t* devc = &opl3sa2_state[card];
 666
 667         /* Install master mixer */
 668         if (devc->chipset == CHIPSET_OPL3SA3) {
 669                 mixer_operations = &opl3sa3_mixer_operations;
 670         }
 671         else {
 672                 mixer_operations = &opl3sa2_mixer_operations;
 673         }
 674
 675         devc->cfg_port = hw_config->io_base;
 676         devc->mixer = sound_install_mixer(MIXER_DRIVER_VERSION,
 677                                           mixer_operations->name,
 678                                           mixer_operations,
 679                                           sizeof(struct mixer_operations),
 680                                           devc);
 681         if(devc->mixer < 0) {
 682                 printk(KERN_ERR PFX "Could not install %s master mixer\n",
 683                          mixer_operations->name);
 684         }
 685         else {
 686                         opl3sa2_mixer_reset(devc);
 687
 688         }
 689 }
 690
 691
 692 static void opl3sa2_clear_slots(struct address_info* hw_config)
 693 {
 694         int i;
 695
 696         for(i = 0; i < 6; i++) {
 697                 hw_config->slots[i] = -1;
 698         }
 699 }
 700
 701
 702 static void __init opl3sa2_set_ymode(struct address_info* hw_config, int ymode)
 703 {
 704         /*
 705          * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
 706          * it's supported.
 707          *
 708          * 0: Desktop (aka normal)   5-12 cm speakers
 709          * 1: Notebook PC mode 1     3 cm speakers
 710          * 2: Notebook PC mode 2     1.5 cm speakers
 711          * 3: Hi-fi                  16-38 cm speakers
 712          */
 713         if(ymode >= 0 && ymode <= 3) {
 714                 unsigned char sys_ctrl;
 715
 716                 opl3sa2_read(hw_config->io_base, OPL3SA2_SYS_CTRL, &sys_ctrl);
 717                 sys_ctrl = (sys_ctrl & 0xcf) | ((ymode & 3) << 4);
 718                 opl3sa2_write(hw_config->io_base, OPL3SA2_SYS_CTRL, sys_ctrl);
 719         }
 720         else {
 721                 printk(KERN_ERR PFX "not setting ymode, it must be one of 0,1,2,3\n");
 722         }
 723 }
 724
 725
 726 static void __init opl3sa2_set_loopback(struct address_info* hw_config, int loopback)
 727 {
 728         if(loopback >= 0 && loopback <= 1) {
 729                 unsigned char misc;
 730
 731                 opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
 732                 misc = (misc & 0xef) | ((loopback & 1) << 4);
 733                 opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc);
 734         }
 735         else {
 736                 printk(KERN_ERR PFX "not setting loopback, it must be either 0 or 1\n");
 737         }
 738 }
 739
 740
 741 static void __exit unload_opl3sa2(struct address_info* hw_config, int card)
 742 {
 743         /* Release control ports */
 744         release_region(hw_config->io_base, 2);
 745
 746         /* Unload mixer */
 747         if(opl3sa2_state[card].mixer >= 0)
 748                 sound_unload_mixerdev(opl3sa2_state[card].mixer);
 749
 750 }
 751
 752 #ifdef CONFIG_PNP
 753 static struct pnp_device_id pnp_opl3sa2_list[] = {
 754         {.id = "YMH0021", .driver_data = 0},
 755         {.id = ""}
 756 };
 757
 758 MODULE_DEVICE_TABLE(pnp, pnp_opl3sa2_list);
 759
 760 static int opl3sa2_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
 761 {
 762         int card = opl3sa2_cards_num;
 763
 764         /* we don't actually want to return an error as the user may have specified
 765          * no multiple card search
 766          */
 767
 768         if (opl3sa2_cards_num == OPL3SA2_CARDS_MAX)
 769                 return 0;
 770         opl3sa2_activated[card] = 1;
 771
 772         /* Our own config: */
 773         opl3sa2_state[card].cfg.io_base = pnp_port_start(dev, 4);
 774         opl3sa2_state[card].cfg.irq     = pnp_irq(dev, 0);
 775         opl3sa2_state[card].cfg.dma     = pnp_dma(dev, 0);
 776         opl3sa2_state[card].cfg.dma2    = pnp_dma(dev, 1);
 777
 778         /* The MSS config: */
 779         opl3sa2_state[card].cfg_mss.io_base      = pnp_port_start(dev, 1);
 780         opl3sa2_state[card].cfg_mss.irq          = pnp_irq(dev, 0);
 781         opl3sa2_state[card].cfg_mss.dma          = pnp_dma(dev, 0);
 782         opl3sa2_state[card].cfg_mss.dma2         = pnp_dma(dev, 1);
 783         opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
 784
 785         opl3sa2_state[card].cfg_mpu.io_base       = pnp_port_start(dev, 3);
 786         opl3sa2_state[card].cfg_mpu.irq           = pnp_irq(dev, 0);
 787         opl3sa2_state[card].cfg_mpu.dma           = -1;
 788         opl3sa2_state[card].cfg_mpu.dma2          = -1;
 789         opl3sa2_state[card].cfg_mpu.always_detect = 1; /* It's there, so use shared IRQs */
 790
 791         /* Call me paranoid: */
 792         opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
 793         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
 794         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
 795
 796         opl3sa2_state[card].pdev = dev;
 797         opl3sa2_cards_num++;
 798
 799         return 0;
 800 }
 801
 802 static struct pnp_driver opl3sa2_driver = {
 803         .name           = "opl3sa2",
 804         .id_table       = pnp_opl3sa2_list,
 805         .probe          = opl3sa2_pnp_probe,
 806 };
 807
 808 #endif /* CONFIG_PNP */
 809
 810 /* End of component functions */
 811
 812 /*
 813  * Install OPL3-SA2 based card(s).
 814  *
 815  * Need to have ad1848 and mpu401 loaded ready.
 816  */
 817 static int __init init_opl3sa2(void)
 818 {
 819         int card, max;
 820
 821         /* Sanitize isapnp and multiple settings */
 822         isapnp = isapnp != 0 ? 1 : 0;
 823         multiple = multiple != 0 ? 1 : 0;
 824
 825         max = (multiple && isapnp) ? OPL3SA2_CARDS_MAX : 1;
 826
 827 #ifdef CONFIG_PNP
 828         if (isapnp){
 829                 pnp_register_driver(&opl3sa2_driver);
 830                 if(!opl3sa2_cards_num){
 831                         printk(KERN_INFO PFX "No PnP cards found\n");
 832                         isapnp = 0;
 833                 }
 834                 max = opl3sa2_cards_num;
 835         }
 836 #endif
 837
 838         for (card = 0; card < max; card++) {
 839                 /* If a user wants an I/O then assume they meant it */
 840                 struct resource *ports;
 841                 int base;
 842
 843                 if (!isapnp) {
 844                         if (io == -1 || irq == -1 || dma == -1 ||
 845                             dma2 == -1 || mss_io == -1) {
 846                                 printk(KERN_ERR
 847                                        PFX "io, mss_io, irq, dma, and dma2 must be set\n");
 848                                 return -EINVAL;
 849                         }
 850                         opl3sa2_cards_num++;
 851
 852                         /*
 853                          * Our own config:
 854                          * (NOTE: IRQ and DMA aren't used, so they're set to
 855                          *  give pretty output from conf_printf. :)
 856                          */
 857                         opl3sa2_state[card].cfg.io_base = io;
 858                         opl3sa2_state[card].cfg.irq     = irq;
 859                         opl3sa2_state[card].cfg.dma     = dma;
 860                         opl3sa2_state[card].cfg.dma2    = dma2;
 861
 862                         /* The MSS config: */
 863                         opl3sa2_state[card].cfg_mss.io_base      = mss_io;
 864                         opl3sa2_state[card].cfg_mss.irq          = irq;
 865                         opl3sa2_state[card].cfg_mss.dma          = dma;
 866                         opl3sa2_state[card].cfg_mss.dma2         = dma2;
 867                         opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
 868
 869                         opl3sa2_state[card].cfg_mpu.io_base       = mpu_io;
 870                         opl3sa2_state[card].cfg_mpu.irq           = irq;
 871                         opl3sa2_state[card].cfg_mpu.dma           = -1;
 872                         opl3sa2_state[card].cfg_mpu.always_detect = 1; /* Use shared IRQs */
 873
 874                         /* Call me paranoid: */
 875                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
 876                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
 877                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
 878                 }
 879
 880                 /* FIXME: leak */
 881                 if (probe_opl3sa2(&opl3sa2_state[card].cfg, card))
 882                         return -ENODEV;
 883
 884                 base = opl3sa2_state[card].cfg_mss.io_base;
 885
 886                 if (!request_region(base, 4, "WSS config"))
 887                         goto failed;
 888
 889                 ports = request_region(base + 4, 4, "ad1848");
 890                 if (!ports)
 891                         goto failed2;
 892
 893                 if (!probe_ms_sound(&opl3sa2_state[card].cfg_mss, ports)) {
 894                         /*
 895                          * If one or more cards are already registered, don't
 896                          * return an error but print a warning.  Note, this
 897                          * should never really happen unless the hardware or
 898                          * ISA PnP screwed up.
 899                          */
 900                         release_region(base + 4, 4);
 901                 failed2:
 902                         release_region(base, 4);
 903                 failed:
 904                         release_region(opl3sa2_state[card].cfg.io_base, 2);
 905
 906                         if (opl3sa2_cards_num) {
 907                                 printk(KERN_WARNING
 908                                        PFX "There was a problem probing one "
 909                                        " of the ISA PNP cards, continuing\n");
 910                                 opl3sa2_cards_num--;
 911                                 continue;
 912                         } else
 913                                 return -ENODEV;
 914                 }
 915
 916                 attach_opl3sa2(&opl3sa2_state[card].cfg, card);
 917                 conf_printf(opl3sa2_state[card].chipset_name, &opl3sa2_state[card].cfg);
 918                 attach_opl3sa2_mixer(&opl3sa2_state[card].cfg, card);
 919                 attach_opl3sa2_mss(&opl3sa2_state[card].cfg_mss, ports);
 920
 921                 /* ewww =) */
 922                 opl3sa2_state[card].card = card;
 923
 924                 /*
 925                  * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
 926                  * it's supported.
 927                  */
 928                 if (ymode != -1) {
 929                         if (opl3sa2_state[card].chipset == CHIPSET_OPL3SA2) {
 930                                 printk(KERN_ERR
 931                                        PFX "ymode not supported on OPL3-SA2\n");
 932                         }
 933                         else {
 934                                 opl3sa2_set_ymode(&opl3sa2_state[card].cfg, ymode);
 935                         }
 936                 }
 937
 938
 939                 /* Set A/D input to Mono loopback if asked to. */
 940                 if (loopback != -1) {
 941                         opl3sa2_set_loopback(&opl3sa2_state[card].cfg, loopback);
 942                 }
 943
 944                 /* Attach MPU if we've been asked to do so, failure isn't fatal */
 945                 if (opl3sa2_state[card].cfg_mpu.io_base != -1) {
 946                         int base = opl3sa2_state[card].cfg_mpu.io_base;
 947                         struct resource *ports;
 948                         ports = request_region(base, 2, "mpu401");
 949                         if (!ports)
 950                                 goto out;
 951                         if (!probe_mpu401(&opl3sa2_state[card].cfg_mpu, ports)) {
 952                                 release_region(base, 2);
 953                                 goto out;
 954                         }
 955                         if (attach_mpu401(&opl3sa2_state[card].cfg_mpu, THIS_MODULE)) {
 956                                 printk(KERN_ERR PFX "failed to attach MPU401\n");
 957                                 opl3sa2_state[card].cfg_mpu.slots[1] = -1;
 958                         }
 959                 }
 960         }
 961
 962 out:
 963         if (isapnp) {
 964                 printk(KERN_NOTICE PFX "%d PnP card(s) found.\n", opl3sa2_cards_num);
 965         }
 966
 967         return 0;
 968 }
 969
 970
 971 /*
 972  * Uninstall OPL3-SA2 based card(s).
 973  */
 974 static void __exit cleanup_opl3sa2(void)
 975 {
 976         int card;
 977
 978         for(card = 0; card < opl3sa2_cards_num; card++) {
 979                 if (opl3sa2_state[card].cfg_mpu.slots[1] != -1) {
 980                         unload_opl3sa2_mpu(&opl3sa2_state[card].cfg_mpu);
 981                 }
 982                 unload_opl3sa2_mss(&opl3sa2_state[card].cfg_mss);
 983                 unload_opl3sa2(&opl3sa2_state[card].cfg, card);
 984 #ifdef CONFIG_PNP
 985                 pnp_unregister_driver(&opl3sa2_driver);
 986 #endif
 987         }
 988 }
 989
 990 module_init(init_opl3sa2);
 991 module_exit(cleanup_opl3sa2);
 992
 993 #ifndef MODULE
 994 static int __init setup_opl3sa2(char *str)
 995 {
 996         /* io, irq, dma, dma2,... */
 997 #ifdef CONFIG_PNP
 998         int ints[11];
 999 #else
1000         int ints[9];
1001 #endif
1002         str = get_options(str, ARRAY_SIZE(ints), ints);
1003
1004         io       = ints[1];
1005         irq      = ints[2];
1006         dma      = ints[3];
1007         dma2     = ints[4];
1008         mss_io   = ints[5];
1009         mpu_io   = ints[6];
1010         ymode    = ints[7];
1011         loopback = ints[8];
1012 #ifdef CONFIG_PNP
1013         isapnp   = ints[9];
1014         multiple = ints[10];
1015 #endif
1016         return 1;
1017 }
1018
1019 __setup("opl3sa2=", setup_opl3sa2);
1020 #endif