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

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