sound/oss/pss.c

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