sound/oss/pss.c

   1 /*
   2  * sound/oss/pss.c
   3  *
   4  * The low level driver for the Personal Sound System (ECHO ESC614).
   5  *
   6  *
   7  * Copyright (C) by Hannu Savolainen 1993-1997
   8  *
   9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11  * for more info.
  12  *
  13  *
  14  * Thomas Sailer        ioctl code reworked (vmalloc/vfree removed)
  15  * Alan Cox             modularisation, clean up.
  16  *
  17  * 98-02-21: Vladimir Michl <vladimir.michl@upol.cz>
  18  *          Added mixer device for Beethoven ADSP-16 (master volume,
  19  *          bass, treble, synth), only for speakers.
  20  *          Fixed bug in pss_write (exchange parameters)
  21  *          Fixed config port of SB
  22  *          Requested two regions for PSS (PSS mixer, PSS config)
  23  *          Modified pss_download_boot
  24  *          To probe_pss_mss added test for initialize AD1848
  25  * 98-05-28: Vladimir Michl <vladimir.michl@upol.cz>
  26  *          Fixed computation of mixer volumes
  27  * 04-05-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  28  *          Added code that allows the user to enable his cdrom and/or
  29  *          joystick through the module parameters pss_cdrom_port and
  30  *          pss_enable_joystick.  pss_cdrom_port takes a port address as its
  31  *          argument.  pss_enable_joystick takes either a 0 or a non-0 as its
  32  *          argument.
  33  * 04-06-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  34  *          Separated some code into new functions for easier reuse.
  35  *          Cleaned up and streamlined new code.  Added code to allow a user
  36  *          to only use this driver for enabling non-sound components
  37  *          through the new module parameter pss_no_sound (flag).  Added
  38  *          code that would allow a user to decide whether the driver should
  39  *          reset the configured hardware settings for the PSS board through
  40  *          the module parameter pss_keep_settings (flag).   This flag will
  41  *          allow a user to free up resources in use by this card if needbe,
  42  *          furthermore it allows him to use this driver to just enable the
  43  *          emulations and then be unloaded as it is no longer needed.  Both
  44  *          new settings are only available to this driver if compiled as a
  45  *          module.  The default settings of all new parameters are set to
  46  *          load the driver as it did in previous versions.
  47  * 04-07-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  48  *          Added module parameter pss_firmware /*(DEBLOBBED)*//*.
  49  * 00-03-03: Christoph Hellwig <chhellwig@infradead.org>
  50  *          Adapted to module_init/module_exit
  51  * 11-10-2000: Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
  52  *          Added __init to probe_pss(), attach_pss() and probe_pss_mpu()
  53  * 02-Jan-2001: Chris Rankin
  54  *          Specify that this module owns the coprocessor
  55  */
  56
  57
  58 #include <linux/init.h>
  59 #include <linux/module.h>
  60 #include <linux/spinlock.h>
  61
  62 #include "sound_config.h"
  63 #include "sound_firmware.h"
  64
  65 #include "ad1848.h"
  66 #include "mpu401.h"
  67
  68 /*
  69  * PSS registers.
  70  */
  71 #define REG(x)  (devc->base+x)
  72 #define PSS_DATA        0
  73 #define PSS_STATUS      2
  74 #define PSS_CONTROL     2
  75 #define PSS_ID          4
  76 #define PSS_IRQACK      4
  77 #define PSS_PIO         0x1a
  78
  79 /*
  80  * Config registers
  81  */
  82 #define CONF_PSS        0x10
  83 #define CONF_WSS        0x12
  84 #define CONF_SB         0x14
  85 #define CONF_CDROM      0x16
  86 #define CONF_MIDI       0x18
  87
  88 /*
  89  * Status bits.
  90  */
  91 #define PSS_FLAG3     0x0800
  92 #define PSS_FLAG2     0x0400
  93 #define PSS_FLAG1     0x1000
  94 #define PSS_FLAG0     0x0800
  95 #define PSS_WRITE_EMPTY  0x8000
  96 #define PSS_READ_FULL    0x4000
  97
  98 /*
  99  * WSS registers
 100  */
 101 #define WSS_INDEX 4
 102 #define WSS_DATA 5
 103
 104 /*
 105  * WSS status bits
 106  */
 107 #define WSS_INITIALIZING 0x80
 108 #define WSS_AUTOCALIBRATION 0x20
 109
 110 #define NO_WSS_MIXER    -1
 111
 112 #include "coproc.h"
 113
 114 #include "pss_boot.h"
 115
 116 /* If compiled into kernel, it enable or disable pss mixer */
 117 #ifdef CONFIG_PSS_MIXER
 118 static bool pss_mixer = 1;
 119 #else
 120 static bool pss_mixer;
 121 #endif
 122
 123
 124 struct pss_mixerdata {
 125         unsigned int volume_l;
 126         unsigned int volume_r;
 127         unsigned int bass;
 128         unsigned int treble;
 129         unsigned int synth;
 130 };
 131
 132 struct pss_confdata {
 133         int             base;
 134         int             irq;
 135         int             dma;
 136         int            *osp;
 137         struct pss_mixerdata mixer;
 138         int             ad_mixer_dev;
 139 };
 140
 141 static struct pss_confdata pss_data;
 142 static struct pss_confdata *devc = &pss_data;
 143 static DEFINE_SPINLOCK(lock);
 144
 145 static int      pss_initialized;
 146 static int      nonstandard_microcode;
 147 static int      pss_cdrom_port = -1;    /* Parameter for the PSS cdrom port */
 148 static bool     pss_enable_joystick;    /* Parameter for enabling the joystick */
 149 static coproc_operations pss_coproc_operations;
 150
 151 static void pss_write(struct pss_confdata *devc, int data)
 152 {
 153         unsigned long i, limit;
 154
 155         limit = jiffies + HZ/10;        /* The timeout is 0.1 seconds */
 156         /*
 157          * Note! the i<5000000 is an emergency exit. The dsp_command() is sometimes
 158          * called while interrupts are disabled. This means that the timer is
 159          * disabled also. However the timeout situation is a abnormal condition.
 160          * Normally the DSP should be ready to accept commands after just couple of
 161          * loops.
 162          */
 163
 164         for (i = 0; i < 5000000 && time_before(jiffies, limit); i++)
 165         {
 166                 if (inw(REG(PSS_STATUS)) & PSS_WRITE_EMPTY)
 167                 {
 168                         outw(data, REG(PSS_DATA));
 169                         return;
 170                 }
 171         }
 172         printk(KERN_WARNING "PSS: DSP Command (%04x) Timeout.\n", data);
 173 }
 174
 175 static int __init probe_pss(struct address_info *hw_config)
 176 {
 177         unsigned short id;
 178         int irq, dma;
 179
 180         devc->base = hw_config->io_base;
 181         irq = devc->irq = hw_config->irq;
 182         dma = devc->dma = hw_config->dma;
 183         devc->osp = hw_config->osp;
 184
 185         if (devc->base != 0x220 && devc->base != 0x240)
 186                 if (devc->base != 0x230 && devc->base != 0x250)         /* Some cards use these */
 187                         return 0;
 188
 189         if (!request_region(devc->base, 0x10, "PSS mixer, SB emulation")) {
 190                 printk(KERN_ERR "PSS: I/O port conflict\n");
 191                 return 0;
 192         }
 193         id = inw(REG(PSS_ID));
 194         if ((id >> 8) != 'E') {
 195                 printk(KERN_ERR "No PSS signature detected at 0x%x (0x%x)\n",  devc->base,  id);
 196                 release_region(devc->base, 0x10);
 197                 return 0;
 198         }
 199         if (!request_region(devc->base + 0x10, 0x9, "PSS config")) {
 200                 printk(KERN_ERR "PSS: I/O port conflict\n");
 201                 release_region(devc->base, 0x10);
 202                 return 0;
 203         }
 204         return 1;
 205 }
 206
 207 static int set_irq(struct pss_confdata *devc, int dev, int irq)
 208 {
 209         static unsigned short irq_bits[16] =
 210         {
 211                 0x0000, 0x0000, 0x0000, 0x0008,
 212                 0x0000, 0x0010, 0x0000, 0x0018,
 213                 0x0000, 0x0020, 0x0028, 0x0030,
 214                 0x0038, 0x0000, 0x0000, 0x0000
 215         };
 216
 217         unsigned short  tmp, bits;
 218
 219         if (irq < 0 || irq > 15)
 220                 return 0;
 221
 222         tmp = inw(REG(dev)) & ~0x38;    /* Load confreg, mask IRQ bits out */
 223
 224         if ((bits = irq_bits[irq]) == 0 && irq != 0)
 225         {
 226                 printk(KERN_ERR "PSS: Invalid IRQ %d\n", irq);
 227                 return 0;
 228         }
 229         outw(tmp | bits, REG(dev));
 230         return 1;
 231 }
 232
 233 static void set_io_base(struct pss_confdata *devc, int dev, int base)
 234 {
 235         unsigned short  tmp = inw(REG(dev)) & 0x003f;
 236         unsigned short  bits = (base & 0x0ffc) << 4;
 237
 238         outw(bits | tmp, REG(dev));
 239 }
 240
 241 static int set_dma(struct pss_confdata *devc, int dev, int dma)
 242 {
 243         static unsigned short dma_bits[8] =
 244         {
 245                 0x0001, 0x0002, 0x0000, 0x0003,
 246                 0x0000, 0x0005, 0x0006, 0x0007
 247         };
 248
 249         unsigned short  tmp, bits;
 250
 251         if (dma < 0 || dma > 7)
 252                 return 0;
 253
 254         tmp = inw(REG(dev)) & ~0x07;    /* Load confreg, mask DMA bits out */
 255
 256         if ((bits = dma_bits[dma]) == 0 && dma != 4)
 257         {
 258                   printk(KERN_ERR "PSS: Invalid DMA %d\n", dma);
 259                   return 0;
 260         }
 261         outw(tmp | bits, REG(dev));
 262         return 1;
 263 }
 264
 265 static int pss_reset_dsp(struct pss_confdata *devc)
 266 {
 267         unsigned long   i, limit = jiffies + HZ/10;
 268
 269         outw(0x2000, REG(PSS_CONTROL));
 270         for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
 271                 inw(REG(PSS_CONTROL));
 272         outw(0x0000, REG(PSS_CONTROL));
 273         return 1;
 274 }
 275
 276 static int pss_put_dspword(struct pss_confdata *devc, unsigned short word)
 277 {
 278         int i, val;
 279
 280         for (i = 0; i < 327680; i++)
 281         {
 282                 val = inw(REG(PSS_STATUS));
 283                 if (val & PSS_WRITE_EMPTY)
 284                 {
 285                         outw(word, REG(PSS_DATA));
 286                         return 1;
 287                 }
 288         }
 289         return 0;
 290 }
 291
 292 static int pss_get_dspword(struct pss_confdata *devc, unsigned short *word)
 293 {
 294         int i, val;
 295
 296         for (i = 0; i < 327680; i++)
 297         {
 298                 val = inw(REG(PSS_STATUS));
 299                 if (val & PSS_READ_FULL)
 300                 {
 301                         *word = inw(REG(PSS_DATA));
 302                         return 1;
 303                 }
 304         }
 305         return 0;
 306 }
 307
 308 static int pss_download_boot(struct pss_confdata *devc, unsigned char *block,
 309                              int size, int flags)
 310 {
 311         int i, val, count;
 312         unsigned long limit;
 313
 314         if (flags & CPF_FIRST)
 315         {
 316 /*_____ Warn DSP software that a boot is coming */
 317                 outw(0x00fe, REG(PSS_DATA));
 318
 319                 limit = jiffies + HZ/10;
 320                 for (i = 0; i < 32768 && time_before(jiffies, limit); i++)
 321                         if (inw(REG(PSS_DATA)) == 0x5500)
 322                                 break;
 323
 324                 outw(*block++, REG(PSS_DATA));
 325                 pss_reset_dsp(devc);
 326         }
 327         count = 1;
 328         while ((flags&CPF_LAST) || count<size )
 329         {
 330                 int j;
 331
 332                 for (j = 0; j < 327670; j++)
 333                 {
 334 /*_____ Wait for BG to appear */
 335                         if (inw(REG(PSS_STATUS)) & PSS_FLAG3)
 336                                 break;
 337                 }
 338
 339                 if (j == 327670)
 340                 {
 341                         /* It's ok we timed out when the file was empty */
 342                         if (count >= size && flags & CPF_LAST)
 343                                 break;
 344                         else
 345                         {
 346                                 printk("\n");
 347                                 printk(KERN_ERR "PSS: Download timeout problems, byte %d=%d\n", count, size);
 348                                 return 0;
 349                         }
 350                 }
 351 /*_____ Send the next byte */
 352                 if (count >= size)
 353                 {
 354                         /* If not data in block send 0xffff */
 355                         outw (0xffff, REG (PSS_DATA));
 356                 }
 357                 else
 358                 {
 359                         /*_____ Send the next byte */
 360                         outw (*block++, REG (PSS_DATA));
 361                 }
 362                 count++;
 363         }
 364
 365         if (flags & CPF_LAST)
 366         {
 367 /*_____ Why */
 368                 outw(0, REG(PSS_DATA));
 369
 370                 limit = jiffies + HZ/10;
 371                 for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
 372                         val = inw(REG(PSS_STATUS));
 373
 374                 limit = jiffies + HZ/10;
 375                 for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
 376                 {
 377                         val = inw(REG(PSS_STATUS));
 378                         if (val & 0x4000)
 379                                 break;
 380                 }
 381
 382                 /* now read the version */
 383                 for (i = 0; i < 32000; i++)
 384                 {
 385                         val = inw(REG(PSS_STATUS));
 386                         if (val & PSS_READ_FULL)
 387                                 break;
 388                 }
 389                 if (i == 32000)
 390                         return 0;
 391
 392                 val = inw(REG(PSS_DATA));
 393                 /* printk( "<PSS: microcode version %d.%d loaded>",  val/16,  val % 16); */
 394         }
 395         return 1;
 396 }
 397
 398 /* Mixer */
 399 static void set_master_volume(struct pss_confdata *devc, int left, int right)
 400 {
 401         static unsigned char log_scale[101] =  {
 402                 0xdb, 0xe0, 0xe3, 0xe5, 0xe7, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xed, 0xee,
 403                 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3,
 404                 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7,
 405                 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9,
 406                 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb,
 407                 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc,
 408                 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
 409                 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
 410                 0xfe, 0xfe, 0xff, 0xff, 0xff
 411         };
 412         pss_write(devc, 0x0010);
 413         pss_write(devc, log_scale[left] | 0x0000);
 414         pss_write(devc, 0x0010);
 415         pss_write(devc, log_scale[right] | 0x0100);
 416 }
 417
 418 static void set_synth_volume(struct pss_confdata *devc, int volume)
 419 {
 420         int vol = ((0x8000*volume)/100L);
 421         pss_write(devc, 0x0080);
 422         pss_write(devc, vol);
 423         pss_write(devc, 0x0081);
 424         pss_write(devc, vol);
 425 }
 426
 427 static void set_bass(struct pss_confdata *devc, int level)
 428 {
 429         int vol = (int)(((0xfd - 0xf0) * level)/100L) + 0xf0;
 430         pss_write(devc, 0x0010);
 431         pss_write(devc, vol | 0x0200);
 432 };
 433
 434 static void set_treble(struct pss_confdata *devc, int level)
 435 {
 436         int vol = (((0xfd - 0xf0) * level)/100L) + 0xf0;
 437         pss_write(devc, 0x0010);
 438         pss_write(devc, vol | 0x0300);
 439 };
 440
 441 static void pss_mixer_reset(struct pss_confdata *devc)
 442 {
 443         set_master_volume(devc, 33, 33);
 444         set_bass(devc, 50);
 445         set_treble(devc, 50);
 446         set_synth_volume(devc, 30);
 447         pss_write (devc, 0x0010);
 448         pss_write (devc, 0x0800 | 0xce);        /* Stereo */
 449
 450         if(pss_mixer)
 451         {
 452                 devc->mixer.volume_l = devc->mixer.volume_r = 33;
 453                 devc->mixer.bass = 50;
 454                 devc->mixer.treble = 50;
 455                 devc->mixer.synth = 30;
 456         }
 457 }
 458
 459 static int set_volume_mono(unsigned __user *p, unsigned int *aleft)
 460 {
 461         unsigned int left, volume;
 462         if (get_user(volume, p))
 463                 return -EFAULT;
 464
 465         left = volume & 0xff;
 466         if (left > 100)
 467                 left = 100;
 468         *aleft = left;
 469         return 0;
 470 }
 471
 472 static int set_volume_stereo(unsigned __user *p,
 473                              unsigned int *aleft,
 474                              unsigned int *aright)
 475 {
 476         unsigned int left, right, volume;
 477         if (get_user(volume, p))
 478                 return -EFAULT;
 479
 480         left = volume & 0xff;
 481         if (left > 100)
 482                 left = 100;
 483         right = (volume >> 8) & 0xff;
 484         if (right > 100)
 485                 right = 100;
 486         *aleft = left;
 487         *aright = right;
 488         return 0;
 489 }
 490
 491 static int ret_vol_mono(int left)
 492 {
 493         return ((left << 8) | left);
 494 }
 495
 496 static int ret_vol_stereo(int left, int right)
 497 {
 498         return ((right << 8) | left);
 499 }
 500
 501 static int call_ad_mixer(struct pss_confdata *devc, unsigned int cmd,
 502                          void __user *arg)
 503 {
 504         if (devc->ad_mixer_dev != NO_WSS_MIXER)
 505                 return mixer_devs[devc->ad_mixer_dev]->ioctl(devc->ad_mixer_dev, cmd, arg);
 506         else
 507                 return -EINVAL;
 508 }
 509
 510 static int pss_mixer_ioctl (int dev, unsigned int cmd, void __user *arg)
 511 {
 512         struct pss_confdata *devc = mixer_devs[dev]->devc;
 513         int cmdf = cmd & 0xff;
 514
 515         if ((cmdf != SOUND_MIXER_VOLUME) && (cmdf != SOUND_MIXER_BASS) &&
 516                 (cmdf != SOUND_MIXER_TREBLE) && (cmdf != SOUND_MIXER_SYNTH) &&
 517                 (cmdf != SOUND_MIXER_DEVMASK) && (cmdf != SOUND_MIXER_STEREODEVS) &&
 518                 (cmdf != SOUND_MIXER_RECMASK) && (cmdf != SOUND_MIXER_CAPS) &&
 519                 (cmdf != SOUND_MIXER_RECSRC))
 520         {
 521                 return call_ad_mixer(devc, cmd, arg);
 522         }
 523
 524         if (((cmd >> 8) & 0xff) != 'M')
 525                 return -EINVAL;
 526
 527         if (_SIOC_DIR (cmd) & _SIOC_WRITE)
 528         {
 529                 switch (cmdf)
 530                 {
 531                         case SOUND_MIXER_RECSRC:
 532                                 if (devc->ad_mixer_dev != NO_WSS_MIXER)
 533                                         return call_ad_mixer(devc, cmd, arg);
 534                                 else
 535                                 {
 536                                         int v;
 537                                         if (get_user(v, (int __user *)arg))
 538                                                 return -EFAULT;
 539                                         if (v != 0)
 540                                                 return -EINVAL;
 541                                         return 0;
 542                                 }
 543                         case SOUND_MIXER_VOLUME:
 544                                 if (set_volume_stereo(arg,
 545                                         &devc->mixer.volume_l,
 546                                         &devc->mixer.volume_r))
 547                                         return -EFAULT;
 548                                 set_master_volume(devc, devc->mixer.volume_l,
 549                                         devc->mixer.volume_r);
 550                                 return ret_vol_stereo(devc->mixer.volume_l,
 551                                         devc->mixer.volume_r);
 552
 553                         case SOUND_MIXER_BASS:
 554                                 if (set_volume_mono(arg, &devc->mixer.bass))
 555                                         return -EFAULT;
 556                                 set_bass(devc, devc->mixer.bass);
 557                                 return ret_vol_mono(devc->mixer.bass);
 558
 559                         case SOUND_MIXER_TREBLE:
 560                                 if (set_volume_mono(arg, &devc->mixer.treble))
 561                                         return -EFAULT;
 562                                 set_treble(devc, devc->mixer.treble);
 563                                 return ret_vol_mono(devc->mixer.treble);
 564
 565                         case SOUND_MIXER_SYNTH:
 566                                 if (set_volume_mono(arg, &devc->mixer.synth))
 567                                         return -EFAULT;
 568                                 set_synth_volume(devc, devc->mixer.synth);
 569                                 return ret_vol_mono(devc->mixer.synth);
 570
 571                         default:
 572                                 return -EINVAL;
 573                 }
 574         }
 575         else
 576         {
 577                 int val, and_mask = 0, or_mask = 0;
 578                 /*
 579                  * Return parameters
 580                  */
 581                 switch (cmdf)
 582                 {
 583                         case SOUND_MIXER_DEVMASK:
 584                                 if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
 585                                         break;
 586                                 and_mask = ~0;
 587                                 or_mask = SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_SYNTH;
 588                                 break;
 589
 590                         case SOUND_MIXER_STEREODEVS:
 591                                 if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
 592                                         break;
 593                                 and_mask = ~0;
 594                                 or_mask = SOUND_MASK_VOLUME;
 595                                 break;
 596
 597                         case SOUND_MIXER_RECMASK:
 598                                 if (devc->ad_mixer_dev != NO_WSS_MIXER)
 599                                         return call_ad_mixer(devc, cmd, arg);
 600                                 break;
 601
 602                         case SOUND_MIXER_CAPS:
 603                                 if (devc->ad_mixer_dev != NO_WSS_MIXER)
 604                                         return call_ad_mixer(devc, cmd, arg);
 605                                 or_mask = SOUND_CAP_EXCL_INPUT;
 606                                 break;
 607
 608                         case SOUND_MIXER_RECSRC:
 609                                 if (devc->ad_mixer_dev != NO_WSS_MIXER)
 610                                         return call_ad_mixer(devc, cmd, arg);
 611                                 break;
 612
 613                         case SOUND_MIXER_VOLUME:
 614                                 or_mask =  ret_vol_stereo(devc->mixer.volume_l, devc->mixer.volume_r);
 615                                 break;
 616
 617                         case SOUND_MIXER_BASS:
 618                                 or_mask =  ret_vol_mono(devc->mixer.bass);
 619                                 break;
 620
 621                         case SOUND_MIXER_TREBLE:
 622                                 or_mask = ret_vol_mono(devc->mixer.treble);
 623                                 break;
 624
 625                         case SOUND_MIXER_SYNTH:
 626                                 or_mask = ret_vol_mono(devc->mixer.synth);
 627                                 break;
 628                         default:
 629                                 return -EINVAL;
 630                 }
 631                 if (get_user(val, (int __user *)arg))
 632                         return -EFAULT;
 633                 val &= and_mask;
 634                 val |= or_mask;
 635                 if (put_user(val, (int __user *)arg))
 636                         return -EFAULT;
 637                 return val;
 638         }
 639 }
 640
 641 static struct mixer_operations pss_mixer_operations =
 642 {
 643         .owner  = THIS_MODULE,
 644         .id     = "SOUNDPORT",
 645         .name   = "PSS-AD1848",
 646         .ioctl  = pss_mixer_ioctl
 647 };
 648
 649 static void disable_all_emulations(void)
 650 {
 651         outw(0x0000, REG(CONF_PSS));    /* 0x0400 enables joystick */
 652         outw(0x0000, REG(CONF_WSS));
 653         outw(0x0000, REG(CONF_SB));
 654         outw(0x0000, REG(CONF_MIDI));
 655         outw(0x0000, REG(CONF_CDROM));
 656 }
 657
 658 static void configure_nonsound_components(void)
 659 {
 660         /* Configure Joystick port */
 661
 662         if(pss_enable_joystick)
 663         {
 664                 outw(0x0400, REG(CONF_PSS));    /* 0x0400 enables joystick */
 665                 printk(KERN_INFO "PSS: joystick enabled.\n");
 666         }
 667         else
 668         {
 669                 printk(KERN_INFO "PSS: joystick port not enabled.\n");
 670         }
 671
 672         /* Configure CDROM port */
 673
 674         if (pss_cdrom_port == -1) {     /* If cdrom port enablation wasn't requested */
 675                 printk(KERN_INFO "PSS: CDROM port not enabled.\n");
 676         } else if (!request_region(pss_cdrom_port, 2, "PSS CDROM")) {
 677                 pss_cdrom_port = -1;
 678                 printk(KERN_ERR "PSS: CDROM I/O port conflict.\n");
 679         } else {
 680                 set_io_base(devc, CONF_CDROM, pss_cdrom_port);
 681                 printk(KERN_INFO "PSS: CDROM I/O port set to 0x%x.\n", pss_cdrom_port);
 682         }
 683 }
 684
 685 static int __init attach_pss(struct address_info *hw_config)
 686 {
 687         unsigned short  id;
 688         char tmp[100];
 689
 690         devc->base = hw_config->io_base;
 691         devc->irq = hw_config->irq;
 692         devc->dma = hw_config->dma;
 693         devc->osp = hw_config->osp;
 694         devc->ad_mixer_dev = NO_WSS_MIXER;
 695
 696         if (!probe_pss(hw_config))
 697                 return 0;
 698
 699         id = inw(REG(PSS_ID)) & 0x00ff;
 700
 701         /*
 702          * Disable all emulations. Will be enabled later (if required).
 703          */
 704
 705         disable_all_emulations();
 706
 707 #ifdef YOU_REALLY_WANT_TO_ALLOCATE_THESE_RESOURCES
 708         if (sound_alloc_dma(hw_config->dma, "PSS"))
 709         {
 710                 printk("pss.c: Can't allocate DMA channel.\n");
 711                 release_region(hw_config->io_base, 0x10);
 712                 release_region(hw_config->io_base+0x10, 0x9);
 713                 return 0;
 714         }
 715         if (!set_irq(devc, CONF_PSS, devc->irq))
 716         {
 717                 printk("PSS: IRQ allocation error.\n");
 718                 release_region(hw_config->io_base, 0x10);
 719                 release_region(hw_config->io_base+0x10, 0x9);
 720                 return 0;
 721         }
 722         if (!set_dma(devc, CONF_PSS, devc->dma))
 723         {
 724                 printk(KERN_ERR "PSS: DMA allocation error\n");
 725                 release_region(hw_config->io_base, 0x10);
 726                 release_region(hw_config->io_base+0x10, 0x9);
 727                 return 0;
 728         }
 729 #endif
 730
 731         configure_nonsound_components();
 732         pss_initialized = 1;
 733         sprintf(tmp, "ECHO-PSS  Rev. %d", id);
 734         conf_printf(tmp, hw_config);
 735         return 1;
 736 }
 737
 738 static int __init probe_pss_mpu(struct address_info *hw_config)
 739 {
 740         struct resource *ports;
 741         int timeout;
 742
 743         if (!pss_initialized)
 744                 return 0;
 745
 746         ports = request_region(hw_config->io_base, 2, "mpu401");
 747
 748         if (!ports) {
 749                 printk(KERN_ERR "PSS: MPU I/O port conflict\n");
 750                 return 0;
 751         }
 752         set_io_base(devc, CONF_MIDI, hw_config->io_base);
 753         if (!set_irq(devc, CONF_MIDI, hw_config->irq)) {
 754                 printk(KERN_ERR "PSS: MIDI IRQ allocation error.\n");
 755                 goto fail;
 756         }
 757         if (!pss_synthLen) {
 758                 printk(KERN_ERR "PSS: Can't enable MPU. MIDI synth microcode not available.\n");
 759                 goto fail;
 760         }
 761         if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST)) {
 762                 printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
 763                 goto fail;
 764         }
 765
 766         /*
 767          * Finally wait until the DSP algorithm has initialized itself and
 768          * deactivates receive interrupt.
 769          */
 770
 771         for (timeout = 900000; timeout > 0; timeout--)
 772         {
 773                 if ((inb(hw_config->io_base + 1) & 0x80) == 0)  /* Input data avail */
 774                         inb(hw_config->io_base);        /* Discard it */
 775                 else
 776                         break;  /* No more input */
 777         }
 778
 779         if (!probe_mpu401(hw_config, ports))
 780                 goto fail;
 781
 782         attach_mpu401(hw_config, THIS_MODULE);  /* Slot 1 */
 783         if (hw_config->slots[1] != -1)  /* The MPU driver installed itself */
 784                 midi_devs[hw_config->slots[1]]->coproc = &pss_coproc_operations;
 785         return 1;
 786 fail:
 787         release_region(hw_config->io_base, 2);
 788         return 0;
 789 }
 790
 791 static int pss_coproc_open(void *dev_info, int sub_device)
 792 {
 793         switch (sub_device)
 794         {
 795                 case COPR_MIDI:
 796                         if (pss_synthLen == 0)
 797                         {
 798                                 printk(KERN_ERR "PSS: MIDI synth microcode not available.\n");
 799                                 return -EIO;
 800                         }
 801                         if (nonstandard_microcode)
 802                                 if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
 803                         {
 804                                 printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
 805                                 return -EIO;
 806                         }
 807                         nonstandard_microcode = 0;
 808                         break;
 809
 810                 default:
 811                         break;
 812         }
 813         return 0;
 814 }
 815
 816 static void pss_coproc_close(void *dev_info, int sub_device)
 817 {
 818         return;
 819 }
 820
 821 static void pss_coproc_reset(void *dev_info)
 822 {
 823         if (pss_synthLen)
 824                 if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
 825                 {
 826                         printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
 827                 }
 828         nonstandard_microcode = 0;
 829 }
 830
 831 static int download_boot_block(void *dev_info, copr_buffer * buf)
 832 {
 833         if (buf->len <= 0 || buf->len > sizeof(buf->data))
 834                 return -EINVAL;
 835
 836         if (!pss_download_boot(devc, buf->data, buf->len, buf->flags))
 837         {
 838                 printk(KERN_ERR "PSS: Unable to load microcode block to DSP.\n");
 839                 return -EIO;
 840         }
 841         nonstandard_microcode = 1;      /* The MIDI microcode has been overwritten */
 842         return 0;
 843 }
 844
 845 static int pss_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
 846 {
 847         copr_buffer *buf;
 848         copr_msg *mbuf;
 849         copr_debug_buf dbuf;
 850         unsigned short tmp;
 851         unsigned long flags;
 852         unsigned short *data;
 853         int i, err;
 854         /* printk( "PSS coproc ioctl %x %x %d\n",  cmd,  arg,  local); */
 855
 856         switch (cmd)
 857         {
 858                 case SNDCTL_COPR_RESET:
 859                         pss_coproc_reset(dev_info);
 860                         return 0;
 861
 862                 case SNDCTL_COPR_LOAD:
 863                         buf = vmalloc(sizeof(copr_buffer));
 864                         if (buf == NULL)
 865                                 return -ENOSPC;
 866                         if (copy_from_user(buf, arg, sizeof(copr_buffer))) {
 867                                 vfree(buf);
 868                                 return -EFAULT;
 869                         }
 870                         err = download_boot_block(dev_info, buf);
 871                         vfree(buf);
 872                         return err;
 873
 874                 case SNDCTL_COPR_SENDMSG:
 875                         mbuf = vmalloc(sizeof(copr_msg));
 876                         if (mbuf == NULL)
 877                                 return -ENOSPC;
 878                         if (copy_from_user(mbuf, arg, sizeof(copr_msg))) {
 879                                 vfree(mbuf);
 880                                 return -EFAULT;
 881                         }
 882                         data = (unsigned short *)(mbuf->data);
 883                         spin_lock_irqsave(&lock, flags);
 884                         for (i = 0; i < mbuf->len; i++) {
 885                                 if (!pss_put_dspword(devc, *data++)) {
 886                                         spin_unlock_irqrestore(&lock,flags);
 887                                         mbuf->len = i;  /* feed back number of WORDs sent */
 888                                         err = copy_to_user(arg, mbuf, sizeof(copr_msg));
 889                                         vfree(mbuf);
 890                                         return err ? -EFAULT : -EIO;
 891                                 }
 892                         }
 893                         spin_unlock_irqrestore(&lock,flags);
 894                         vfree(mbuf);
 895                         return 0;
 896
 897                 case SNDCTL_COPR_RCVMSG:
 898                         err = 0;
 899                         mbuf = vmalloc(sizeof(copr_msg));
 900                         if (mbuf == NULL)
 901                                 return -ENOSPC;
 902                         data = (unsigned short *)mbuf->data;
 903                         spin_lock_irqsave(&lock, flags);
 904                         for (i = 0; i < sizeof(mbuf->data)/sizeof(unsigned short); i++) {
 905                                 mbuf->len = i;  /* feed back number of WORDs read */
 906                                 if (!pss_get_dspword(devc, data++)) {
 907                                         if (i == 0)
 908                                                 err = -EIO;
 909                                         break;
 910                                 }
 911                         }
 912                         spin_unlock_irqrestore(&lock,flags);
 913                         if (copy_to_user(arg, mbuf, sizeof(copr_msg)))
 914                                 err = -EFAULT;
 915                         vfree(mbuf);
 916                         return err;
 917
 918                 case SNDCTL_COPR_RDATA:
 919                         if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
 920                                 return -EFAULT;
 921                         spin_lock_irqsave(&lock, flags);
 922                         if (!pss_put_dspword(devc, 0x00d0)) {
 923                                 spin_unlock_irqrestore(&lock,flags);
 924                                 return -EIO;
 925                         }
 926                         if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
 927                                 spin_unlock_irqrestore(&lock,flags);
 928                                 return -EIO;
 929                         }
 930                         if (!pss_get_dspword(devc, &tmp)) {
 931                                 spin_unlock_irqrestore(&lock,flags);
 932                                 return -EIO;
 933                         }
 934                         dbuf.parm1 = tmp;
 935                         spin_unlock_irqrestore(&lock,flags);
 936                         if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
 937                                 return -EFAULT;
 938                         return 0;
 939
 940                 case SNDCTL_COPR_WDATA:
 941                         if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
 942                                 return -EFAULT;
 943                         spin_lock_irqsave(&lock, flags);
 944                         if (!pss_put_dspword(devc, 0x00d1)) {
 945                                 spin_unlock_irqrestore(&lock,flags);
 946                                 return -EIO;
 947                         }
 948                         if (!pss_put_dspword(devc, (unsigned short) (dbuf.parm1 & 0xffff))) {
 949                                 spin_unlock_irqrestore(&lock,flags);
 950                                 return -EIO;
 951                         }
 952                         tmp = (unsigned int)dbuf.parm2 & 0xffff;
 953                         if (!pss_put_dspword(devc, tmp)) {
 954                                 spin_unlock_irqrestore(&lock,flags);
 955                                 return -EIO;
 956                         }
 957                         spin_unlock_irqrestore(&lock,flags);
 958                         return 0;
 959
 960                 case SNDCTL_COPR_WCODE:
 961                         if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
 962                                 return -EFAULT;
 963                         spin_lock_irqsave(&lock, flags);
 964                         if (!pss_put_dspword(devc, 0x00d3)) {
 965                                 spin_unlock_irqrestore(&lock,flags);
 966                                 return -EIO;
 967                         }
 968                         if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
 969                                 spin_unlock_irqrestore(&lock,flags);
 970                                 return -EIO;
 971                         }
 972                         tmp = (unsigned int)dbuf.parm2 & 0x00ff;
 973                         if (!pss_put_dspword(devc, tmp)) {
 974                                 spin_unlock_irqrestore(&lock,flags);
 975                                 return -EIO;
 976                         }
 977                         tmp = ((unsigned int)dbuf.parm2 >> 8) & 0xffff;
 978                         if (!pss_put_dspword(devc, tmp)) {
 979                                 spin_unlock_irqrestore(&lock,flags);
 980                                 return -EIO;
 981                         }
 982                         spin_unlock_irqrestore(&lock,flags);
 983                         return 0;
 984
 985                 case SNDCTL_COPR_RCODE:
 986                         if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
 987                                 return -EFAULT;
 988                         spin_lock_irqsave(&lock, flags);
 989                         if (!pss_put_dspword(devc, 0x00d2)) {
 990                                 spin_unlock_irqrestore(&lock,flags);
 991                                 return -EIO;
 992                         }
 993                         if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
 994                                 spin_unlock_irqrestore(&lock,flags);
 995                                 return -EIO;
 996                         }
 997                         if (!pss_get_dspword(devc, &tmp)) { /* Read MSB */
 998                                 spin_unlock_irqrestore(&lock,flags);
 999                                 return -EIO;
1000                         }
1001                         dbuf.parm1 = tmp << 8;
1002                         if (!pss_get_dspword(devc, &tmp)) { /* Read LSB */
1003                                 spin_unlock_irqrestore(&lock,flags);
1004                                 return -EIO;
1005                         }
1006                         dbuf.parm1 |= tmp & 0x00ff;
1007                         spin_unlock_irqrestore(&lock,flags);
1008                         if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
1009                                 return -EFAULT;
1010                         return 0;
1011
1012                 default:
1013                         return -EINVAL;
1014         }
1015         return -EINVAL;
1016 }
1017
1018 static coproc_operations pss_coproc_operations =
1019 {
1020         "ADSP-2115",
1021         THIS_MODULE,
1022         pss_coproc_open,
1023         pss_coproc_close,
1024         pss_coproc_ioctl,
1025         pss_coproc_reset,
1026         &pss_data
1027 };
1028
1029 static int __init probe_pss_mss(struct address_info *hw_config)
1030 {
1031         volatile int timeout;
1032         struct resource *ports;
1033         int        my_mix = -999;       /* gcc shut up */
1034
1035         if (!pss_initialized)
1036                 return 0;
1037
1038         if (!request_region(hw_config->io_base, 4, "WSS config")) {
1039                 printk(KERN_ERR "PSS: WSS I/O port conflicts.\n");
1040                 return 0;
1041         }
1042         ports = request_region(hw_config->io_base + 4, 4, "ad1848");
1043         if (!ports) {
1044                 printk(KERN_ERR "PSS: WSS I/O port conflicts.\n");
1045                 release_region(hw_config->io_base, 4);
1046                 return 0;
1047         }
1048         set_io_base(devc, CONF_WSS, hw_config->io_base);
1049         if (!set_irq(devc, CONF_WSS, hw_config->irq)) {
1050                 printk("PSS: WSS IRQ allocation error.\n");
1051                 goto fail;
1052         }
1053         if (!set_dma(devc, CONF_WSS, hw_config->dma)) {
1054                 printk(KERN_ERR "PSS: WSS DMA allocation error\n");
1055                 goto fail;
1056         }
1057         /*
1058          * For some reason the card returns 0xff in the WSS status register
1059          * immediately after boot. Probably MIDI+SB emulation algorithm
1060          * downloaded to the ADSP2115 spends some time initializing the card.
1061          * Let's try to wait until it finishes this task.
1062          */
1063         for (timeout = 0; timeout < 100000 && (inb(hw_config->io_base + WSS_INDEX) &
1064           WSS_INITIALIZING); timeout++)
1065                 ;
1066
1067         outb((0x0b), hw_config->io_base + WSS_INDEX);   /* Required by some cards */
1068
1069         for (timeout = 0; (inb(hw_config->io_base + WSS_DATA) & WSS_AUTOCALIBRATION) &&
1070           (timeout < 100000); timeout++)
1071                 ;
1072
1073         if (!probe_ms_sound(hw_config, ports))
1074                 goto fail;
1075
1076         devc->ad_mixer_dev = NO_WSS_MIXER;
1077         if (pss_mixer)
1078         {
1079                 if ((my_mix = sound_install_mixer (MIXER_DRIVER_VERSION,
1080                         "PSS-SPEAKERS and AD1848 (through MSS audio codec)",
1081                         &pss_mixer_operations,
1082                         sizeof (struct mixer_operations),
1083                         devc)) < 0)
1084                 {
1085                         printk(KERN_ERR "Could not install PSS mixer\n");
1086                         goto fail;
1087                 }
1088         }
1089         pss_mixer_reset(devc);
1090         attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */
1091
1092         if (hw_config->slots[0] != -1)
1093         {
1094                 /* The MSS driver installed itself */
1095                 audio_devs[hw_config->slots[0]]->coproc = &pss_coproc_operations;
1096                 if (pss_mixer && (num_mixers == (my_mix + 2)))
1097                 {
1098                         /* The MSS mixer installed */
1099                         devc->ad_mixer_dev = audio_devs[hw_config->slots[0]]->mixer_dev;
1100                 }
1101         }
1102         return 1;
1103 fail:
1104         release_region(hw_config->io_base + 4, 4);
1105         release_region(hw_config->io_base, 4);
1106         return 0;
1107 }
1108
1109 static inline void __exit unload_pss(struct address_info *hw_config)
1110 {
1111         release_region(hw_config->io_base, 0x10);
1112         release_region(hw_config->io_base+0x10, 0x9);
1113 }
1114
1115 static inline void __exit unload_pss_mpu(struct address_info *hw_config)
1116 {
1117         unload_mpu401(hw_config);
1118 }
1119
1120 static inline void __exit unload_pss_mss(struct address_info *hw_config)
1121 {
1122         unload_ms_sound(hw_config);
1123 }
1124
1125
1126 static struct address_info cfg;
1127 static struct address_info cfg2;
1128 static struct address_info cfg_mpu;
1129
1130 static int pss_io __initdata    = -1;
1131 static int mss_io __initdata    = -1;
1132 static int mss_irq __initdata   = -1;
1133 static int mss_dma __initdata   = -1;
1134 static int mpu_io __initdata    = -1;
1135 static int mpu_irq __initdata   = -1;
1136 static bool pss_no_sound = 0;   /* Just configure non-sound components */
1137 static bool pss_keep_settings  = 1;     /* Keep hardware settings at module exit */
1138 static char *pss_firmware = "/*(DEBLOBBED)*/";
1139
1140 module_param(pss_io, int, 0);
1141 MODULE_PARM_DESC(pss_io, "Set i/o base of PSS card (probably 0x220 or 0x240)");
1142 module_param(mss_io, int, 0);
1143 MODULE_PARM_DESC(mss_io, "Set WSS (audio) i/o base (0x530, 0x604, 0xE80, 0xF40, or other. Address must end in 0 or 4 and must be from 0x100 to 0xFF4)");
1144 module_param(mss_irq, int, 0);
1145 MODULE_PARM_DESC(mss_irq, "Set WSS (audio) IRQ (3, 5, 7, 9, 10, 11, 12)");
1146 module_param(mss_dma, int, 0);
1147 MODULE_PARM_DESC(mss_dma, "Set WSS (audio) DMA (0, 1, 3)");
1148 module_param(mpu_io, int, 0);
1149 MODULE_PARM_DESC(mpu_io, "Set MIDI i/o base (0x330 or other. Address must be on 4 location boundaries and must be from 0x100 to 0xFFC)");
1150 module_param(mpu_irq, int, 0);
1151 MODULE_PARM_DESC(mpu_irq, "Set MIDI IRQ (3, 5, 7, 9, 10, 11, 12)");
1152 module_param(pss_cdrom_port, int, 0);
1153 MODULE_PARM_DESC(pss_cdrom_port, "Set the PSS CDROM port i/o base (0x340 or other)");
1154 module_param(pss_enable_joystick, bool, 0);
1155 MODULE_PARM_DESC(pss_enable_joystick, "Enables the PSS joystick port (1 to enable, 0 to disable)");
1156 module_param(pss_no_sound, bool, 0);
1157 MODULE_PARM_DESC(pss_no_sound, "Configure sound compoents (0 - no, 1 - yes)");
1158 module_param(pss_keep_settings, bool, 0);
1159 MODULE_PARM_DESC(pss_keep_settings, "Keep hardware setting at driver unloading (0 - no, 1 - yes)");
1160 module_param(pss_firmware, charp, 0);
1161 MODULE_PARM_DESC(pss_firmware, "Location of the firmware file (default - /*(DEBLOBBED)*/)");
1162 module_param(pss_mixer, bool, 0);
1163 MODULE_PARM_DESC(pss_mixer, "Enable (1) or disable (0) PSS mixer (controlling of output volume, bass, treble, synth volume). The mixer is not available on all PSS cards.");
1164 MODULE_AUTHOR("Hannu Savolainen, Vladimir Michl");
1165 MODULE_DESCRIPTION("Module for PSS sound cards (based on AD1848, ADSP-2115 and ESC614). This module includes control of output amplifier and synth volume of the Beethoven ADSP-16 card (this may work with other PSS cards).");
1166 MODULE_LICENSE("GPL");
1167
1168
1169 static int fw_load = 0;
1170 static int pssmpu = 0, pssmss = 0;
1171
1172 /*
1173  *    Load a PSS sound card module
1174  */
1175
1176 static int __init init_pss(void)
1177 {
1178
1179         if(pss_no_sound)                /* If configuring only nonsound components */
1180         {
1181                 cfg.io_base = pss_io;
1182                 if(!probe_pss(&cfg))
1183                         return -ENODEV;
1184                 printk(KERN_INFO "ECHO-PSS  Rev. %d\n", inw(REG(PSS_ID)) & 0x00ff);
1185                 printk(KERN_INFO "PSS: loading in no sound mode.\n");
1186                 disable_all_emulations();
1187                 configure_nonsound_components();
1188                 release_region(pss_io, 0x10);
1189                 release_region(pss_io + 0x10, 0x9);
1190                 return 0;
1191         }
1192
1193         cfg.io_base = pss_io;
1194
1195         cfg2.io_base = mss_io;
1196         cfg2.irq = mss_irq;
1197         cfg2.dma = mss_dma;
1198
1199         cfg_mpu.io_base = mpu_io;
1200         cfg_mpu.irq = mpu_irq;
1201
1202         if (cfg.io_base == -1 || cfg2.io_base == -1 || cfg2.irq == -1 || cfg.dma == -1) {
1203                 printk(KERN_INFO "pss: mss_io, mss_dma, mss_irq and pss_io must be set.\n");
1204                 return -EINVAL;
1205         }
1206
1207         if (!pss_synth) {
1208                 fw_load = 1;
1209                 pss_synthLen = mod_firmware_load(pss_firmware, (void *) &pss_synth);
1210         }
1211         if (!attach_pss(&cfg))
1212                 return -ENODEV;
1213         /*
1214          *    Attach stuff
1215          */
1216         if (probe_pss_mpu(&cfg_mpu))
1217                 pssmpu = 1;
1218
1219         if (probe_pss_mss(&cfg2))
1220                 pssmss = 1;
1221
1222         return 0;
1223 }
1224
1225 static void __exit cleanup_pss(void)
1226 {
1227         if(!pss_no_sound)
1228         {
1229                 if (fw_load)
1230                         vfree(pss_synth);
1231                 if(pssmss)
1232                         unload_pss_mss(&cfg2);
1233                 if(pssmpu)
1234                         unload_pss_mpu(&cfg_mpu);
1235                 unload_pss(&cfg);
1236         } else if (pss_cdrom_port != -1)
1237                 release_region(pss_cdrom_port, 2);
1238
1239         if(!pss_keep_settings)  /* Keep hardware settings if asked */
1240         {
1241                 disable_all_emulations();
1242                 printk(KERN_INFO "Resetting PSS sound card configurations.\n");
1243         }
1244 }
1245
1246 module_init(init_pss);
1247 module_exit(cleanup_pss);
1248
1249 #ifndef MODULE
1250 static int __init setup_pss(char *str)
1251 {
1252         /* io, mss_io, mss_irq, mss_dma, mpu_io, mpu_irq */
1253         int ints[7];
1254
1255         str = get_options(str, ARRAY_SIZE(ints), ints);
1256
1257         pss_io  = ints[1];
1258         mss_io  = ints[2];
1259         mss_irq = ints[3];
1260         mss_dma = ints[4];
1261         mpu_io  = ints[5];
1262         mpu_irq = ints[6];
1263
1264         return 1;
1265 }
1266
1267 __setup("pss=", setup_pss);
1268 #endif